{-# 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.ApplicationInsights.Types.Problem
-- 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.ApplicationInsights.Types.Problem where

import Amazonka.ApplicationInsights.Types.FeedbackKey
import Amazonka.ApplicationInsights.Types.FeedbackValue
import Amazonka.ApplicationInsights.Types.SeverityLevel
import Amazonka.ApplicationInsights.Types.Status
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

-- | Describes a problem that is detected by correlating observations.
--
-- /See:/ 'newProblem' smart constructor.
data Problem = Problem'
  { -- | The resource affected by the problem.
    Problem -> Maybe Text
affectedResource :: Prelude.Maybe Prelude.Text,
    -- | The time when the problem ended, in epoch seconds.
    Problem -> Maybe POSIX
endTime :: Prelude.Maybe Data.POSIX,
    -- | Feedback provided by the user about the problem.
    Problem -> Maybe (HashMap FeedbackKey FeedbackValue)
feedback :: Prelude.Maybe (Prelude.HashMap FeedbackKey FeedbackValue),
    -- | The ID of the problem.
    Problem -> Maybe Text
id :: Prelude.Maybe Prelude.Text,
    -- | A detailed analysis of the problem using machine learning.
    Problem -> Maybe Text
insights :: Prelude.Maybe Prelude.Text,
    -- | The last time that the problem reoccurred after its last resolution.
    Problem -> Maybe POSIX
lastRecurrenceTime :: Prelude.Maybe Data.POSIX,
    -- | The number of times that the same problem reoccurred after the first
    -- time it was resolved.
    Problem -> Maybe Integer
recurringCount :: Prelude.Maybe Prelude.Integer,
    -- | The name of the resource group affected by the problem.
    Problem -> Maybe Text
resourceGroupName :: Prelude.Maybe Prelude.Text,
    -- | A measure of the level of impact of the problem.
    Problem -> Maybe SeverityLevel
severityLevel :: Prelude.Maybe SeverityLevel,
    -- | The time when the problem started, in epoch seconds.
    Problem -> Maybe POSIX
startTime :: Prelude.Maybe Data.POSIX,
    -- | The status of the problem.
    Problem -> Maybe Status
status :: Prelude.Maybe Status,
    -- | The name of the problem.
    Problem -> Maybe Text
title :: Prelude.Maybe Prelude.Text
  }
  deriving (Problem -> Problem -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Problem -> Problem -> Bool
$c/= :: Problem -> Problem -> Bool
== :: Problem -> Problem -> Bool
$c== :: Problem -> Problem -> Bool
Prelude.Eq, ReadPrec [Problem]
ReadPrec Problem
Int -> ReadS Problem
ReadS [Problem]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Problem]
$creadListPrec :: ReadPrec [Problem]
readPrec :: ReadPrec Problem
$creadPrec :: ReadPrec Problem
readList :: ReadS [Problem]
$creadList :: ReadS [Problem]
readsPrec :: Int -> ReadS Problem
$creadsPrec :: Int -> ReadS Problem
Prelude.Read, Int -> Problem -> ShowS
[Problem] -> ShowS
Problem -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Problem] -> ShowS
$cshowList :: [Problem] -> ShowS
show :: Problem -> String
$cshow :: Problem -> String
showsPrec :: Int -> Problem -> ShowS
$cshowsPrec :: Int -> Problem -> ShowS
Prelude.Show, forall x. Rep Problem x -> Problem
forall x. Problem -> Rep Problem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Problem x -> Problem
$cfrom :: forall x. Problem -> Rep Problem x
Prelude.Generic)

-- |
-- Create a value of 'Problem' 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:
--
-- 'affectedResource', 'problem_affectedResource' - The resource affected by the problem.
--
-- 'endTime', 'problem_endTime' - The time when the problem ended, in epoch seconds.
--
-- 'feedback', 'problem_feedback' - Feedback provided by the user about the problem.
--
-- 'id', 'problem_id' - The ID of the problem.
--
-- 'insights', 'problem_insights' - A detailed analysis of the problem using machine learning.
--
-- 'lastRecurrenceTime', 'problem_lastRecurrenceTime' - The last time that the problem reoccurred after its last resolution.
--
-- 'recurringCount', 'problem_recurringCount' - The number of times that the same problem reoccurred after the first
-- time it was resolved.
--
-- 'resourceGroupName', 'problem_resourceGroupName' - The name of the resource group affected by the problem.
--
-- 'severityLevel', 'problem_severityLevel' - A measure of the level of impact of the problem.
--
-- 'startTime', 'problem_startTime' - The time when the problem started, in epoch seconds.
--
-- 'status', 'problem_status' - The status of the problem.
--
-- 'title', 'problem_title' - The name of the problem.
newProblem ::
  Problem
newProblem :: Problem
newProblem =
  Problem'
    { $sel:affectedResource:Problem' :: Maybe Text
affectedResource = forall a. Maybe a
Prelude.Nothing,
      $sel:endTime:Problem' :: Maybe POSIX
endTime = forall a. Maybe a
Prelude.Nothing,
      $sel:feedback:Problem' :: Maybe (HashMap FeedbackKey FeedbackValue)
feedback = forall a. Maybe a
Prelude.Nothing,
      $sel:id:Problem' :: Maybe Text
id = forall a. Maybe a
Prelude.Nothing,
      $sel:insights:Problem' :: Maybe Text
insights = forall a. Maybe a
Prelude.Nothing,
      $sel:lastRecurrenceTime:Problem' :: Maybe POSIX
lastRecurrenceTime = forall a. Maybe a
Prelude.Nothing,
      $sel:recurringCount:Problem' :: Maybe Integer
recurringCount = forall a. Maybe a
Prelude.Nothing,
      $sel:resourceGroupName:Problem' :: Maybe Text
resourceGroupName = forall a. Maybe a
Prelude.Nothing,
      $sel:severityLevel:Problem' :: Maybe SeverityLevel
severityLevel = forall a. Maybe a
Prelude.Nothing,
      $sel:startTime:Problem' :: Maybe POSIX
startTime = forall a. Maybe a
Prelude.Nothing,
      $sel:status:Problem' :: Maybe Status
status = forall a. Maybe a
Prelude.Nothing,
      $sel:title:Problem' :: Maybe Text
title = forall a. Maybe a
Prelude.Nothing
    }

-- | The resource affected by the problem.
problem_affectedResource :: Lens.Lens' Problem (Prelude.Maybe Prelude.Text)
problem_affectedResource :: Lens' Problem (Maybe Text)
problem_affectedResource = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Problem' {Maybe Text
affectedResource :: Maybe Text
$sel:affectedResource:Problem' :: Problem -> Maybe Text
affectedResource} -> Maybe Text
affectedResource) (\s :: Problem
s@Problem' {} Maybe Text
a -> Problem
s {$sel:affectedResource:Problem' :: Maybe Text
affectedResource = Maybe Text
a} :: Problem)

-- | The time when the problem ended, in epoch seconds.
problem_endTime :: Lens.Lens' Problem (Prelude.Maybe Prelude.UTCTime)
problem_endTime :: Lens' Problem (Maybe UTCTime)
problem_endTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Problem' {Maybe POSIX
endTime :: Maybe POSIX
$sel:endTime:Problem' :: Problem -> Maybe POSIX
endTime} -> Maybe POSIX
endTime) (\s :: Problem
s@Problem' {} Maybe POSIX
a -> Problem
s {$sel:endTime:Problem' :: Maybe POSIX
endTime = Maybe POSIX
a} :: Problem) 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

-- | Feedback provided by the user about the problem.
problem_feedback :: Lens.Lens' Problem (Prelude.Maybe (Prelude.HashMap FeedbackKey FeedbackValue))
problem_feedback :: Lens' Problem (Maybe (HashMap FeedbackKey FeedbackValue))
problem_feedback = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Problem' {Maybe (HashMap FeedbackKey FeedbackValue)
feedback :: Maybe (HashMap FeedbackKey FeedbackValue)
$sel:feedback:Problem' :: Problem -> Maybe (HashMap FeedbackKey FeedbackValue)
feedback} -> Maybe (HashMap FeedbackKey FeedbackValue)
feedback) (\s :: Problem
s@Problem' {} Maybe (HashMap FeedbackKey FeedbackValue)
a -> Problem
s {$sel:feedback:Problem' :: Maybe (HashMap FeedbackKey FeedbackValue)
feedback = Maybe (HashMap FeedbackKey FeedbackValue)
a} :: Problem) 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 problem.
problem_id :: Lens.Lens' Problem (Prelude.Maybe Prelude.Text)
problem_id :: Lens' Problem (Maybe Text)
problem_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Problem' {Maybe Text
id :: Maybe Text
$sel:id:Problem' :: Problem -> Maybe Text
id} -> Maybe Text
id) (\s :: Problem
s@Problem' {} Maybe Text
a -> Problem
s {$sel:id:Problem' :: Maybe Text
id = Maybe Text
a} :: Problem)

-- | A detailed analysis of the problem using machine learning.
problem_insights :: Lens.Lens' Problem (Prelude.Maybe Prelude.Text)
problem_insights :: Lens' Problem (Maybe Text)
problem_insights = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Problem' {Maybe Text
insights :: Maybe Text
$sel:insights:Problem' :: Problem -> Maybe Text
insights} -> Maybe Text
insights) (\s :: Problem
s@Problem' {} Maybe Text
a -> Problem
s {$sel:insights:Problem' :: Maybe Text
insights = Maybe Text
a} :: Problem)

-- | The last time that the problem reoccurred after its last resolution.
problem_lastRecurrenceTime :: Lens.Lens' Problem (Prelude.Maybe Prelude.UTCTime)
problem_lastRecurrenceTime :: Lens' Problem (Maybe UTCTime)
problem_lastRecurrenceTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Problem' {Maybe POSIX
lastRecurrenceTime :: Maybe POSIX
$sel:lastRecurrenceTime:Problem' :: Problem -> Maybe POSIX
lastRecurrenceTime} -> Maybe POSIX
lastRecurrenceTime) (\s :: Problem
s@Problem' {} Maybe POSIX
a -> Problem
s {$sel:lastRecurrenceTime:Problem' :: Maybe POSIX
lastRecurrenceTime = Maybe POSIX
a} :: Problem) 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 number of times that the same problem reoccurred after the first
-- time it was resolved.
problem_recurringCount :: Lens.Lens' Problem (Prelude.Maybe Prelude.Integer)
problem_recurringCount :: Lens' Problem (Maybe Integer)
problem_recurringCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Problem' {Maybe Integer
recurringCount :: Maybe Integer
$sel:recurringCount:Problem' :: Problem -> Maybe Integer
recurringCount} -> Maybe Integer
recurringCount) (\s :: Problem
s@Problem' {} Maybe Integer
a -> Problem
s {$sel:recurringCount:Problem' :: Maybe Integer
recurringCount = Maybe Integer
a} :: Problem)

-- | The name of the resource group affected by the problem.
problem_resourceGroupName :: Lens.Lens' Problem (Prelude.Maybe Prelude.Text)
problem_resourceGroupName :: Lens' Problem (Maybe Text)
problem_resourceGroupName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Problem' {Maybe Text
resourceGroupName :: Maybe Text
$sel:resourceGroupName:Problem' :: Problem -> Maybe Text
resourceGroupName} -> Maybe Text
resourceGroupName) (\s :: Problem
s@Problem' {} Maybe Text
a -> Problem
s {$sel:resourceGroupName:Problem' :: Maybe Text
resourceGroupName = Maybe Text
a} :: Problem)

-- | A measure of the level of impact of the problem.
problem_severityLevel :: Lens.Lens' Problem (Prelude.Maybe SeverityLevel)
problem_severityLevel :: Lens' Problem (Maybe SeverityLevel)
problem_severityLevel = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Problem' {Maybe SeverityLevel
severityLevel :: Maybe SeverityLevel
$sel:severityLevel:Problem' :: Problem -> Maybe SeverityLevel
severityLevel} -> Maybe SeverityLevel
severityLevel) (\s :: Problem
s@Problem' {} Maybe SeverityLevel
a -> Problem
s {$sel:severityLevel:Problem' :: Maybe SeverityLevel
severityLevel = Maybe SeverityLevel
a} :: Problem)

-- | The time when the problem started, in epoch seconds.
problem_startTime :: Lens.Lens' Problem (Prelude.Maybe Prelude.UTCTime)
problem_startTime :: Lens' Problem (Maybe UTCTime)
problem_startTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Problem' {Maybe POSIX
startTime :: Maybe POSIX
$sel:startTime:Problem' :: Problem -> Maybe POSIX
startTime} -> Maybe POSIX
startTime) (\s :: Problem
s@Problem' {} Maybe POSIX
a -> Problem
s {$sel:startTime:Problem' :: Maybe POSIX
startTime = Maybe POSIX
a} :: Problem) 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 problem.
problem_status :: Lens.Lens' Problem (Prelude.Maybe Status)
problem_status :: Lens' Problem (Maybe Status)
problem_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Problem' {Maybe Status
status :: Maybe Status
$sel:status:Problem' :: Problem -> Maybe Status
status} -> Maybe Status
status) (\s :: Problem
s@Problem' {} Maybe Status
a -> Problem
s {$sel:status:Problem' :: Maybe Status
status = Maybe Status
a} :: Problem)

-- | The name of the problem.
problem_title :: Lens.Lens' Problem (Prelude.Maybe Prelude.Text)
problem_title :: Lens' Problem (Maybe Text)
problem_title = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Problem' {Maybe Text
title :: Maybe Text
$sel:title:Problem' :: Problem -> Maybe Text
title} -> Maybe Text
title) (\s :: Problem
s@Problem' {} Maybe Text
a -> Problem
s {$sel:title:Problem' :: Maybe Text
title = Maybe Text
a} :: Problem)

instance Data.FromJSON Problem where
  parseJSON :: Value -> Parser Problem
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Problem"
      ( \Object
x ->
          Maybe Text
-> Maybe POSIX
-> Maybe (HashMap FeedbackKey FeedbackValue)
-> Maybe Text
-> Maybe Text
-> Maybe POSIX
-> Maybe Integer
-> Maybe Text
-> Maybe SeverityLevel
-> Maybe POSIX
-> Maybe Status
-> Maybe Text
-> Problem
Problem'
            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
"AffectedResource")
            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
"EndTime")
            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
"Feedback" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            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
"Id")
            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
"Insights")
            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
"LastRecurrenceTime")
            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
"RecurringCount")
            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
"ResourceGroupName")
            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
"SeverityLevel")
            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
"StartTime")
            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
"Title")
      )

instance Prelude.Hashable Problem where
  hashWithSalt :: Int -> Problem -> Int
hashWithSalt Int
_salt Problem' {Maybe Integer
Maybe Text
Maybe (HashMap FeedbackKey FeedbackValue)
Maybe POSIX
Maybe SeverityLevel
Maybe Status
title :: Maybe Text
status :: Maybe Status
startTime :: Maybe POSIX
severityLevel :: Maybe SeverityLevel
resourceGroupName :: Maybe Text
recurringCount :: Maybe Integer
lastRecurrenceTime :: Maybe POSIX
insights :: Maybe Text
id :: Maybe Text
feedback :: Maybe (HashMap FeedbackKey FeedbackValue)
endTime :: Maybe POSIX
affectedResource :: Maybe Text
$sel:title:Problem' :: Problem -> Maybe Text
$sel:status:Problem' :: Problem -> Maybe Status
$sel:startTime:Problem' :: Problem -> Maybe POSIX
$sel:severityLevel:Problem' :: Problem -> Maybe SeverityLevel
$sel:resourceGroupName:Problem' :: Problem -> Maybe Text
$sel:recurringCount:Problem' :: Problem -> Maybe Integer
$sel:lastRecurrenceTime:Problem' :: Problem -> Maybe POSIX
$sel:insights:Problem' :: Problem -> Maybe Text
$sel:id:Problem' :: Problem -> Maybe Text
$sel:feedback:Problem' :: Problem -> Maybe (HashMap FeedbackKey FeedbackValue)
$sel:endTime:Problem' :: Problem -> Maybe POSIX
$sel:affectedResource:Problem' :: Problem -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
affectedResource
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
endTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap FeedbackKey FeedbackValue)
feedback
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
id
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
insights
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
lastRecurrenceTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Integer
recurringCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
resourceGroupName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SeverityLevel
severityLevel
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
startTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Status
status
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
title

instance Prelude.NFData Problem where
  rnf :: Problem -> ()
rnf Problem' {Maybe Integer
Maybe Text
Maybe (HashMap FeedbackKey FeedbackValue)
Maybe POSIX
Maybe SeverityLevel
Maybe Status
title :: Maybe Text
status :: Maybe Status
startTime :: Maybe POSIX
severityLevel :: Maybe SeverityLevel
resourceGroupName :: Maybe Text
recurringCount :: Maybe Integer
lastRecurrenceTime :: Maybe POSIX
insights :: Maybe Text
id :: Maybe Text
feedback :: Maybe (HashMap FeedbackKey FeedbackValue)
endTime :: Maybe POSIX
affectedResource :: Maybe Text
$sel:title:Problem' :: Problem -> Maybe Text
$sel:status:Problem' :: Problem -> Maybe Status
$sel:startTime:Problem' :: Problem -> Maybe POSIX
$sel:severityLevel:Problem' :: Problem -> Maybe SeverityLevel
$sel:resourceGroupName:Problem' :: Problem -> Maybe Text
$sel:recurringCount:Problem' :: Problem -> Maybe Integer
$sel:lastRecurrenceTime:Problem' :: Problem -> Maybe POSIX
$sel:insights:Problem' :: Problem -> Maybe Text
$sel:id:Problem' :: Problem -> Maybe Text
$sel:feedback:Problem' :: Problem -> Maybe (HashMap FeedbackKey FeedbackValue)
$sel:endTime:Problem' :: Problem -> Maybe POSIX
$sel:affectedResource:Problem' :: Problem -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
affectedResource
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
endTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap FeedbackKey FeedbackValue)
feedback
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
id
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
insights
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
lastRecurrenceTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Integer
recurringCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
resourceGroupName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SeverityLevel
severityLevel
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
startTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Status
status
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
title