{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE ImportQualifiedPost #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
{-# OPTIONS_GHC -fno-warn-name-shadowing #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- |
-- Module      : Gogol.ToolResults.Internal.Product
-- Copyright   : (c) 2015-2025 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+gogol@gmail.com>
--               Toni Cebrián <toni@tonicebrian.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Gogol.ToolResults.Internal.Product
  ( -- * ANR
    ANR (..),
    newANR,

    -- * AvailableDeepLinks
    AvailableDeepLinks (..),
    newAvailableDeepLinks,

    -- * BlankScreen
    BlankScreen (..),
    newBlankScreen,

    -- * CrashDialogError
    CrashDialogError (..),
    newCrashDialogError,

    -- * EncounteredLoginScreen
    EncounteredLoginScreen (..),
    newEncounteredLoginScreen,

    -- * EncounteredNonAndroidUiWidgetScreen
    EncounteredNonAndroidUiWidgetScreen (..),
    newEncounteredNonAndroidUiWidgetScreen,

    -- * FailedToInstall
    FailedToInstall (..),
    newFailedToInstall,

    -- * FatalException
    FatalException (..),
    newFatalException,

    -- * InAppPurchasesFound
    InAppPurchasesFound (..),
    newInAppPurchasesFound,

    -- * InsufficientCoverage
    InsufficientCoverage (..),
    newInsufficientCoverage,

    -- * IosAppCrashed
    IosAppCrashed (..),
    newIosAppCrashed,

    -- * LauncherActivityNotFound
    LauncherActivityNotFound (..),
    newLauncherActivityNotFound,

    -- * NativeCrash
    NativeCrash (..),
    newNativeCrash,

    -- * NonSdkApi
    NonSdkApi (..),
    newNonSdkApi,

    -- * NonSdkApiInsight
    NonSdkApiInsight (..),
    newNonSdkApiInsight,

    -- * NonSdkApiUsageViolation
    NonSdkApiUsageViolation (..),
    newNonSdkApiUsageViolation,

    -- * NonSdkApiUsageViolationReport
    NonSdkApiUsageViolationReport (..),
    newNonSdkApiUsageViolationReport,

    -- * OverlappingUIElements
    OverlappingUIElements (..),
    newOverlappingUIElements,

    -- * PendingGoogleUpdateInsight
    PendingGoogleUpdateInsight (..),
    newPendingGoogleUpdateInsight,

    -- * PerformedGoogleLogin
    PerformedGoogleLogin (..),
    newPerformedGoogleLogin,

    -- * PerformedMonkeyActions
    PerformedMonkeyActions (..),
    newPerformedMonkeyActions,

    -- * RoboScriptExecution
    RoboScriptExecution (..),
    newRoboScriptExecution,

    -- * StackTrace
    StackTrace (..),
    newStackTrace,

    -- * StartActivityNotFound
    StartActivityNotFound (..),
    newStartActivityNotFound,

    -- * UIElementTooDeep
    UIElementTooDeep (..),
    newUIElementTooDeep,

    -- * UnspecifiedWarning
    UnspecifiedWarning (..),
    newUnspecifiedWarning,

    -- * UnusedRoboDirective
    UnusedRoboDirective (..),
    newUnusedRoboDirective,

    -- * UpgradeInsight
    UpgradeInsight (..),
    newUpgradeInsight,

    -- * UsedRoboDirective
    UsedRoboDirective (..),
    newUsedRoboDirective,

    -- * UsedRoboIgnoreDirective
    UsedRoboIgnoreDirective (..),
    newUsedRoboIgnoreDirective,
  )
where

import Gogol.Prelude qualified as Core
import Gogol.ToolResults.Internal.Sum

-- | Additional details for an ANR crash.
--
-- /See:/ 'newANR' smart constructor.
newtype ANR = ANR
  { -- | The stack trace of the ANR crash. Optional.
    ANR -> Maybe StackTrace
stackTrace :: (Core.Maybe StackTrace)
  }
  deriving (ANR -> ANR -> Bool
(ANR -> ANR -> Bool) -> (ANR -> ANR -> Bool) -> Eq ANR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ANR -> ANR -> Bool
== :: ANR -> ANR -> Bool
$c/= :: ANR -> ANR -> Bool
/= :: ANR -> ANR -> Bool
Core.Eq, Int -> ANR -> ShowS
[ANR] -> ShowS
ANR -> String
(Int -> ANR -> ShowS)
-> (ANR -> String) -> ([ANR] -> ShowS) -> Show ANR
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ANR -> ShowS
showsPrec :: Int -> ANR -> ShowS
$cshow :: ANR -> String
show :: ANR -> String
$cshowList :: [ANR] -> ShowS
showList :: [ANR] -> ShowS
Core.Show, (forall x. ANR -> Rep ANR x)
-> (forall x. Rep ANR x -> ANR) -> Generic ANR
forall x. Rep ANR x -> ANR
forall x. ANR -> Rep ANR x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ANR -> Rep ANR x
from :: forall x. ANR -> Rep ANR x
$cto :: forall x. Rep ANR x -> ANR
to :: forall x. Rep ANR x -> ANR
Core.Generic)

-- | Creates a value of 'ANR' with the minimum fields required to make a request.
newANR ::
  ANR
newANR :: ANR
newANR = ANR {stackTrace :: Maybe StackTrace
stackTrace = Maybe StackTrace
forall a. Maybe a
Core.Nothing}

instance Core.FromJSON ANR where
  parseJSON :: Value -> Parser ANR
parseJSON =
    String -> (Object -> Parser ANR) -> Value -> Parser ANR
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"ANR"
      (\Object
o -> Maybe StackTrace -> ANR
ANR (Maybe StackTrace -> ANR)
-> Parser (Maybe StackTrace) -> Parser ANR
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe StackTrace)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"stackTrace"))

instance Core.ToJSON ANR where
  toJSON :: ANR -> Value
toJSON ANR {Maybe StackTrace
stackTrace :: ANR -> Maybe StackTrace
stackTrace :: Maybe StackTrace
..} =
    [Pair] -> Value
Core.object
      ([Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes [(Key
"stackTrace" Core..=) (StackTrace -> Pair) -> Maybe StackTrace -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe StackTrace
stackTrace])

-- | A suggestion to use deep links for a Robo run.
--
-- /See:/ 'newAvailableDeepLinks' smart constructor.
data AvailableDeepLinks = AvailableDeepLinks
  deriving (AvailableDeepLinks -> AvailableDeepLinks -> Bool
(AvailableDeepLinks -> AvailableDeepLinks -> Bool)
-> (AvailableDeepLinks -> AvailableDeepLinks -> Bool)
-> Eq AvailableDeepLinks
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AvailableDeepLinks -> AvailableDeepLinks -> Bool
== :: AvailableDeepLinks -> AvailableDeepLinks -> Bool
$c/= :: AvailableDeepLinks -> AvailableDeepLinks -> Bool
/= :: AvailableDeepLinks -> AvailableDeepLinks -> Bool
Core.Eq, Int -> AvailableDeepLinks -> ShowS
[AvailableDeepLinks] -> ShowS
AvailableDeepLinks -> String
(Int -> AvailableDeepLinks -> ShowS)
-> (AvailableDeepLinks -> String)
-> ([AvailableDeepLinks] -> ShowS)
-> Show AvailableDeepLinks
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AvailableDeepLinks -> ShowS
showsPrec :: Int -> AvailableDeepLinks -> ShowS
$cshow :: AvailableDeepLinks -> String
show :: AvailableDeepLinks -> String
$cshowList :: [AvailableDeepLinks] -> ShowS
showList :: [AvailableDeepLinks] -> ShowS
Core.Show, (forall x. AvailableDeepLinks -> Rep AvailableDeepLinks x)
-> (forall x. Rep AvailableDeepLinks x -> AvailableDeepLinks)
-> Generic AvailableDeepLinks
forall x. Rep AvailableDeepLinks x -> AvailableDeepLinks
forall x. AvailableDeepLinks -> Rep AvailableDeepLinks x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AvailableDeepLinks -> Rep AvailableDeepLinks x
from :: forall x. AvailableDeepLinks -> Rep AvailableDeepLinks x
$cto :: forall x. Rep AvailableDeepLinks x -> AvailableDeepLinks
to :: forall x. Rep AvailableDeepLinks x -> AvailableDeepLinks
Core.Generic)

-- | Creates a value of 'AvailableDeepLinks' with the minimum fields required to make a request.
newAvailableDeepLinks ::
  AvailableDeepLinks
newAvailableDeepLinks :: AvailableDeepLinks
newAvailableDeepLinks = AvailableDeepLinks
AvailableDeepLinks

instance Core.FromJSON AvailableDeepLinks where
  parseJSON :: Value -> Parser AvailableDeepLinks
parseJSON =
    String
-> (Object -> Parser AvailableDeepLinks)
-> Value
-> Parser AvailableDeepLinks
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"AvailableDeepLinks"
      (\Object
o -> AvailableDeepLinks -> Parser AvailableDeepLinks
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
Core.pure AvailableDeepLinks
AvailableDeepLinks)

instance Core.ToJSON AvailableDeepLinks where
  toJSON :: AvailableDeepLinks -> Value
toJSON = Value -> AvailableDeepLinks -> Value
forall a b. a -> b -> a
Core.const Value
Core.emptyObject

-- | A warning that Robo encountered a screen that was mostly blank; this may indicate a problem with the app.
--
-- /See:/ 'newBlankScreen' smart constructor.
newtype BlankScreen = BlankScreen
  { -- | The screen id of the element
    BlankScreen -> Maybe Text
screenId :: (Core.Maybe Core.Text)
  }
  deriving (BlankScreen -> BlankScreen -> Bool
(BlankScreen -> BlankScreen -> Bool)
-> (BlankScreen -> BlankScreen -> Bool) -> Eq BlankScreen
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BlankScreen -> BlankScreen -> Bool
== :: BlankScreen -> BlankScreen -> Bool
$c/= :: BlankScreen -> BlankScreen -> Bool
/= :: BlankScreen -> BlankScreen -> Bool
Core.Eq, Int -> BlankScreen -> ShowS
[BlankScreen] -> ShowS
BlankScreen -> String
(Int -> BlankScreen -> ShowS)
-> (BlankScreen -> String)
-> ([BlankScreen] -> ShowS)
-> Show BlankScreen
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BlankScreen -> ShowS
showsPrec :: Int -> BlankScreen -> ShowS
$cshow :: BlankScreen -> String
show :: BlankScreen -> String
$cshowList :: [BlankScreen] -> ShowS
showList :: [BlankScreen] -> ShowS
Core.Show, (forall x. BlankScreen -> Rep BlankScreen x)
-> (forall x. Rep BlankScreen x -> BlankScreen)
-> Generic BlankScreen
forall x. Rep BlankScreen x -> BlankScreen
forall x. BlankScreen -> Rep BlankScreen x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BlankScreen -> Rep BlankScreen x
from :: forall x. BlankScreen -> Rep BlankScreen x
$cto :: forall x. Rep BlankScreen x -> BlankScreen
to :: forall x. Rep BlankScreen x -> BlankScreen
Core.Generic)

-- | Creates a value of 'BlankScreen' with the minimum fields required to make a request.
newBlankScreen ::
  BlankScreen
newBlankScreen :: BlankScreen
newBlankScreen = BlankScreen {screenId :: Maybe Text
screenId = Maybe Text
forall a. Maybe a
Core.Nothing}

instance Core.FromJSON BlankScreen where
  parseJSON :: Value -> Parser BlankScreen
parseJSON =
    String
-> (Object -> Parser BlankScreen) -> Value -> Parser BlankScreen
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"BlankScreen"
      (\Object
o -> Maybe Text -> BlankScreen
BlankScreen (Maybe Text -> BlankScreen)
-> Parser (Maybe Text) -> Parser BlankScreen
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"screenId"))

instance Core.ToJSON BlankScreen where
  toJSON :: BlankScreen -> Value
toJSON BlankScreen {Maybe Text
screenId :: BlankScreen -> Maybe Text
screenId :: Maybe Text
..} =
    [Pair] -> Value
Core.object
      ([Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes [(Key
"screenId" Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Text
screenId])

-- | Crash dialog was detected during the test execution
--
-- /See:/ 'newCrashDialogError' smart constructor.
newtype CrashDialogError = CrashDialogError
  { -- | The name of the package that caused the dialog.
    CrashDialogError -> Maybe Text
crashPackage :: (Core.Maybe Core.Text)
  }
  deriving (CrashDialogError -> CrashDialogError -> Bool
(CrashDialogError -> CrashDialogError -> Bool)
-> (CrashDialogError -> CrashDialogError -> Bool)
-> Eq CrashDialogError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CrashDialogError -> CrashDialogError -> Bool
== :: CrashDialogError -> CrashDialogError -> Bool
$c/= :: CrashDialogError -> CrashDialogError -> Bool
/= :: CrashDialogError -> CrashDialogError -> Bool
Core.Eq, Int -> CrashDialogError -> ShowS
[CrashDialogError] -> ShowS
CrashDialogError -> String
(Int -> CrashDialogError -> ShowS)
-> (CrashDialogError -> String)
-> ([CrashDialogError] -> ShowS)
-> Show CrashDialogError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CrashDialogError -> ShowS
showsPrec :: Int -> CrashDialogError -> ShowS
$cshow :: CrashDialogError -> String
show :: CrashDialogError -> String
$cshowList :: [CrashDialogError] -> ShowS
showList :: [CrashDialogError] -> ShowS
Core.Show, (forall x. CrashDialogError -> Rep CrashDialogError x)
-> (forall x. Rep CrashDialogError x -> CrashDialogError)
-> Generic CrashDialogError
forall x. Rep CrashDialogError x -> CrashDialogError
forall x. CrashDialogError -> Rep CrashDialogError x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CrashDialogError -> Rep CrashDialogError x
from :: forall x. CrashDialogError -> Rep CrashDialogError x
$cto :: forall x. Rep CrashDialogError x -> CrashDialogError
to :: forall x. Rep CrashDialogError x -> CrashDialogError
Core.Generic)

-- | Creates a value of 'CrashDialogError' with the minimum fields required to make a request.
newCrashDialogError ::
  CrashDialogError
newCrashDialogError :: CrashDialogError
newCrashDialogError = CrashDialogError {crashPackage :: Maybe Text
crashPackage = Maybe Text
forall a. Maybe a
Core.Nothing}

instance Core.FromJSON CrashDialogError where
  parseJSON :: Value -> Parser CrashDialogError
parseJSON =
    String
-> (Object -> Parser CrashDialogError)
-> Value
-> Parser CrashDialogError
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"CrashDialogError"
      (\Object
o -> Maybe Text -> CrashDialogError
CrashDialogError (Maybe Text -> CrashDialogError)
-> Parser (Maybe Text) -> Parser CrashDialogError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"crashPackage"))

instance Core.ToJSON CrashDialogError where
  toJSON :: CrashDialogError -> Value
toJSON CrashDialogError {Maybe Text
crashPackage :: CrashDialogError -> Maybe Text
crashPackage :: Maybe Text
..} =
    [Pair] -> Value
Core.object
      ([Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes [(Key
"crashPackage" Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Text
crashPackage])

-- | Additional details about encountered login screens.
--
-- /See:/ 'newEncounteredLoginScreen' smart constructor.
data EncounteredLoginScreen = EncounteredLoginScreen
  { -- | Number of encountered distinct login screens.
    EncounteredLoginScreen -> Maybe Int32
distinctScreens :: (Core.Maybe Core.Int32),
    -- | Subset of login screens.
    EncounteredLoginScreen -> Maybe [Text]
screenIds :: (Core.Maybe [Core.Text])
  }
  deriving (EncounteredLoginScreen -> EncounteredLoginScreen -> Bool
(EncounteredLoginScreen -> EncounteredLoginScreen -> Bool)
-> (EncounteredLoginScreen -> EncounteredLoginScreen -> Bool)
-> Eq EncounteredLoginScreen
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EncounteredLoginScreen -> EncounteredLoginScreen -> Bool
== :: EncounteredLoginScreen -> EncounteredLoginScreen -> Bool
$c/= :: EncounteredLoginScreen -> EncounteredLoginScreen -> Bool
/= :: EncounteredLoginScreen -> EncounteredLoginScreen -> Bool
Core.Eq, Int -> EncounteredLoginScreen -> ShowS
[EncounteredLoginScreen] -> ShowS
EncounteredLoginScreen -> String
(Int -> EncounteredLoginScreen -> ShowS)
-> (EncounteredLoginScreen -> String)
-> ([EncounteredLoginScreen] -> ShowS)
-> Show EncounteredLoginScreen
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EncounteredLoginScreen -> ShowS
showsPrec :: Int -> EncounteredLoginScreen -> ShowS
$cshow :: EncounteredLoginScreen -> String
show :: EncounteredLoginScreen -> String
$cshowList :: [EncounteredLoginScreen] -> ShowS
showList :: [EncounteredLoginScreen] -> ShowS
Core.Show, (forall x. EncounteredLoginScreen -> Rep EncounteredLoginScreen x)
-> (forall x.
    Rep EncounteredLoginScreen x -> EncounteredLoginScreen)
-> Generic EncounteredLoginScreen
forall x. Rep EncounteredLoginScreen x -> EncounteredLoginScreen
forall x. EncounteredLoginScreen -> Rep EncounteredLoginScreen x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EncounteredLoginScreen -> Rep EncounteredLoginScreen x
from :: forall x. EncounteredLoginScreen -> Rep EncounteredLoginScreen x
$cto :: forall x. Rep EncounteredLoginScreen x -> EncounteredLoginScreen
to :: forall x. Rep EncounteredLoginScreen x -> EncounteredLoginScreen
Core.Generic)

-- | Creates a value of 'EncounteredLoginScreen' with the minimum fields required to make a request.
newEncounteredLoginScreen ::
  EncounteredLoginScreen
newEncounteredLoginScreen :: EncounteredLoginScreen
newEncounteredLoginScreen =
  EncounteredLoginScreen
    { distinctScreens :: Maybe Int32
distinctScreens = Maybe Int32
forall a. Maybe a
Core.Nothing,
      screenIds :: Maybe [Text]
screenIds = Maybe [Text]
forall a. Maybe a
Core.Nothing
    }

instance Core.FromJSON EncounteredLoginScreen where
  parseJSON :: Value -> Parser EncounteredLoginScreen
parseJSON =
    String
-> (Object -> Parser EncounteredLoginScreen)
-> Value
-> Parser EncounteredLoginScreen
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"EncounteredLoginScreen"
      ( \Object
o ->
          Maybe Int32 -> Maybe [Text] -> EncounteredLoginScreen
EncounteredLoginScreen
            (Maybe Int32 -> Maybe [Text] -> EncounteredLoginScreen)
-> Parser (Maybe Int32)
-> Parser (Maybe [Text] -> EncounteredLoginScreen)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe Int32)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"distinctScreens")
            Parser (Maybe [Text] -> EncounteredLoginScreen)
-> Parser (Maybe [Text]) -> Parser EncounteredLoginScreen
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe [Text])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"screenIds")
      )

instance Core.ToJSON EncounteredLoginScreen where
  toJSON :: EncounteredLoginScreen -> Value
toJSON EncounteredLoginScreen {Maybe Int32
Maybe [Text]
distinctScreens :: EncounteredLoginScreen -> Maybe Int32
screenIds :: EncounteredLoginScreen -> Maybe [Text]
distinctScreens :: Maybe Int32
screenIds :: Maybe [Text]
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes
          [ (Key
"distinctScreens" Core..=) (Int32 -> Pair) -> Maybe Int32 -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Int32
distinctScreens,
            (Key
"screenIds" Core..=) ([Text] -> Pair) -> Maybe [Text] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe [Text]
screenIds
          ]
      )

-- | Additional details about encountered screens with elements that are not Android UI widgets.
--
-- /See:/ 'newEncounteredNonAndroidUiWidgetScreen' smart constructor.
data EncounteredNonAndroidUiWidgetScreen = EncounteredNonAndroidUiWidgetScreen
  { -- | Number of encountered distinct screens with non Android UI widgets.
    EncounteredNonAndroidUiWidgetScreen -> Maybe Int32
distinctScreens :: (Core.Maybe Core.Int32),
    -- | Subset of screens which contain non Android UI widgets.
    EncounteredNonAndroidUiWidgetScreen -> Maybe [Text]
screenIds :: (Core.Maybe [Core.Text])
  }
  deriving (EncounteredNonAndroidUiWidgetScreen
-> EncounteredNonAndroidUiWidgetScreen -> Bool
(EncounteredNonAndroidUiWidgetScreen
 -> EncounteredNonAndroidUiWidgetScreen -> Bool)
-> (EncounteredNonAndroidUiWidgetScreen
    -> EncounteredNonAndroidUiWidgetScreen -> Bool)
-> Eq EncounteredNonAndroidUiWidgetScreen
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EncounteredNonAndroidUiWidgetScreen
-> EncounteredNonAndroidUiWidgetScreen -> Bool
== :: EncounteredNonAndroidUiWidgetScreen
-> EncounteredNonAndroidUiWidgetScreen -> Bool
$c/= :: EncounteredNonAndroidUiWidgetScreen
-> EncounteredNonAndroidUiWidgetScreen -> Bool
/= :: EncounteredNonAndroidUiWidgetScreen
-> EncounteredNonAndroidUiWidgetScreen -> Bool
Core.Eq, Int -> EncounteredNonAndroidUiWidgetScreen -> ShowS
[EncounteredNonAndroidUiWidgetScreen] -> ShowS
EncounteredNonAndroidUiWidgetScreen -> String
(Int -> EncounteredNonAndroidUiWidgetScreen -> ShowS)
-> (EncounteredNonAndroidUiWidgetScreen -> String)
-> ([EncounteredNonAndroidUiWidgetScreen] -> ShowS)
-> Show EncounteredNonAndroidUiWidgetScreen
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EncounteredNonAndroidUiWidgetScreen -> ShowS
showsPrec :: Int -> EncounteredNonAndroidUiWidgetScreen -> ShowS
$cshow :: EncounteredNonAndroidUiWidgetScreen -> String
show :: EncounteredNonAndroidUiWidgetScreen -> String
$cshowList :: [EncounteredNonAndroidUiWidgetScreen] -> ShowS
showList :: [EncounteredNonAndroidUiWidgetScreen] -> ShowS
Core.Show, (forall x.
 EncounteredNonAndroidUiWidgetScreen
 -> Rep EncounteredNonAndroidUiWidgetScreen x)
-> (forall x.
    Rep EncounteredNonAndroidUiWidgetScreen x
    -> EncounteredNonAndroidUiWidgetScreen)
-> Generic EncounteredNonAndroidUiWidgetScreen
forall x.
Rep EncounteredNonAndroidUiWidgetScreen x
-> EncounteredNonAndroidUiWidgetScreen
forall x.
EncounteredNonAndroidUiWidgetScreen
-> Rep EncounteredNonAndroidUiWidgetScreen x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
EncounteredNonAndroidUiWidgetScreen
-> Rep EncounteredNonAndroidUiWidgetScreen x
from :: forall x.
EncounteredNonAndroidUiWidgetScreen
-> Rep EncounteredNonAndroidUiWidgetScreen x
$cto :: forall x.
Rep EncounteredNonAndroidUiWidgetScreen x
-> EncounteredNonAndroidUiWidgetScreen
to :: forall x.
Rep EncounteredNonAndroidUiWidgetScreen x
-> EncounteredNonAndroidUiWidgetScreen
Core.Generic)

-- | Creates a value of 'EncounteredNonAndroidUiWidgetScreen' with the minimum fields required to make a request.
newEncounteredNonAndroidUiWidgetScreen ::
  EncounteredNonAndroidUiWidgetScreen
newEncounteredNonAndroidUiWidgetScreen :: EncounteredNonAndroidUiWidgetScreen
newEncounteredNonAndroidUiWidgetScreen =
  EncounteredNonAndroidUiWidgetScreen
    { distinctScreens :: Maybe Int32
distinctScreens =
        Maybe Int32
forall a. Maybe a
Core.Nothing,
      screenIds :: Maybe [Text]
screenIds = Maybe [Text]
forall a. Maybe a
Core.Nothing
    }

instance Core.FromJSON EncounteredNonAndroidUiWidgetScreen where
  parseJSON :: Value -> Parser EncounteredNonAndroidUiWidgetScreen
parseJSON =
    String
-> (Object -> Parser EncounteredNonAndroidUiWidgetScreen)
-> Value
-> Parser EncounteredNonAndroidUiWidgetScreen
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"EncounteredNonAndroidUiWidgetScreen"
      ( \Object
o ->
          Maybe Int32 -> Maybe [Text] -> EncounteredNonAndroidUiWidgetScreen
EncounteredNonAndroidUiWidgetScreen
            (Maybe Int32
 -> Maybe [Text] -> EncounteredNonAndroidUiWidgetScreen)
-> Parser (Maybe Int32)
-> Parser (Maybe [Text] -> EncounteredNonAndroidUiWidgetScreen)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe Int32)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"distinctScreens")
            Parser (Maybe [Text] -> EncounteredNonAndroidUiWidgetScreen)
-> Parser (Maybe [Text])
-> Parser EncounteredNonAndroidUiWidgetScreen
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe [Text])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"screenIds")
      )

instance Core.ToJSON EncounteredNonAndroidUiWidgetScreen where
  toJSON :: EncounteredNonAndroidUiWidgetScreen -> Value
toJSON EncounteredNonAndroidUiWidgetScreen {Maybe Int32
Maybe [Text]
distinctScreens :: EncounteredNonAndroidUiWidgetScreen -> Maybe Int32
screenIds :: EncounteredNonAndroidUiWidgetScreen -> Maybe [Text]
distinctScreens :: Maybe Int32
screenIds :: Maybe [Text]
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes
          [ (Key
"distinctScreens" Core..=) (Int32 -> Pair) -> Maybe Int32 -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Int32
distinctScreens,
            (Key
"screenIds" Core..=) ([Text] -> Pair) -> Maybe [Text] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe [Text]
screenIds
          ]
      )

-- | Failed to install the APK.
--
-- /See:/ 'newFailedToInstall' smart constructor.
data FailedToInstall = FailedToInstall
  deriving (FailedToInstall -> FailedToInstall -> Bool
(FailedToInstall -> FailedToInstall -> Bool)
-> (FailedToInstall -> FailedToInstall -> Bool)
-> Eq FailedToInstall
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FailedToInstall -> FailedToInstall -> Bool
== :: FailedToInstall -> FailedToInstall -> Bool
$c/= :: FailedToInstall -> FailedToInstall -> Bool
/= :: FailedToInstall -> FailedToInstall -> Bool
Core.Eq, Int -> FailedToInstall -> ShowS
[FailedToInstall] -> ShowS
FailedToInstall -> String
(Int -> FailedToInstall -> ShowS)
-> (FailedToInstall -> String)
-> ([FailedToInstall] -> ShowS)
-> Show FailedToInstall
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FailedToInstall -> ShowS
showsPrec :: Int -> FailedToInstall -> ShowS
$cshow :: FailedToInstall -> String
show :: FailedToInstall -> String
$cshowList :: [FailedToInstall] -> ShowS
showList :: [FailedToInstall] -> ShowS
Core.Show, (forall x. FailedToInstall -> Rep FailedToInstall x)
-> (forall x. Rep FailedToInstall x -> FailedToInstall)
-> Generic FailedToInstall
forall x. Rep FailedToInstall x -> FailedToInstall
forall x. FailedToInstall -> Rep FailedToInstall x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FailedToInstall -> Rep FailedToInstall x
from :: forall x. FailedToInstall -> Rep FailedToInstall x
$cto :: forall x. Rep FailedToInstall x -> FailedToInstall
to :: forall x. Rep FailedToInstall x -> FailedToInstall
Core.Generic)

-- | Creates a value of 'FailedToInstall' with the minimum fields required to make a request.
newFailedToInstall ::
  FailedToInstall
newFailedToInstall :: FailedToInstall
newFailedToInstall = FailedToInstall
FailedToInstall

instance Core.FromJSON FailedToInstall where
  parseJSON :: Value -> Parser FailedToInstall
parseJSON =
    String
-> (Object -> Parser FailedToInstall)
-> Value
-> Parser FailedToInstall
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"FailedToInstall"
      (\Object
o -> FailedToInstall -> Parser FailedToInstall
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
Core.pure FailedToInstall
FailedToInstall)

instance Core.ToJSON FailedToInstall where
  toJSON :: FailedToInstall -> Value
toJSON = Value -> FailedToInstall -> Value
forall a b. a -> b -> a
Core.const Value
Core.emptyObject

-- | Additional details for a fatal exception.
--
-- /See:/ 'newFatalException' smart constructor.
newtype FatalException = FatalException
  { -- | The stack trace of the fatal exception. Optional.
    FatalException -> Maybe StackTrace
stackTrace :: (Core.Maybe StackTrace)
  }
  deriving (FatalException -> FatalException -> Bool
(FatalException -> FatalException -> Bool)
-> (FatalException -> FatalException -> Bool) -> Eq FatalException
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FatalException -> FatalException -> Bool
== :: FatalException -> FatalException -> Bool
$c/= :: FatalException -> FatalException -> Bool
/= :: FatalException -> FatalException -> Bool
Core.Eq, Int -> FatalException -> ShowS
[FatalException] -> ShowS
FatalException -> String
(Int -> FatalException -> ShowS)
-> (FatalException -> String)
-> ([FatalException] -> ShowS)
-> Show FatalException
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FatalException -> ShowS
showsPrec :: Int -> FatalException -> ShowS
$cshow :: FatalException -> String
show :: FatalException -> String
$cshowList :: [FatalException] -> ShowS
showList :: [FatalException] -> ShowS
Core.Show, (forall x. FatalException -> Rep FatalException x)
-> (forall x. Rep FatalException x -> FatalException)
-> Generic FatalException
forall x. Rep FatalException x -> FatalException
forall x. FatalException -> Rep FatalException x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FatalException -> Rep FatalException x
from :: forall x. FatalException -> Rep FatalException x
$cto :: forall x. Rep FatalException x -> FatalException
to :: forall x. Rep FatalException x -> FatalException
Core.Generic)

-- | Creates a value of 'FatalException' with the minimum fields required to make a request.
newFatalException ::
  FatalException
newFatalException :: FatalException
newFatalException = FatalException {stackTrace :: Maybe StackTrace
stackTrace = Maybe StackTrace
forall a. Maybe a
Core.Nothing}

instance Core.FromJSON FatalException where
  parseJSON :: Value -> Parser FatalException
parseJSON =
    String
-> (Object -> Parser FatalException)
-> Value
-> Parser FatalException
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"FatalException"
      (\Object
o -> Maybe StackTrace -> FatalException
FatalException (Maybe StackTrace -> FatalException)
-> Parser (Maybe StackTrace) -> Parser FatalException
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe StackTrace)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"stackTrace"))

instance Core.ToJSON FatalException where
  toJSON :: FatalException -> Value
toJSON FatalException {Maybe StackTrace
stackTrace :: FatalException -> Maybe StackTrace
stackTrace :: Maybe StackTrace
..} =
    [Pair] -> Value
Core.object
      ([Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes [(Key
"stackTrace" Core..=) (StackTrace -> Pair) -> Maybe StackTrace -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe StackTrace
stackTrace])

-- | Additional details of in-app purchases encountered during the crawl.
--
-- /See:/ 'newInAppPurchasesFound' smart constructor.
data InAppPurchasesFound = InAppPurchasesFound
  { -- | The total number of in-app purchases flows explored: how many times the robo tries to buy a SKU.
    InAppPurchasesFound -> Maybe Int32
inAppPurchasesFlowsExplored :: (Core.Maybe Core.Int32),
    -- | The total number of in-app purchases flows started.
    InAppPurchasesFound -> Maybe Int32
inAppPurchasesFlowsStarted :: (Core.Maybe Core.Int32)
  }
  deriving (InAppPurchasesFound -> InAppPurchasesFound -> Bool
(InAppPurchasesFound -> InAppPurchasesFound -> Bool)
-> (InAppPurchasesFound -> InAppPurchasesFound -> Bool)
-> Eq InAppPurchasesFound
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InAppPurchasesFound -> InAppPurchasesFound -> Bool
== :: InAppPurchasesFound -> InAppPurchasesFound -> Bool
$c/= :: InAppPurchasesFound -> InAppPurchasesFound -> Bool
/= :: InAppPurchasesFound -> InAppPurchasesFound -> Bool
Core.Eq, Int -> InAppPurchasesFound -> ShowS
[InAppPurchasesFound] -> ShowS
InAppPurchasesFound -> String
(Int -> InAppPurchasesFound -> ShowS)
-> (InAppPurchasesFound -> String)
-> ([InAppPurchasesFound] -> ShowS)
-> Show InAppPurchasesFound
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InAppPurchasesFound -> ShowS
showsPrec :: Int -> InAppPurchasesFound -> ShowS
$cshow :: InAppPurchasesFound -> String
show :: InAppPurchasesFound -> String
$cshowList :: [InAppPurchasesFound] -> ShowS
showList :: [InAppPurchasesFound] -> ShowS
Core.Show, (forall x. InAppPurchasesFound -> Rep InAppPurchasesFound x)
-> (forall x. Rep InAppPurchasesFound x -> InAppPurchasesFound)
-> Generic InAppPurchasesFound
forall x. Rep InAppPurchasesFound x -> InAppPurchasesFound
forall x. InAppPurchasesFound -> Rep InAppPurchasesFound x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. InAppPurchasesFound -> Rep InAppPurchasesFound x
from :: forall x. InAppPurchasesFound -> Rep InAppPurchasesFound x
$cto :: forall x. Rep InAppPurchasesFound x -> InAppPurchasesFound
to :: forall x. Rep InAppPurchasesFound x -> InAppPurchasesFound
Core.Generic)

-- | Creates a value of 'InAppPurchasesFound' with the minimum fields required to make a request.
newInAppPurchasesFound ::
  InAppPurchasesFound
newInAppPurchasesFound :: InAppPurchasesFound
newInAppPurchasesFound =
  InAppPurchasesFound
    { inAppPurchasesFlowsExplored :: Maybe Int32
inAppPurchasesFlowsExplored = Maybe Int32
forall a. Maybe a
Core.Nothing,
      inAppPurchasesFlowsStarted :: Maybe Int32
inAppPurchasesFlowsStarted = Maybe Int32
forall a. Maybe a
Core.Nothing
    }

instance Core.FromJSON InAppPurchasesFound where
  parseJSON :: Value -> Parser InAppPurchasesFound
parseJSON =
    String
-> (Object -> Parser InAppPurchasesFound)
-> Value
-> Parser InAppPurchasesFound
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"InAppPurchasesFound"
      ( \Object
o ->
          Maybe Int32 -> Maybe Int32 -> InAppPurchasesFound
InAppPurchasesFound
            (Maybe Int32 -> Maybe Int32 -> InAppPurchasesFound)
-> Parser (Maybe Int32)
-> Parser (Maybe Int32 -> InAppPurchasesFound)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe Int32)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"inAppPurchasesFlowsExplored")
            Parser (Maybe Int32 -> InAppPurchasesFound)
-> Parser (Maybe Int32) -> Parser InAppPurchasesFound
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe Int32)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"inAppPurchasesFlowsStarted")
      )

instance Core.ToJSON InAppPurchasesFound where
  toJSON :: InAppPurchasesFound -> Value
toJSON InAppPurchasesFound {Maybe Int32
inAppPurchasesFlowsExplored :: InAppPurchasesFound -> Maybe Int32
inAppPurchasesFlowsStarted :: InAppPurchasesFound -> Maybe Int32
inAppPurchasesFlowsExplored :: Maybe Int32
inAppPurchasesFlowsStarted :: Maybe Int32
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes
          [ (Key
"inAppPurchasesFlowsExplored" Core..=)
              (Int32 -> Pair) -> Maybe Int32 -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Int32
inAppPurchasesFlowsExplored,
            (Key
"inAppPurchasesFlowsStarted" Core..=)
              (Int32 -> Pair) -> Maybe Int32 -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Int32
inAppPurchasesFlowsStarted
          ]
      )

-- | A warning that Robo did not crawl potentially important parts of the app.
--
-- /See:/ 'newInsufficientCoverage' smart constructor.
data InsufficientCoverage = InsufficientCoverage
  deriving (InsufficientCoverage -> InsufficientCoverage -> Bool
(InsufficientCoverage -> InsufficientCoverage -> Bool)
-> (InsufficientCoverage -> InsufficientCoverage -> Bool)
-> Eq InsufficientCoverage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InsufficientCoverage -> InsufficientCoverage -> Bool
== :: InsufficientCoverage -> InsufficientCoverage -> Bool
$c/= :: InsufficientCoverage -> InsufficientCoverage -> Bool
/= :: InsufficientCoverage -> InsufficientCoverage -> Bool
Core.Eq, Int -> InsufficientCoverage -> ShowS
[InsufficientCoverage] -> ShowS
InsufficientCoverage -> String
(Int -> InsufficientCoverage -> ShowS)
-> (InsufficientCoverage -> String)
-> ([InsufficientCoverage] -> ShowS)
-> Show InsufficientCoverage
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InsufficientCoverage -> ShowS
showsPrec :: Int -> InsufficientCoverage -> ShowS
$cshow :: InsufficientCoverage -> String
show :: InsufficientCoverage -> String
$cshowList :: [InsufficientCoverage] -> ShowS
showList :: [InsufficientCoverage] -> ShowS
Core.Show, (forall x. InsufficientCoverage -> Rep InsufficientCoverage x)
-> (forall x. Rep InsufficientCoverage x -> InsufficientCoverage)
-> Generic InsufficientCoverage
forall x. Rep InsufficientCoverage x -> InsufficientCoverage
forall x. InsufficientCoverage -> Rep InsufficientCoverage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. InsufficientCoverage -> Rep InsufficientCoverage x
from :: forall x. InsufficientCoverage -> Rep InsufficientCoverage x
$cto :: forall x. Rep InsufficientCoverage x -> InsufficientCoverage
to :: forall x. Rep InsufficientCoverage x -> InsufficientCoverage
Core.Generic)

-- | Creates a value of 'InsufficientCoverage' with the minimum fields required to make a request.
newInsufficientCoverage ::
  InsufficientCoverage
newInsufficientCoverage :: InsufficientCoverage
newInsufficientCoverage = InsufficientCoverage
InsufficientCoverage

instance Core.FromJSON InsufficientCoverage where
  parseJSON :: Value -> Parser InsufficientCoverage
parseJSON =
    String
-> (Object -> Parser InsufficientCoverage)
-> Value
-> Parser InsufficientCoverage
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"InsufficientCoverage"
      (\Object
o -> InsufficientCoverage -> Parser InsufficientCoverage
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
Core.pure InsufficientCoverage
InsufficientCoverage)

instance Core.ToJSON InsufficientCoverage where
  toJSON :: InsufficientCoverage -> Value
toJSON = Value -> InsufficientCoverage -> Value
forall a b. a -> b -> a
Core.const Value
Core.emptyObject

-- | Additional details for an iOS app crash.
--
-- /See:/ 'newIosAppCrashed' smart constructor.
newtype IosAppCrashed = IosAppCrashed
  { -- | The stack trace, if one is available. Optional.
    IosAppCrashed -> Maybe StackTrace
stackTrace :: (Core.Maybe StackTrace)
  }
  deriving (IosAppCrashed -> IosAppCrashed -> Bool
(IosAppCrashed -> IosAppCrashed -> Bool)
-> (IosAppCrashed -> IosAppCrashed -> Bool) -> Eq IosAppCrashed
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IosAppCrashed -> IosAppCrashed -> Bool
== :: IosAppCrashed -> IosAppCrashed -> Bool
$c/= :: IosAppCrashed -> IosAppCrashed -> Bool
/= :: IosAppCrashed -> IosAppCrashed -> Bool
Core.Eq, Int -> IosAppCrashed -> ShowS
[IosAppCrashed] -> ShowS
IosAppCrashed -> String
(Int -> IosAppCrashed -> ShowS)
-> (IosAppCrashed -> String)
-> ([IosAppCrashed] -> ShowS)
-> Show IosAppCrashed
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IosAppCrashed -> ShowS
showsPrec :: Int -> IosAppCrashed -> ShowS
$cshow :: IosAppCrashed -> String
show :: IosAppCrashed -> String
$cshowList :: [IosAppCrashed] -> ShowS
showList :: [IosAppCrashed] -> ShowS
Core.Show, (forall x. IosAppCrashed -> Rep IosAppCrashed x)
-> (forall x. Rep IosAppCrashed x -> IosAppCrashed)
-> Generic IosAppCrashed
forall x. Rep IosAppCrashed x -> IosAppCrashed
forall x. IosAppCrashed -> Rep IosAppCrashed x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IosAppCrashed -> Rep IosAppCrashed x
from :: forall x. IosAppCrashed -> Rep IosAppCrashed x
$cto :: forall x. Rep IosAppCrashed x -> IosAppCrashed
to :: forall x. Rep IosAppCrashed x -> IosAppCrashed
Core.Generic)

-- | Creates a value of 'IosAppCrashed' with the minimum fields required to make a request.
newIosAppCrashed ::
  IosAppCrashed
newIosAppCrashed :: IosAppCrashed
newIosAppCrashed = IosAppCrashed {stackTrace :: Maybe StackTrace
stackTrace = Maybe StackTrace
forall a. Maybe a
Core.Nothing}

instance Core.FromJSON IosAppCrashed where
  parseJSON :: Value -> Parser IosAppCrashed
parseJSON =
    String
-> (Object -> Parser IosAppCrashed)
-> Value
-> Parser IosAppCrashed
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"IosAppCrashed"
      (\Object
o -> Maybe StackTrace -> IosAppCrashed
IosAppCrashed (Maybe StackTrace -> IosAppCrashed)
-> Parser (Maybe StackTrace) -> Parser IosAppCrashed
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe StackTrace)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"stackTrace"))

instance Core.ToJSON IosAppCrashed where
  toJSON :: IosAppCrashed -> Value
toJSON IosAppCrashed {Maybe StackTrace
stackTrace :: IosAppCrashed -> Maybe StackTrace
stackTrace :: Maybe StackTrace
..} =
    [Pair] -> Value
Core.object
      ([Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes [(Key
"stackTrace" Core..=) (StackTrace -> Pair) -> Maybe StackTrace -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe StackTrace
stackTrace])

-- | Failed to find the launcher activity of an app.
--
-- /See:/ 'newLauncherActivityNotFound' smart constructor.
data LauncherActivityNotFound = LauncherActivityNotFound
  deriving (LauncherActivityNotFound -> LauncherActivityNotFound -> Bool
(LauncherActivityNotFound -> LauncherActivityNotFound -> Bool)
-> (LauncherActivityNotFound -> LauncherActivityNotFound -> Bool)
-> Eq LauncherActivityNotFound
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LauncherActivityNotFound -> LauncherActivityNotFound -> Bool
== :: LauncherActivityNotFound -> LauncherActivityNotFound -> Bool
$c/= :: LauncherActivityNotFound -> LauncherActivityNotFound -> Bool
/= :: LauncherActivityNotFound -> LauncherActivityNotFound -> Bool
Core.Eq, Int -> LauncherActivityNotFound -> ShowS
[LauncherActivityNotFound] -> ShowS
LauncherActivityNotFound -> String
(Int -> LauncherActivityNotFound -> ShowS)
-> (LauncherActivityNotFound -> String)
-> ([LauncherActivityNotFound] -> ShowS)
-> Show LauncherActivityNotFound
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LauncherActivityNotFound -> ShowS
showsPrec :: Int -> LauncherActivityNotFound -> ShowS
$cshow :: LauncherActivityNotFound -> String
show :: LauncherActivityNotFound -> String
$cshowList :: [LauncherActivityNotFound] -> ShowS
showList :: [LauncherActivityNotFound] -> ShowS
Core.Show, (forall x.
 LauncherActivityNotFound -> Rep LauncherActivityNotFound x)
-> (forall x.
    Rep LauncherActivityNotFound x -> LauncherActivityNotFound)
-> Generic LauncherActivityNotFound
forall x.
Rep LauncherActivityNotFound x -> LauncherActivityNotFound
forall x.
LauncherActivityNotFound -> Rep LauncherActivityNotFound x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
LauncherActivityNotFound -> Rep LauncherActivityNotFound x
from :: forall x.
LauncherActivityNotFound -> Rep LauncherActivityNotFound x
$cto :: forall x.
Rep LauncherActivityNotFound x -> LauncherActivityNotFound
to :: forall x.
Rep LauncherActivityNotFound x -> LauncherActivityNotFound
Core.Generic)

-- | Creates a value of 'LauncherActivityNotFound' with the minimum fields required to make a request.
newLauncherActivityNotFound ::
  LauncherActivityNotFound
newLauncherActivityNotFound :: LauncherActivityNotFound
newLauncherActivityNotFound = LauncherActivityNotFound
LauncherActivityNotFound

instance Core.FromJSON LauncherActivityNotFound where
  parseJSON :: Value -> Parser LauncherActivityNotFound
parseJSON =
    String
-> (Object -> Parser LauncherActivityNotFound)
-> Value
-> Parser LauncherActivityNotFound
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"LauncherActivityNotFound"
      (\Object
o -> LauncherActivityNotFound -> Parser LauncherActivityNotFound
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
Core.pure LauncherActivityNotFound
LauncherActivityNotFound)

instance Core.ToJSON LauncherActivityNotFound where
  toJSON :: LauncherActivityNotFound -> Value
toJSON = Value -> LauncherActivityNotFound -> Value
forall a b. a -> b -> a
Core.const Value
Core.emptyObject

-- | Additional details for a native crash.
--
-- /See:/ 'newNativeCrash' smart constructor.
newtype NativeCrash = NativeCrash
  { -- | The stack trace of the native crash. Optional.
    NativeCrash -> Maybe StackTrace
stackTrace :: (Core.Maybe StackTrace)
  }
  deriving (NativeCrash -> NativeCrash -> Bool
(NativeCrash -> NativeCrash -> Bool)
-> (NativeCrash -> NativeCrash -> Bool) -> Eq NativeCrash
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NativeCrash -> NativeCrash -> Bool
== :: NativeCrash -> NativeCrash -> Bool
$c/= :: NativeCrash -> NativeCrash -> Bool
/= :: NativeCrash -> NativeCrash -> Bool
Core.Eq, Int -> NativeCrash -> ShowS
[NativeCrash] -> ShowS
NativeCrash -> String
(Int -> NativeCrash -> ShowS)
-> (NativeCrash -> String)
-> ([NativeCrash] -> ShowS)
-> Show NativeCrash
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NativeCrash -> ShowS
showsPrec :: Int -> NativeCrash -> ShowS
$cshow :: NativeCrash -> String
show :: NativeCrash -> String
$cshowList :: [NativeCrash] -> ShowS
showList :: [NativeCrash] -> ShowS
Core.Show, (forall x. NativeCrash -> Rep NativeCrash x)
-> (forall x. Rep NativeCrash x -> NativeCrash)
-> Generic NativeCrash
forall x. Rep NativeCrash x -> NativeCrash
forall x. NativeCrash -> Rep NativeCrash x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NativeCrash -> Rep NativeCrash x
from :: forall x. NativeCrash -> Rep NativeCrash x
$cto :: forall x. Rep NativeCrash x -> NativeCrash
to :: forall x. Rep NativeCrash x -> NativeCrash
Core.Generic)

-- | Creates a value of 'NativeCrash' with the minimum fields required to make a request.
newNativeCrash ::
  NativeCrash
newNativeCrash :: NativeCrash
newNativeCrash = NativeCrash {stackTrace :: Maybe StackTrace
stackTrace = Maybe StackTrace
forall a. Maybe a
Core.Nothing}

instance Core.FromJSON NativeCrash where
  parseJSON :: Value -> Parser NativeCrash
parseJSON =
    String
-> (Object -> Parser NativeCrash) -> Value -> Parser NativeCrash
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"NativeCrash"
      (\Object
o -> Maybe StackTrace -> NativeCrash
NativeCrash (Maybe StackTrace -> NativeCrash)
-> Parser (Maybe StackTrace) -> Parser NativeCrash
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe StackTrace)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"stackTrace"))

instance Core.ToJSON NativeCrash where
  toJSON :: NativeCrash -> Value
toJSON NativeCrash {Maybe StackTrace
stackTrace :: NativeCrash -> Maybe StackTrace
stackTrace :: Maybe StackTrace
..} =
    [Pair] -> Value
Core.object
      ([Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes [(Key
"stackTrace" Core..=) (StackTrace -> Pair) -> Maybe StackTrace -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe StackTrace
stackTrace])

-- | A non-sdk API and examples of it being called along with other metadata See https:\/\/developer.android.com\/distribute\/best-practices\/develop\/restrictions-non-sdk-interfaces
--
-- /See:/ 'newNonSdkApi' smart constructor.
data NonSdkApi = NonSdkApi
  { -- | The signature of the Non-SDK API
    NonSdkApi -> Maybe Text
apiSignature :: (Core.Maybe Core.Text),
    -- | Example stack traces of this API being called.
    NonSdkApi -> Maybe [Text]
exampleStackTraces :: (Core.Maybe [Core.Text]),
    -- | Optional debugging insights for non-SDK API violations.
    NonSdkApi -> Maybe [NonSdkApiInsight]
insights :: (Core.Maybe [NonSdkApiInsight]),
    -- | The total number of times this API was observed to have been called.
    NonSdkApi -> Maybe Int32
invocationCount :: (Core.Maybe Core.Int32),
    -- | Which list this API appears on
    NonSdkApi -> Maybe NonSdkApi_List
list :: (Core.Maybe NonSdkApi_List)
  }
  deriving (NonSdkApi -> NonSdkApi -> Bool
(NonSdkApi -> NonSdkApi -> Bool)
-> (NonSdkApi -> NonSdkApi -> Bool) -> Eq NonSdkApi
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NonSdkApi -> NonSdkApi -> Bool
== :: NonSdkApi -> NonSdkApi -> Bool
$c/= :: NonSdkApi -> NonSdkApi -> Bool
/= :: NonSdkApi -> NonSdkApi -> Bool
Core.Eq, Int -> NonSdkApi -> ShowS
[NonSdkApi] -> ShowS
NonSdkApi -> String
(Int -> NonSdkApi -> ShowS)
-> (NonSdkApi -> String)
-> ([NonSdkApi] -> ShowS)
-> Show NonSdkApi
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NonSdkApi -> ShowS
showsPrec :: Int -> NonSdkApi -> ShowS
$cshow :: NonSdkApi -> String
show :: NonSdkApi -> String
$cshowList :: [NonSdkApi] -> ShowS
showList :: [NonSdkApi] -> ShowS
Core.Show, (forall x. NonSdkApi -> Rep NonSdkApi x)
-> (forall x. Rep NonSdkApi x -> NonSdkApi) -> Generic NonSdkApi
forall x. Rep NonSdkApi x -> NonSdkApi
forall x. NonSdkApi -> Rep NonSdkApi x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NonSdkApi -> Rep NonSdkApi x
from :: forall x. NonSdkApi -> Rep NonSdkApi x
$cto :: forall x. Rep NonSdkApi x -> NonSdkApi
to :: forall x. Rep NonSdkApi x -> NonSdkApi
Core.Generic)

-- | Creates a value of 'NonSdkApi' with the minimum fields required to make a request.
newNonSdkApi ::
  NonSdkApi
newNonSdkApi :: NonSdkApi
newNonSdkApi =
  NonSdkApi
    { apiSignature :: Maybe Text
apiSignature = Maybe Text
forall a. Maybe a
Core.Nothing,
      exampleStackTraces :: Maybe [Text]
exampleStackTraces = Maybe [Text]
forall a. Maybe a
Core.Nothing,
      insights :: Maybe [NonSdkApiInsight]
insights = Maybe [NonSdkApiInsight]
forall a. Maybe a
Core.Nothing,
      invocationCount :: Maybe Int32
invocationCount = Maybe Int32
forall a. Maybe a
Core.Nothing,
      list :: Maybe NonSdkApi_List
list = Maybe NonSdkApi_List
forall a. Maybe a
Core.Nothing
    }

instance Core.FromJSON NonSdkApi where
  parseJSON :: Value -> Parser NonSdkApi
parseJSON =
    String -> (Object -> Parser NonSdkApi) -> Value -> Parser NonSdkApi
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"NonSdkApi"
      ( \Object
o ->
          Maybe Text
-> Maybe [Text]
-> Maybe [NonSdkApiInsight]
-> Maybe Int32
-> Maybe NonSdkApi_List
-> NonSdkApi
NonSdkApi
            (Maybe Text
 -> Maybe [Text]
 -> Maybe [NonSdkApiInsight]
 -> Maybe Int32
 -> Maybe NonSdkApi_List
 -> NonSdkApi)
-> Parser (Maybe Text)
-> Parser
     (Maybe [Text]
      -> Maybe [NonSdkApiInsight]
      -> Maybe Int32
      -> Maybe NonSdkApi_List
      -> NonSdkApi)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"apiSignature")
            Parser
  (Maybe [Text]
   -> Maybe [NonSdkApiInsight]
   -> Maybe Int32
   -> Maybe NonSdkApi_List
   -> NonSdkApi)
-> Parser (Maybe [Text])
-> Parser
     (Maybe [NonSdkApiInsight]
      -> Maybe Int32 -> Maybe NonSdkApi_List -> NonSdkApi)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe [Text])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"exampleStackTraces")
            Parser
  (Maybe [NonSdkApiInsight]
   -> Maybe Int32 -> Maybe NonSdkApi_List -> NonSdkApi)
-> Parser (Maybe [NonSdkApiInsight])
-> Parser (Maybe Int32 -> Maybe NonSdkApi_List -> NonSdkApi)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe [NonSdkApiInsight])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"insights")
            Parser (Maybe Int32 -> Maybe NonSdkApi_List -> NonSdkApi)
-> Parser (Maybe Int32)
-> Parser (Maybe NonSdkApi_List -> NonSdkApi)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe Int32)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"invocationCount")
            Parser (Maybe NonSdkApi_List -> NonSdkApi)
-> Parser (Maybe NonSdkApi_List) -> Parser NonSdkApi
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe NonSdkApi_List)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"list")
      )

instance Core.ToJSON NonSdkApi where
  toJSON :: NonSdkApi -> Value
toJSON NonSdkApi {Maybe Int32
Maybe [Text]
Maybe [NonSdkApiInsight]
Maybe Text
Maybe NonSdkApi_List
apiSignature :: NonSdkApi -> Maybe Text
exampleStackTraces :: NonSdkApi -> Maybe [Text]
insights :: NonSdkApi -> Maybe [NonSdkApiInsight]
invocationCount :: NonSdkApi -> Maybe Int32
list :: NonSdkApi -> Maybe NonSdkApi_List
apiSignature :: Maybe Text
exampleStackTraces :: Maybe [Text]
insights :: Maybe [NonSdkApiInsight]
invocationCount :: Maybe Int32
list :: Maybe NonSdkApi_List
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes
          [ (Key
"apiSignature" Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Text
apiSignature,
            (Key
"exampleStackTraces" Core..=) ([Text] -> Pair) -> Maybe [Text] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe [Text]
exampleStackTraces,
            (Key
"insights" Core..=) ([NonSdkApiInsight] -> Pair)
-> Maybe [NonSdkApiInsight] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe [NonSdkApiInsight]
insights,
            (Key
"invocationCount" Core..=) (Int32 -> Pair) -> Maybe Int32 -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Int32
invocationCount,
            (Key
"list" Core..=) (NonSdkApi_List -> Pair) -> Maybe NonSdkApi_List -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe NonSdkApi_List
list
          ]
      )

-- | Non-SDK API insights (to address debugging solutions).
--
-- /See:/ 'newNonSdkApiInsight' smart constructor.
data NonSdkApiInsight = NonSdkApiInsight
  { -- | Optional sample stack traces, for which this insight applies (there should be at least one).
    NonSdkApiInsight -> Maybe [Text]
exampleTraceMessages :: (Core.Maybe [Core.Text]),
    -- | A unique ID, to be used for determining the effectiveness of this particular insight in the context of a matcher. (required)
    NonSdkApiInsight -> Maybe Text
matcherId :: (Core.Maybe Core.Text),
    -- | An insight indicating that the hidden API usage originates from a Google-provided library.
    NonSdkApiInsight -> Maybe PendingGoogleUpdateInsight
pendingGoogleUpdateInsight :: (Core.Maybe PendingGoogleUpdateInsight),
    -- | An insight indicating that the hidden API usage originates from the use of a library that needs to be upgraded.
    NonSdkApiInsight -> Maybe UpgradeInsight
upgradeInsight :: (Core.Maybe UpgradeInsight)
  }
  deriving (NonSdkApiInsight -> NonSdkApiInsight -> Bool
(NonSdkApiInsight -> NonSdkApiInsight -> Bool)
-> (NonSdkApiInsight -> NonSdkApiInsight -> Bool)
-> Eq NonSdkApiInsight
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NonSdkApiInsight -> NonSdkApiInsight -> Bool
== :: NonSdkApiInsight -> NonSdkApiInsight -> Bool
$c/= :: NonSdkApiInsight -> NonSdkApiInsight -> Bool
/= :: NonSdkApiInsight -> NonSdkApiInsight -> Bool
Core.Eq, Int -> NonSdkApiInsight -> ShowS
[NonSdkApiInsight] -> ShowS
NonSdkApiInsight -> String
(Int -> NonSdkApiInsight -> ShowS)
-> (NonSdkApiInsight -> String)
-> ([NonSdkApiInsight] -> ShowS)
-> Show NonSdkApiInsight
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NonSdkApiInsight -> ShowS
showsPrec :: Int -> NonSdkApiInsight -> ShowS
$cshow :: NonSdkApiInsight -> String
show :: NonSdkApiInsight -> String
$cshowList :: [NonSdkApiInsight] -> ShowS
showList :: [NonSdkApiInsight] -> ShowS
Core.Show, (forall x. NonSdkApiInsight -> Rep NonSdkApiInsight x)
-> (forall x. Rep NonSdkApiInsight x -> NonSdkApiInsight)
-> Generic NonSdkApiInsight
forall x. Rep NonSdkApiInsight x -> NonSdkApiInsight
forall x. NonSdkApiInsight -> Rep NonSdkApiInsight x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NonSdkApiInsight -> Rep NonSdkApiInsight x
from :: forall x. NonSdkApiInsight -> Rep NonSdkApiInsight x
$cto :: forall x. Rep NonSdkApiInsight x -> NonSdkApiInsight
to :: forall x. Rep NonSdkApiInsight x -> NonSdkApiInsight
Core.Generic)

-- | Creates a value of 'NonSdkApiInsight' with the minimum fields required to make a request.
newNonSdkApiInsight ::
  NonSdkApiInsight
newNonSdkApiInsight :: NonSdkApiInsight
newNonSdkApiInsight =
  NonSdkApiInsight
    { exampleTraceMessages :: Maybe [Text]
exampleTraceMessages = Maybe [Text]
forall a. Maybe a
Core.Nothing,
      matcherId :: Maybe Text
matcherId = Maybe Text
forall a. Maybe a
Core.Nothing,
      pendingGoogleUpdateInsight :: Maybe PendingGoogleUpdateInsight
pendingGoogleUpdateInsight = Maybe PendingGoogleUpdateInsight
forall a. Maybe a
Core.Nothing,
      upgradeInsight :: Maybe UpgradeInsight
upgradeInsight = Maybe UpgradeInsight
forall a. Maybe a
Core.Nothing
    }

instance Core.FromJSON NonSdkApiInsight where
  parseJSON :: Value -> Parser NonSdkApiInsight
parseJSON =
    String
-> (Object -> Parser NonSdkApiInsight)
-> Value
-> Parser NonSdkApiInsight
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"NonSdkApiInsight"
      ( \Object
o ->
          Maybe [Text]
-> Maybe Text
-> Maybe PendingGoogleUpdateInsight
-> Maybe UpgradeInsight
-> NonSdkApiInsight
NonSdkApiInsight
            (Maybe [Text]
 -> Maybe Text
 -> Maybe PendingGoogleUpdateInsight
 -> Maybe UpgradeInsight
 -> NonSdkApiInsight)
-> Parser (Maybe [Text])
-> Parser
     (Maybe Text
      -> Maybe PendingGoogleUpdateInsight
      -> Maybe UpgradeInsight
      -> NonSdkApiInsight)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe [Text])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"exampleTraceMessages")
            Parser
  (Maybe Text
   -> Maybe PendingGoogleUpdateInsight
   -> Maybe UpgradeInsight
   -> NonSdkApiInsight)
-> Parser (Maybe Text)
-> Parser
     (Maybe PendingGoogleUpdateInsight
      -> Maybe UpgradeInsight -> NonSdkApiInsight)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"matcherId")
            Parser
  (Maybe PendingGoogleUpdateInsight
   -> Maybe UpgradeInsight -> NonSdkApiInsight)
-> Parser (Maybe PendingGoogleUpdateInsight)
-> Parser (Maybe UpgradeInsight -> NonSdkApiInsight)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe PendingGoogleUpdateInsight)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"pendingGoogleUpdateInsight")
            Parser (Maybe UpgradeInsight -> NonSdkApiInsight)
-> Parser (Maybe UpgradeInsight) -> Parser NonSdkApiInsight
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe UpgradeInsight)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"upgradeInsight")
      )

instance Core.ToJSON NonSdkApiInsight where
  toJSON :: NonSdkApiInsight -> Value
toJSON NonSdkApiInsight {Maybe [Text]
Maybe Text
Maybe UpgradeInsight
Maybe PendingGoogleUpdateInsight
exampleTraceMessages :: NonSdkApiInsight -> Maybe [Text]
matcherId :: NonSdkApiInsight -> Maybe Text
pendingGoogleUpdateInsight :: NonSdkApiInsight -> Maybe PendingGoogleUpdateInsight
upgradeInsight :: NonSdkApiInsight -> Maybe UpgradeInsight
exampleTraceMessages :: Maybe [Text]
matcherId :: Maybe Text
pendingGoogleUpdateInsight :: Maybe PendingGoogleUpdateInsight
upgradeInsight :: Maybe UpgradeInsight
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes
          [ (Key
"exampleTraceMessages" Core..=) ([Text] -> Pair) -> Maybe [Text] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe [Text]
exampleTraceMessages,
            (Key
"matcherId" Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Text
matcherId,
            (Key
"pendingGoogleUpdateInsight" Core..=)
              (PendingGoogleUpdateInsight -> Pair)
-> Maybe PendingGoogleUpdateInsight -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe PendingGoogleUpdateInsight
pendingGoogleUpdateInsight,
            (Key
"upgradeInsight" Core..=) (UpgradeInsight -> Pair) -> Maybe UpgradeInsight -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe UpgradeInsight
upgradeInsight
          ]
      )

-- | Additional details for a non-sdk API usage violation.
--
-- /See:/ 'newNonSdkApiUsageViolation' smart constructor.
data NonSdkApiUsageViolation = NonSdkApiUsageViolation
  { -- | Signatures of a subset of those hidden API\'s.
    NonSdkApiUsageViolation -> Maybe [Text]
apiSignatures :: (Core.Maybe [Core.Text]),
    -- | Total number of unique hidden API\'s accessed.
    NonSdkApiUsageViolation -> Maybe Int32
uniqueApis :: (Core.Maybe Core.Int32)
  }
  deriving (NonSdkApiUsageViolation -> NonSdkApiUsageViolation -> Bool
(NonSdkApiUsageViolation -> NonSdkApiUsageViolation -> Bool)
-> (NonSdkApiUsageViolation -> NonSdkApiUsageViolation -> Bool)
-> Eq NonSdkApiUsageViolation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NonSdkApiUsageViolation -> NonSdkApiUsageViolation -> Bool
== :: NonSdkApiUsageViolation -> NonSdkApiUsageViolation -> Bool
$c/= :: NonSdkApiUsageViolation -> NonSdkApiUsageViolation -> Bool
/= :: NonSdkApiUsageViolation -> NonSdkApiUsageViolation -> Bool
Core.Eq, Int -> NonSdkApiUsageViolation -> ShowS
[NonSdkApiUsageViolation] -> ShowS
NonSdkApiUsageViolation -> String
(Int -> NonSdkApiUsageViolation -> ShowS)
-> (NonSdkApiUsageViolation -> String)
-> ([NonSdkApiUsageViolation] -> ShowS)
-> Show NonSdkApiUsageViolation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NonSdkApiUsageViolation -> ShowS
showsPrec :: Int -> NonSdkApiUsageViolation -> ShowS
$cshow :: NonSdkApiUsageViolation -> String
show :: NonSdkApiUsageViolation -> String
$cshowList :: [NonSdkApiUsageViolation] -> ShowS
showList :: [NonSdkApiUsageViolation] -> ShowS
Core.Show, (forall x.
 NonSdkApiUsageViolation -> Rep NonSdkApiUsageViolation x)
-> (forall x.
    Rep NonSdkApiUsageViolation x -> NonSdkApiUsageViolation)
-> Generic NonSdkApiUsageViolation
forall x. Rep NonSdkApiUsageViolation x -> NonSdkApiUsageViolation
forall x. NonSdkApiUsageViolation -> Rep NonSdkApiUsageViolation x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NonSdkApiUsageViolation -> Rep NonSdkApiUsageViolation x
from :: forall x. NonSdkApiUsageViolation -> Rep NonSdkApiUsageViolation x
$cto :: forall x. Rep NonSdkApiUsageViolation x -> NonSdkApiUsageViolation
to :: forall x. Rep NonSdkApiUsageViolation x -> NonSdkApiUsageViolation
Core.Generic)

-- | Creates a value of 'NonSdkApiUsageViolation' with the minimum fields required to make a request.
newNonSdkApiUsageViolation ::
  NonSdkApiUsageViolation
newNonSdkApiUsageViolation :: NonSdkApiUsageViolation
newNonSdkApiUsageViolation =
  NonSdkApiUsageViolation
    { apiSignatures :: Maybe [Text]
apiSignatures = Maybe [Text]
forall a. Maybe a
Core.Nothing,
      uniqueApis :: Maybe Int32
uniqueApis = Maybe Int32
forall a. Maybe a
Core.Nothing
    }

instance Core.FromJSON NonSdkApiUsageViolation where
  parseJSON :: Value -> Parser NonSdkApiUsageViolation
parseJSON =
    String
-> (Object -> Parser NonSdkApiUsageViolation)
-> Value
-> Parser NonSdkApiUsageViolation
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"NonSdkApiUsageViolation"
      ( \Object
o ->
          Maybe [Text] -> Maybe Int32 -> NonSdkApiUsageViolation
NonSdkApiUsageViolation
            (Maybe [Text] -> Maybe Int32 -> NonSdkApiUsageViolation)
-> Parser (Maybe [Text])
-> Parser (Maybe Int32 -> NonSdkApiUsageViolation)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe [Text])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"apiSignatures")
            Parser (Maybe Int32 -> NonSdkApiUsageViolation)
-> Parser (Maybe Int32) -> Parser NonSdkApiUsageViolation
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe Int32)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"uniqueApis")
      )

instance Core.ToJSON NonSdkApiUsageViolation where
  toJSON :: NonSdkApiUsageViolation -> Value
toJSON NonSdkApiUsageViolation {Maybe Int32
Maybe [Text]
apiSignatures :: NonSdkApiUsageViolation -> Maybe [Text]
uniqueApis :: NonSdkApiUsageViolation -> Maybe Int32
apiSignatures :: Maybe [Text]
uniqueApis :: Maybe Int32
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes
          [ (Key
"apiSignatures" Core..=) ([Text] -> Pair) -> Maybe [Text] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe [Text]
apiSignatures,
            (Key
"uniqueApis" Core..=) (Int32 -> Pair) -> Maybe Int32 -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Int32
uniqueApis
          ]
      )

-- | Contains a summary and examples of non-sdk API usage violations.
--
-- /See:/ 'newNonSdkApiUsageViolationReport' smart constructor.
data NonSdkApiUsageViolationReport = NonSdkApiUsageViolationReport
  { -- | Examples of the detected API usages.
    NonSdkApiUsageViolationReport -> Maybe [NonSdkApi]
exampleApis :: (Core.Maybe [NonSdkApi]),
    -- | Minimum API level required for the application to run.
    NonSdkApiUsageViolationReport -> Maybe Int32
minSdkVersion :: (Core.Maybe Core.Int32),
    -- | Specifies the API Level on which the application is designed to run.
    NonSdkApiUsageViolationReport -> Maybe Int32
targetSdkVersion :: (Core.Maybe Core.Int32),
    -- | Total number of unique Non-SDK API\'s accessed.
    NonSdkApiUsageViolationReport -> Maybe Int32
uniqueApis :: (Core.Maybe Core.Int32)
  }
  deriving (NonSdkApiUsageViolationReport
-> NonSdkApiUsageViolationReport -> Bool
(NonSdkApiUsageViolationReport
 -> NonSdkApiUsageViolationReport -> Bool)
-> (NonSdkApiUsageViolationReport
    -> NonSdkApiUsageViolationReport -> Bool)
-> Eq NonSdkApiUsageViolationReport
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NonSdkApiUsageViolationReport
-> NonSdkApiUsageViolationReport -> Bool
== :: NonSdkApiUsageViolationReport
-> NonSdkApiUsageViolationReport -> Bool
$c/= :: NonSdkApiUsageViolationReport
-> NonSdkApiUsageViolationReport -> Bool
/= :: NonSdkApiUsageViolationReport
-> NonSdkApiUsageViolationReport -> Bool
Core.Eq, Int -> NonSdkApiUsageViolationReport -> ShowS
[NonSdkApiUsageViolationReport] -> ShowS
NonSdkApiUsageViolationReport -> String
(Int -> NonSdkApiUsageViolationReport -> ShowS)
-> (NonSdkApiUsageViolationReport -> String)
-> ([NonSdkApiUsageViolationReport] -> ShowS)
-> Show NonSdkApiUsageViolationReport
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NonSdkApiUsageViolationReport -> ShowS
showsPrec :: Int -> NonSdkApiUsageViolationReport -> ShowS
$cshow :: NonSdkApiUsageViolationReport -> String
show :: NonSdkApiUsageViolationReport -> String
$cshowList :: [NonSdkApiUsageViolationReport] -> ShowS
showList :: [NonSdkApiUsageViolationReport] -> ShowS
Core.Show, (forall x.
 NonSdkApiUsageViolationReport
 -> Rep NonSdkApiUsageViolationReport x)
-> (forall x.
    Rep NonSdkApiUsageViolationReport x
    -> NonSdkApiUsageViolationReport)
-> Generic NonSdkApiUsageViolationReport
forall x.
Rep NonSdkApiUsageViolationReport x
-> NonSdkApiUsageViolationReport
forall x.
NonSdkApiUsageViolationReport
-> Rep NonSdkApiUsageViolationReport x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
NonSdkApiUsageViolationReport
-> Rep NonSdkApiUsageViolationReport x
from :: forall x.
NonSdkApiUsageViolationReport
-> Rep NonSdkApiUsageViolationReport x
$cto :: forall x.
Rep NonSdkApiUsageViolationReport x
-> NonSdkApiUsageViolationReport
to :: forall x.
Rep NonSdkApiUsageViolationReport x
-> NonSdkApiUsageViolationReport
Core.Generic)

-- | Creates a value of 'NonSdkApiUsageViolationReport' with the minimum fields required to make a request.
newNonSdkApiUsageViolationReport ::
  NonSdkApiUsageViolationReport
newNonSdkApiUsageViolationReport :: NonSdkApiUsageViolationReport
newNonSdkApiUsageViolationReport =
  NonSdkApiUsageViolationReport
    { exampleApis :: Maybe [NonSdkApi]
exampleApis = Maybe [NonSdkApi]
forall a. Maybe a
Core.Nothing,
      minSdkVersion :: Maybe Int32
minSdkVersion = Maybe Int32
forall a. Maybe a
Core.Nothing,
      targetSdkVersion :: Maybe Int32
targetSdkVersion = Maybe Int32
forall a. Maybe a
Core.Nothing,
      uniqueApis :: Maybe Int32
uniqueApis = Maybe Int32
forall a. Maybe a
Core.Nothing
    }

instance Core.FromJSON NonSdkApiUsageViolationReport where
  parseJSON :: Value -> Parser NonSdkApiUsageViolationReport
parseJSON =
    String
-> (Object -> Parser NonSdkApiUsageViolationReport)
-> Value
-> Parser NonSdkApiUsageViolationReport
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"NonSdkApiUsageViolationReport"
      ( \Object
o ->
          Maybe [NonSdkApi]
-> Maybe Int32
-> Maybe Int32
-> Maybe Int32
-> NonSdkApiUsageViolationReport
NonSdkApiUsageViolationReport
            (Maybe [NonSdkApi]
 -> Maybe Int32
 -> Maybe Int32
 -> Maybe Int32
 -> NonSdkApiUsageViolationReport)
-> Parser (Maybe [NonSdkApi])
-> Parser
     (Maybe Int32
      -> Maybe Int32 -> Maybe Int32 -> NonSdkApiUsageViolationReport)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe [NonSdkApi])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"exampleApis")
            Parser
  (Maybe Int32
   -> Maybe Int32 -> Maybe Int32 -> NonSdkApiUsageViolationReport)
-> Parser (Maybe Int32)
-> Parser
     (Maybe Int32 -> Maybe Int32 -> NonSdkApiUsageViolationReport)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe Int32)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"minSdkVersion")
            Parser
  (Maybe Int32 -> Maybe Int32 -> NonSdkApiUsageViolationReport)
-> Parser (Maybe Int32)
-> Parser (Maybe Int32 -> NonSdkApiUsageViolationReport)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe Int32)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"targetSdkVersion")
            Parser (Maybe Int32 -> NonSdkApiUsageViolationReport)
-> Parser (Maybe Int32) -> Parser NonSdkApiUsageViolationReport
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe Int32)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"uniqueApis")
      )

instance Core.ToJSON NonSdkApiUsageViolationReport where
  toJSON :: NonSdkApiUsageViolationReport -> Value
toJSON NonSdkApiUsageViolationReport {Maybe Int32
Maybe [NonSdkApi]
exampleApis :: NonSdkApiUsageViolationReport -> Maybe [NonSdkApi]
minSdkVersion :: NonSdkApiUsageViolationReport -> Maybe Int32
targetSdkVersion :: NonSdkApiUsageViolationReport -> Maybe Int32
uniqueApis :: NonSdkApiUsageViolationReport -> Maybe Int32
exampleApis :: Maybe [NonSdkApi]
minSdkVersion :: Maybe Int32
targetSdkVersion :: Maybe Int32
uniqueApis :: Maybe Int32
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes
          [ (Key
"exampleApis" Core..=) ([NonSdkApi] -> Pair) -> Maybe [NonSdkApi] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe [NonSdkApi]
exampleApis,
            (Key
"minSdkVersion" Core..=) (Int32 -> Pair) -> Maybe Int32 -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Int32
minSdkVersion,
            (Key
"targetSdkVersion" Core..=) (Int32 -> Pair) -> Maybe Int32 -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Int32
targetSdkVersion,
            (Key
"uniqueApis" Core..=) (Int32 -> Pair) -> Maybe Int32 -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Int32
uniqueApis
          ]
      )

-- | A warning that Robo encountered a screen that has overlapping clickable elements; this may indicate a potential UI issue.
--
-- /See:/ 'newOverlappingUIElements' smart constructor.
data OverlappingUIElements = OverlappingUIElements
  { -- | Resource names of the overlapping screen elements
    OverlappingUIElements -> Maybe [Text]
resourceName :: (Core.Maybe [Core.Text]),
    -- | The screen id of the elements
    OverlappingUIElements -> Maybe Text
screenId :: (Core.Maybe Core.Text)
  }
  deriving (OverlappingUIElements -> OverlappingUIElements -> Bool
(OverlappingUIElements -> OverlappingUIElements -> Bool)
-> (OverlappingUIElements -> OverlappingUIElements -> Bool)
-> Eq OverlappingUIElements
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OverlappingUIElements -> OverlappingUIElements -> Bool
== :: OverlappingUIElements -> OverlappingUIElements -> Bool
$c/= :: OverlappingUIElements -> OverlappingUIElements -> Bool
/= :: OverlappingUIElements -> OverlappingUIElements -> Bool
Core.Eq, Int -> OverlappingUIElements -> ShowS
[OverlappingUIElements] -> ShowS
OverlappingUIElements -> String
(Int -> OverlappingUIElements -> ShowS)
-> (OverlappingUIElements -> String)
-> ([OverlappingUIElements] -> ShowS)
-> Show OverlappingUIElements
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OverlappingUIElements -> ShowS
showsPrec :: Int -> OverlappingUIElements -> ShowS
$cshow :: OverlappingUIElements -> String
show :: OverlappingUIElements -> String
$cshowList :: [OverlappingUIElements] -> ShowS
showList :: [OverlappingUIElements] -> ShowS
Core.Show, (forall x. OverlappingUIElements -> Rep OverlappingUIElements x)
-> (forall x. Rep OverlappingUIElements x -> OverlappingUIElements)
-> Generic OverlappingUIElements
forall x. Rep OverlappingUIElements x -> OverlappingUIElements
forall x. OverlappingUIElements -> Rep OverlappingUIElements x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. OverlappingUIElements -> Rep OverlappingUIElements x
from :: forall x. OverlappingUIElements -> Rep OverlappingUIElements x
$cto :: forall x. Rep OverlappingUIElements x -> OverlappingUIElements
to :: forall x. Rep OverlappingUIElements x -> OverlappingUIElements
Core.Generic)

-- | Creates a value of 'OverlappingUIElements' with the minimum fields required to make a request.
newOverlappingUIElements ::
  OverlappingUIElements
newOverlappingUIElements :: OverlappingUIElements
newOverlappingUIElements =
  OverlappingUIElements
    { resourceName :: Maybe [Text]
resourceName = Maybe [Text]
forall a. Maybe a
Core.Nothing,
      screenId :: Maybe Text
screenId = Maybe Text
forall a. Maybe a
Core.Nothing
    }

instance Core.FromJSON OverlappingUIElements where
  parseJSON :: Value -> Parser OverlappingUIElements
parseJSON =
    String
-> (Object -> Parser OverlappingUIElements)
-> Value
-> Parser OverlappingUIElements
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"OverlappingUIElements"
      ( \Object
o ->
          Maybe [Text] -> Maybe Text -> OverlappingUIElements
OverlappingUIElements
            (Maybe [Text] -> Maybe Text -> OverlappingUIElements)
-> Parser (Maybe [Text])
-> Parser (Maybe Text -> OverlappingUIElements)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe [Text])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"resourceName")
            Parser (Maybe Text -> OverlappingUIElements)
-> Parser (Maybe Text) -> Parser OverlappingUIElements
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"screenId")
      )

instance Core.ToJSON OverlappingUIElements where
  toJSON :: OverlappingUIElements -> Value
toJSON OverlappingUIElements {Maybe [Text]
Maybe Text
resourceName :: OverlappingUIElements -> Maybe [Text]
screenId :: OverlappingUIElements -> Maybe Text
resourceName :: Maybe [Text]
screenId :: Maybe Text
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes
          [ (Key
"resourceName" Core..=) ([Text] -> Pair) -> Maybe [Text] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe [Text]
resourceName,
            (Key
"screenId" Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Text
screenId
          ]
      )

-- | This insight indicates that the hidden API usage originates from a Google-provided library. Users need not take any action.
--
-- /See:/ 'newPendingGoogleUpdateInsight' smart constructor.
newtype PendingGoogleUpdateInsight = PendingGoogleUpdateInsight
  { -- | The name of the Google-provided library with the non-SDK API dependency.
    PendingGoogleUpdateInsight -> Maybe Text
nameOfGoogleLibrary :: (Core.Maybe Core.Text)
  }
  deriving (PendingGoogleUpdateInsight -> PendingGoogleUpdateInsight -> Bool
(PendingGoogleUpdateInsight -> PendingGoogleUpdateInsight -> Bool)
-> (PendingGoogleUpdateInsight
    -> PendingGoogleUpdateInsight -> Bool)
-> Eq PendingGoogleUpdateInsight
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PendingGoogleUpdateInsight -> PendingGoogleUpdateInsight -> Bool
== :: PendingGoogleUpdateInsight -> PendingGoogleUpdateInsight -> Bool
$c/= :: PendingGoogleUpdateInsight -> PendingGoogleUpdateInsight -> Bool
/= :: PendingGoogleUpdateInsight -> PendingGoogleUpdateInsight -> Bool
Core.Eq, Int -> PendingGoogleUpdateInsight -> ShowS
[PendingGoogleUpdateInsight] -> ShowS
PendingGoogleUpdateInsight -> String
(Int -> PendingGoogleUpdateInsight -> ShowS)
-> (PendingGoogleUpdateInsight -> String)
-> ([PendingGoogleUpdateInsight] -> ShowS)
-> Show PendingGoogleUpdateInsight
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PendingGoogleUpdateInsight -> ShowS
showsPrec :: Int -> PendingGoogleUpdateInsight -> ShowS
$cshow :: PendingGoogleUpdateInsight -> String
show :: PendingGoogleUpdateInsight -> String
$cshowList :: [PendingGoogleUpdateInsight] -> ShowS
showList :: [PendingGoogleUpdateInsight] -> ShowS
Core.Show, (forall x.
 PendingGoogleUpdateInsight -> Rep PendingGoogleUpdateInsight x)
-> (forall x.
    Rep PendingGoogleUpdateInsight x -> PendingGoogleUpdateInsight)
-> Generic PendingGoogleUpdateInsight
forall x.
Rep PendingGoogleUpdateInsight x -> PendingGoogleUpdateInsight
forall x.
PendingGoogleUpdateInsight -> Rep PendingGoogleUpdateInsight x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
PendingGoogleUpdateInsight -> Rep PendingGoogleUpdateInsight x
from :: forall x.
PendingGoogleUpdateInsight -> Rep PendingGoogleUpdateInsight x
$cto :: forall x.
Rep PendingGoogleUpdateInsight x -> PendingGoogleUpdateInsight
to :: forall x.
Rep PendingGoogleUpdateInsight x -> PendingGoogleUpdateInsight
Core.Generic)

-- | Creates a value of 'PendingGoogleUpdateInsight' with the minimum fields required to make a request.
newPendingGoogleUpdateInsight ::
  PendingGoogleUpdateInsight
newPendingGoogleUpdateInsight :: PendingGoogleUpdateInsight
newPendingGoogleUpdateInsight =
  PendingGoogleUpdateInsight {nameOfGoogleLibrary :: Maybe Text
nameOfGoogleLibrary = Maybe Text
forall a. Maybe a
Core.Nothing}

instance Core.FromJSON PendingGoogleUpdateInsight where
  parseJSON :: Value -> Parser PendingGoogleUpdateInsight
parseJSON =
    String
-> (Object -> Parser PendingGoogleUpdateInsight)
-> Value
-> Parser PendingGoogleUpdateInsight
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"PendingGoogleUpdateInsight"
      ( \Object
o ->
          Maybe Text -> PendingGoogleUpdateInsight
PendingGoogleUpdateInsight
            (Maybe Text -> PendingGoogleUpdateInsight)
-> Parser (Maybe Text) -> Parser PendingGoogleUpdateInsight
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"nameOfGoogleLibrary")
      )

instance Core.ToJSON PendingGoogleUpdateInsight where
  toJSON :: PendingGoogleUpdateInsight -> Value
toJSON PendingGoogleUpdateInsight {Maybe Text
nameOfGoogleLibrary :: PendingGoogleUpdateInsight -> Maybe Text
nameOfGoogleLibrary :: Maybe Text
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes
          [(Key
"nameOfGoogleLibrary" Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Text
nameOfGoogleLibrary]
      )

-- | A notification that Robo signed in with Google.
--
-- /See:/ 'newPerformedGoogleLogin' smart constructor.
data PerformedGoogleLogin = PerformedGoogleLogin
  deriving (PerformedGoogleLogin -> PerformedGoogleLogin -> Bool
(PerformedGoogleLogin -> PerformedGoogleLogin -> Bool)
-> (PerformedGoogleLogin -> PerformedGoogleLogin -> Bool)
-> Eq PerformedGoogleLogin
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PerformedGoogleLogin -> PerformedGoogleLogin -> Bool
== :: PerformedGoogleLogin -> PerformedGoogleLogin -> Bool
$c/= :: PerformedGoogleLogin -> PerformedGoogleLogin -> Bool
/= :: PerformedGoogleLogin -> PerformedGoogleLogin -> Bool
Core.Eq, Int -> PerformedGoogleLogin -> ShowS
[PerformedGoogleLogin] -> ShowS
PerformedGoogleLogin -> String
(Int -> PerformedGoogleLogin -> ShowS)
-> (PerformedGoogleLogin -> String)
-> ([PerformedGoogleLogin] -> ShowS)
-> Show PerformedGoogleLogin
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PerformedGoogleLogin -> ShowS
showsPrec :: Int -> PerformedGoogleLogin -> ShowS
$cshow :: PerformedGoogleLogin -> String
show :: PerformedGoogleLogin -> String
$cshowList :: [PerformedGoogleLogin] -> ShowS
showList :: [PerformedGoogleLogin] -> ShowS
Core.Show, (forall x. PerformedGoogleLogin -> Rep PerformedGoogleLogin x)
-> (forall x. Rep PerformedGoogleLogin x -> PerformedGoogleLogin)
-> Generic PerformedGoogleLogin
forall x. Rep PerformedGoogleLogin x -> PerformedGoogleLogin
forall x. PerformedGoogleLogin -> Rep PerformedGoogleLogin x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PerformedGoogleLogin -> Rep PerformedGoogleLogin x
from :: forall x. PerformedGoogleLogin -> Rep PerformedGoogleLogin x
$cto :: forall x. Rep PerformedGoogleLogin x -> PerformedGoogleLogin
to :: forall x. Rep PerformedGoogleLogin x -> PerformedGoogleLogin
Core.Generic)

-- | Creates a value of 'PerformedGoogleLogin' with the minimum fields required to make a request.
newPerformedGoogleLogin ::
  PerformedGoogleLogin
newPerformedGoogleLogin :: PerformedGoogleLogin
newPerformedGoogleLogin = PerformedGoogleLogin
PerformedGoogleLogin

instance Core.FromJSON PerformedGoogleLogin where
  parseJSON :: Value -> Parser PerformedGoogleLogin
parseJSON =
    String
-> (Object -> Parser PerformedGoogleLogin)
-> Value
-> Parser PerformedGoogleLogin
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"PerformedGoogleLogin"
      (\Object
o -> PerformedGoogleLogin -> Parser PerformedGoogleLogin
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
Core.pure PerformedGoogleLogin
PerformedGoogleLogin)

instance Core.ToJSON PerformedGoogleLogin where
  toJSON :: PerformedGoogleLogin -> Value
toJSON = Value -> PerformedGoogleLogin -> Value
forall a b. a -> b -> a
Core.const Value
Core.emptyObject

-- | A notification that Robo performed some monkey actions.
--
-- /See:/ 'newPerformedMonkeyActions' smart constructor.
newtype PerformedMonkeyActions = PerformedMonkeyActions
  { -- | The total number of monkey actions performed during the crawl.
    PerformedMonkeyActions -> Maybe Int32
totalActions :: (Core.Maybe Core.Int32)
  }
  deriving (PerformedMonkeyActions -> PerformedMonkeyActions -> Bool
(PerformedMonkeyActions -> PerformedMonkeyActions -> Bool)
-> (PerformedMonkeyActions -> PerformedMonkeyActions -> Bool)
-> Eq PerformedMonkeyActions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PerformedMonkeyActions -> PerformedMonkeyActions -> Bool
== :: PerformedMonkeyActions -> PerformedMonkeyActions -> Bool
$c/= :: PerformedMonkeyActions -> PerformedMonkeyActions -> Bool
/= :: PerformedMonkeyActions -> PerformedMonkeyActions -> Bool
Core.Eq, Int -> PerformedMonkeyActions -> ShowS
[PerformedMonkeyActions] -> ShowS
PerformedMonkeyActions -> String
(Int -> PerformedMonkeyActions -> ShowS)
-> (PerformedMonkeyActions -> String)
-> ([PerformedMonkeyActions] -> ShowS)
-> Show PerformedMonkeyActions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PerformedMonkeyActions -> ShowS
showsPrec :: Int -> PerformedMonkeyActions -> ShowS
$cshow :: PerformedMonkeyActions -> String
show :: PerformedMonkeyActions -> String
$cshowList :: [PerformedMonkeyActions] -> ShowS
showList :: [PerformedMonkeyActions] -> ShowS
Core.Show, (forall x. PerformedMonkeyActions -> Rep PerformedMonkeyActions x)
-> (forall x.
    Rep PerformedMonkeyActions x -> PerformedMonkeyActions)
-> Generic PerformedMonkeyActions
forall x. Rep PerformedMonkeyActions x -> PerformedMonkeyActions
forall x. PerformedMonkeyActions -> Rep PerformedMonkeyActions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PerformedMonkeyActions -> Rep PerformedMonkeyActions x
from :: forall x. PerformedMonkeyActions -> Rep PerformedMonkeyActions x
$cto :: forall x. Rep PerformedMonkeyActions x -> PerformedMonkeyActions
to :: forall x. Rep PerformedMonkeyActions x -> PerformedMonkeyActions
Core.Generic)

-- | Creates a value of 'PerformedMonkeyActions' with the minimum fields required to make a request.
newPerformedMonkeyActions ::
  PerformedMonkeyActions
newPerformedMonkeyActions :: PerformedMonkeyActions
newPerformedMonkeyActions =
  PerformedMonkeyActions {totalActions :: Maybe Int32
totalActions = Maybe Int32
forall a. Maybe a
Core.Nothing}

instance Core.FromJSON PerformedMonkeyActions where
  parseJSON :: Value -> Parser PerformedMonkeyActions
parseJSON =
    String
-> (Object -> Parser PerformedMonkeyActions)
-> Value
-> Parser PerformedMonkeyActions
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"PerformedMonkeyActions"
      ( \Object
o ->
          Maybe Int32 -> PerformedMonkeyActions
PerformedMonkeyActions (Maybe Int32 -> PerformedMonkeyActions)
-> Parser (Maybe Int32) -> Parser PerformedMonkeyActions
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe Int32)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"totalActions")
      )

instance Core.ToJSON PerformedMonkeyActions where
  toJSON :: PerformedMonkeyActions -> Value
toJSON PerformedMonkeyActions {Maybe Int32
totalActions :: PerformedMonkeyActions -> Maybe Int32
totalActions :: Maybe Int32
..} =
    [Pair] -> Value
Core.object
      ([Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes [(Key
"totalActions" Core..=) (Int32 -> Pair) -> Maybe Int32 -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Int32
totalActions])

-- | Execution stats for a user-provided Robo script.
--
-- /See:/ 'newRoboScriptExecution' smart constructor.
data RoboScriptExecution = RoboScriptExecution
  { -- | The number of Robo script actions executed successfully.
    RoboScriptExecution -> Maybe Int32
successfulActions :: (Core.Maybe Core.Int32),
    -- | The total number of actions in the Robo script.
    RoboScriptExecution -> Maybe Int32
totalActions :: (Core.Maybe Core.Int32)
  }
  deriving (RoboScriptExecution -> RoboScriptExecution -> Bool
(RoboScriptExecution -> RoboScriptExecution -> Bool)
-> (RoboScriptExecution -> RoboScriptExecution -> Bool)
-> Eq RoboScriptExecution
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RoboScriptExecution -> RoboScriptExecution -> Bool
== :: RoboScriptExecution -> RoboScriptExecution -> Bool
$c/= :: RoboScriptExecution -> RoboScriptExecution -> Bool
/= :: RoboScriptExecution -> RoboScriptExecution -> Bool
Core.Eq, Int -> RoboScriptExecution -> ShowS
[RoboScriptExecution] -> ShowS
RoboScriptExecution -> String
(Int -> RoboScriptExecution -> ShowS)
-> (RoboScriptExecution -> String)
-> ([RoboScriptExecution] -> ShowS)
-> Show RoboScriptExecution
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RoboScriptExecution -> ShowS
showsPrec :: Int -> RoboScriptExecution -> ShowS
$cshow :: RoboScriptExecution -> String
show :: RoboScriptExecution -> String
$cshowList :: [RoboScriptExecution] -> ShowS
showList :: [RoboScriptExecution] -> ShowS
Core.Show, (forall x. RoboScriptExecution -> Rep RoboScriptExecution x)
-> (forall x. Rep RoboScriptExecution x -> RoboScriptExecution)
-> Generic RoboScriptExecution
forall x. Rep RoboScriptExecution x -> RoboScriptExecution
forall x. RoboScriptExecution -> Rep RoboScriptExecution x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RoboScriptExecution -> Rep RoboScriptExecution x
from :: forall x. RoboScriptExecution -> Rep RoboScriptExecution x
$cto :: forall x. Rep RoboScriptExecution x -> RoboScriptExecution
to :: forall x. Rep RoboScriptExecution x -> RoboScriptExecution
Core.Generic)

-- | Creates a value of 'RoboScriptExecution' with the minimum fields required to make a request.
newRoboScriptExecution ::
  RoboScriptExecution
newRoboScriptExecution :: RoboScriptExecution
newRoboScriptExecution =
  RoboScriptExecution
    { successfulActions :: Maybe Int32
successfulActions = Maybe Int32
forall a. Maybe a
Core.Nothing,
      totalActions :: Maybe Int32
totalActions = Maybe Int32
forall a. Maybe a
Core.Nothing
    }

instance Core.FromJSON RoboScriptExecution where
  parseJSON :: Value -> Parser RoboScriptExecution
parseJSON =
    String
-> (Object -> Parser RoboScriptExecution)
-> Value
-> Parser RoboScriptExecution
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"RoboScriptExecution"
      ( \Object
o ->
          Maybe Int32 -> Maybe Int32 -> RoboScriptExecution
RoboScriptExecution
            (Maybe Int32 -> Maybe Int32 -> RoboScriptExecution)
-> Parser (Maybe Int32)
-> Parser (Maybe Int32 -> RoboScriptExecution)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe Int32)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"successfulActions")
            Parser (Maybe Int32 -> RoboScriptExecution)
-> Parser (Maybe Int32) -> Parser RoboScriptExecution
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe Int32)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"totalActions")
      )

instance Core.ToJSON RoboScriptExecution where
  toJSON :: RoboScriptExecution -> Value
toJSON RoboScriptExecution {Maybe Int32
successfulActions :: RoboScriptExecution -> Maybe Int32
totalActions :: RoboScriptExecution -> Maybe Int32
successfulActions :: Maybe Int32
totalActions :: Maybe Int32
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes
          [ (Key
"successfulActions" Core..=) (Int32 -> Pair) -> Maybe Int32 -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Int32
successfulActions,
            (Key
"totalActions" Core..=) (Int32 -> Pair) -> Maybe Int32 -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Int32
totalActions
          ]
      )

-- | A stacktrace.
--
-- /See:/ 'newStackTrace' smart constructor.
newtype StackTrace = StackTrace
  { -- | The stack trace message.
    --
    -- Required
    StackTrace -> Maybe Text
exception :: (Core.Maybe Core.Text)
  }
  deriving (StackTrace -> StackTrace -> Bool
(StackTrace -> StackTrace -> Bool)
-> (StackTrace -> StackTrace -> Bool) -> Eq StackTrace
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StackTrace -> StackTrace -> Bool
== :: StackTrace -> StackTrace -> Bool
$c/= :: StackTrace -> StackTrace -> Bool
/= :: StackTrace -> StackTrace -> Bool
Core.Eq, Int -> StackTrace -> ShowS
[StackTrace] -> ShowS
StackTrace -> String
(Int -> StackTrace -> ShowS)
-> (StackTrace -> String)
-> ([StackTrace] -> ShowS)
-> Show StackTrace
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StackTrace -> ShowS
showsPrec :: Int -> StackTrace -> ShowS
$cshow :: StackTrace -> String
show :: StackTrace -> String
$cshowList :: [StackTrace] -> ShowS
showList :: [StackTrace] -> ShowS
Core.Show, (forall x. StackTrace -> Rep StackTrace x)
-> (forall x. Rep StackTrace x -> StackTrace) -> Generic StackTrace
forall x. Rep StackTrace x -> StackTrace
forall x. StackTrace -> Rep StackTrace x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. StackTrace -> Rep StackTrace x
from :: forall x. StackTrace -> Rep StackTrace x
$cto :: forall x. Rep StackTrace x -> StackTrace
to :: forall x. Rep StackTrace x -> StackTrace
Core.Generic)

-- | Creates a value of 'StackTrace' with the minimum fields required to make a request.
newStackTrace ::
  StackTrace
newStackTrace :: StackTrace
newStackTrace = StackTrace {exception :: Maybe Text
exception = Maybe Text
forall a. Maybe a
Core.Nothing}

instance Core.FromJSON StackTrace where
  parseJSON :: Value -> Parser StackTrace
parseJSON =
    String
-> (Object -> Parser StackTrace) -> Value -> Parser StackTrace
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"StackTrace"
      (\Object
o -> Maybe Text -> StackTrace
StackTrace (Maybe Text -> StackTrace)
-> Parser (Maybe Text) -> Parser StackTrace
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"exception"))

instance Core.ToJSON StackTrace where
  toJSON :: StackTrace -> Value
toJSON StackTrace {Maybe Text
exception :: StackTrace -> Maybe Text
exception :: Maybe Text
..} =
    [Pair] -> Value
Core.object
      ([Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes [(Key
"exception" Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Text
exception])

-- | User provided intent failed to resolve to an activity.
--
-- /See:/ 'newStartActivityNotFound' smart constructor.
data StartActivityNotFound = StartActivityNotFound
  { StartActivityNotFound -> Maybe Text
action :: (Core.Maybe Core.Text),
    StartActivityNotFound -> Maybe Text
uri :: (Core.Maybe Core.Text)
  }
  deriving (StartActivityNotFound -> StartActivityNotFound -> Bool
(StartActivityNotFound -> StartActivityNotFound -> Bool)
-> (StartActivityNotFound -> StartActivityNotFound -> Bool)
-> Eq StartActivityNotFound
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StartActivityNotFound -> StartActivityNotFound -> Bool
== :: StartActivityNotFound -> StartActivityNotFound -> Bool
$c/= :: StartActivityNotFound -> StartActivityNotFound -> Bool
/= :: StartActivityNotFound -> StartActivityNotFound -> Bool
Core.Eq, Int -> StartActivityNotFound -> ShowS
[StartActivityNotFound] -> ShowS
StartActivityNotFound -> String
(Int -> StartActivityNotFound -> ShowS)
-> (StartActivityNotFound -> String)
-> ([StartActivityNotFound] -> ShowS)
-> Show StartActivityNotFound
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StartActivityNotFound -> ShowS
showsPrec :: Int -> StartActivityNotFound -> ShowS
$cshow :: StartActivityNotFound -> String
show :: StartActivityNotFound -> String
$cshowList :: [StartActivityNotFound] -> ShowS
showList :: [StartActivityNotFound] -> ShowS
Core.Show, (forall x. StartActivityNotFound -> Rep StartActivityNotFound x)
-> (forall x. Rep StartActivityNotFound x -> StartActivityNotFound)
-> Generic StartActivityNotFound
forall x. Rep StartActivityNotFound x -> StartActivityNotFound
forall x. StartActivityNotFound -> Rep StartActivityNotFound x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. StartActivityNotFound -> Rep StartActivityNotFound x
from :: forall x. StartActivityNotFound -> Rep StartActivityNotFound x
$cto :: forall x. Rep StartActivityNotFound x -> StartActivityNotFound
to :: forall x. Rep StartActivityNotFound x -> StartActivityNotFound
Core.Generic)

-- | Creates a value of 'StartActivityNotFound' with the minimum fields required to make a request.
newStartActivityNotFound ::
  StartActivityNotFound
newStartActivityNotFound :: StartActivityNotFound
newStartActivityNotFound =
  StartActivityNotFound {action :: Maybe Text
action = Maybe Text
forall a. Maybe a
Core.Nothing, uri :: Maybe Text
uri = Maybe Text
forall a. Maybe a
Core.Nothing}

instance Core.FromJSON StartActivityNotFound where
  parseJSON :: Value -> Parser StartActivityNotFound
parseJSON =
    String
-> (Object -> Parser StartActivityNotFound)
-> Value
-> Parser StartActivityNotFound
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"StartActivityNotFound"
      ( \Object
o ->
          Maybe Text -> Maybe Text -> StartActivityNotFound
StartActivityNotFound
            (Maybe Text -> Maybe Text -> StartActivityNotFound)
-> Parser (Maybe Text)
-> Parser (Maybe Text -> StartActivityNotFound)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"action")
            Parser (Maybe Text -> StartActivityNotFound)
-> Parser (Maybe Text) -> Parser StartActivityNotFound
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"uri")
      )

instance Core.ToJSON StartActivityNotFound where
  toJSON :: StartActivityNotFound -> Value
toJSON StartActivityNotFound {Maybe Text
action :: StartActivityNotFound -> Maybe Text
uri :: StartActivityNotFound -> Maybe Text
action :: Maybe Text
uri :: Maybe Text
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes
          [(Key
"action" Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Text
action, (Key
"uri" Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Text
uri]
      )

-- | A warning that the screen hierarchy is deeper than the recommended threshold.
--
-- /See:/ 'newUIElementTooDeep' smart constructor.
data UIElementTooDeep = UIElementTooDeep
  { -- | The depth of the screen element
    UIElementTooDeep -> Maybe Int32
depth :: (Core.Maybe Core.Int32),
    -- | The screen id of the element
    UIElementTooDeep -> Maybe Text
screenId :: (Core.Maybe Core.Text),
    -- | The screen state id of the element
    UIElementTooDeep -> Maybe Text
screenStateId :: (Core.Maybe Core.Text)
  }
  deriving (UIElementTooDeep -> UIElementTooDeep -> Bool
(UIElementTooDeep -> UIElementTooDeep -> Bool)
-> (UIElementTooDeep -> UIElementTooDeep -> Bool)
-> Eq UIElementTooDeep
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UIElementTooDeep -> UIElementTooDeep -> Bool
== :: UIElementTooDeep -> UIElementTooDeep -> Bool
$c/= :: UIElementTooDeep -> UIElementTooDeep -> Bool
/= :: UIElementTooDeep -> UIElementTooDeep -> Bool
Core.Eq, Int -> UIElementTooDeep -> ShowS
[UIElementTooDeep] -> ShowS
UIElementTooDeep -> String
(Int -> UIElementTooDeep -> ShowS)
-> (UIElementTooDeep -> String)
-> ([UIElementTooDeep] -> ShowS)
-> Show UIElementTooDeep
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UIElementTooDeep -> ShowS
showsPrec :: Int -> UIElementTooDeep -> ShowS
$cshow :: UIElementTooDeep -> String
show :: UIElementTooDeep -> String
$cshowList :: [UIElementTooDeep] -> ShowS
showList :: [UIElementTooDeep] -> ShowS
Core.Show, (forall x. UIElementTooDeep -> Rep UIElementTooDeep x)
-> (forall x. Rep UIElementTooDeep x -> UIElementTooDeep)
-> Generic UIElementTooDeep
forall x. Rep UIElementTooDeep x -> UIElementTooDeep
forall x. UIElementTooDeep -> Rep UIElementTooDeep x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UIElementTooDeep -> Rep UIElementTooDeep x
from :: forall x. UIElementTooDeep -> Rep UIElementTooDeep x
$cto :: forall x. Rep UIElementTooDeep x -> UIElementTooDeep
to :: forall x. Rep UIElementTooDeep x -> UIElementTooDeep
Core.Generic)

-- | Creates a value of 'UIElementTooDeep' with the minimum fields required to make a request.
newUIElementTooDeep ::
  UIElementTooDeep
newUIElementTooDeep :: UIElementTooDeep
newUIElementTooDeep =
  UIElementTooDeep
    { depth :: Maybe Int32
depth = Maybe Int32
forall a. Maybe a
Core.Nothing,
      screenId :: Maybe Text
screenId = Maybe Text
forall a. Maybe a
Core.Nothing,
      screenStateId :: Maybe Text
screenStateId = Maybe Text
forall a. Maybe a
Core.Nothing
    }

instance Core.FromJSON UIElementTooDeep where
  parseJSON :: Value -> Parser UIElementTooDeep
parseJSON =
    String
-> (Object -> Parser UIElementTooDeep)
-> Value
-> Parser UIElementTooDeep
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"UIElementTooDeep"
      ( \Object
o ->
          Maybe Int32 -> Maybe Text -> Maybe Text -> UIElementTooDeep
UIElementTooDeep
            (Maybe Int32 -> Maybe Text -> Maybe Text -> UIElementTooDeep)
-> Parser (Maybe Int32)
-> Parser (Maybe Text -> Maybe Text -> UIElementTooDeep)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe Int32)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"depth")
            Parser (Maybe Text -> Maybe Text -> UIElementTooDeep)
-> Parser (Maybe Text) -> Parser (Maybe Text -> UIElementTooDeep)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"screenId")
            Parser (Maybe Text -> UIElementTooDeep)
-> Parser (Maybe Text) -> Parser UIElementTooDeep
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"screenStateId")
      )

instance Core.ToJSON UIElementTooDeep where
  toJSON :: UIElementTooDeep -> Value
toJSON UIElementTooDeep {Maybe Int32
Maybe Text
depth :: UIElementTooDeep -> Maybe Int32
screenId :: UIElementTooDeep -> Maybe Text
screenStateId :: UIElementTooDeep -> Maybe Text
depth :: Maybe Int32
screenId :: Maybe Text
screenStateId :: Maybe Text
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes
          [ (Key
"depth" Core..=) (Int32 -> Pair) -> Maybe Int32 -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Int32
depth,
            (Key
"screenId" Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Text
screenId,
            (Key
"screenStateId" Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Text
screenStateId
          ]
      )

-- | Default unspecified warning.
--
-- /See:/ 'newUnspecifiedWarning' smart constructor.
data UnspecifiedWarning = UnspecifiedWarning
  deriving (UnspecifiedWarning -> UnspecifiedWarning -> Bool
(UnspecifiedWarning -> UnspecifiedWarning -> Bool)
-> (UnspecifiedWarning -> UnspecifiedWarning -> Bool)
-> Eq UnspecifiedWarning
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnspecifiedWarning -> UnspecifiedWarning -> Bool
== :: UnspecifiedWarning -> UnspecifiedWarning -> Bool
$c/= :: UnspecifiedWarning -> UnspecifiedWarning -> Bool
/= :: UnspecifiedWarning -> UnspecifiedWarning -> Bool
Core.Eq, Int -> UnspecifiedWarning -> ShowS
[UnspecifiedWarning] -> ShowS
UnspecifiedWarning -> String
(Int -> UnspecifiedWarning -> ShowS)
-> (UnspecifiedWarning -> String)
-> ([UnspecifiedWarning] -> ShowS)
-> Show UnspecifiedWarning
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UnspecifiedWarning -> ShowS
showsPrec :: Int -> UnspecifiedWarning -> ShowS
$cshow :: UnspecifiedWarning -> String
show :: UnspecifiedWarning -> String
$cshowList :: [UnspecifiedWarning] -> ShowS
showList :: [UnspecifiedWarning] -> ShowS
Core.Show, (forall x. UnspecifiedWarning -> Rep UnspecifiedWarning x)
-> (forall x. Rep UnspecifiedWarning x -> UnspecifiedWarning)
-> Generic UnspecifiedWarning
forall x. Rep UnspecifiedWarning x -> UnspecifiedWarning
forall x. UnspecifiedWarning -> Rep UnspecifiedWarning x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UnspecifiedWarning -> Rep UnspecifiedWarning x
from :: forall x. UnspecifiedWarning -> Rep UnspecifiedWarning x
$cto :: forall x. Rep UnspecifiedWarning x -> UnspecifiedWarning
to :: forall x. Rep UnspecifiedWarning x -> UnspecifiedWarning
Core.Generic)

-- | Creates a value of 'UnspecifiedWarning' with the minimum fields required to make a request.
newUnspecifiedWarning ::
  UnspecifiedWarning
newUnspecifiedWarning :: UnspecifiedWarning
newUnspecifiedWarning = UnspecifiedWarning
UnspecifiedWarning

instance Core.FromJSON UnspecifiedWarning where
  parseJSON :: Value -> Parser UnspecifiedWarning
parseJSON =
    String
-> (Object -> Parser UnspecifiedWarning)
-> Value
-> Parser UnspecifiedWarning
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"UnspecifiedWarning"
      (\Object
o -> UnspecifiedWarning -> Parser UnspecifiedWarning
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
Core.pure UnspecifiedWarning
UnspecifiedWarning)

instance Core.ToJSON UnspecifiedWarning where
  toJSON :: UnspecifiedWarning -> Value
toJSON = Value -> UnspecifiedWarning -> Value
forall a b. a -> b -> a
Core.const Value
Core.emptyObject

-- | Additional details of an unused robodirective.
--
-- /See:/ 'newUnusedRoboDirective' smart constructor.
newtype UnusedRoboDirective = UnusedRoboDirective
  { -- | The name of the resource that was unused.
    UnusedRoboDirective -> Maybe Text
resourceName :: (Core.Maybe Core.Text)
  }
  deriving (UnusedRoboDirective -> UnusedRoboDirective -> Bool
(UnusedRoboDirective -> UnusedRoboDirective -> Bool)
-> (UnusedRoboDirective -> UnusedRoboDirective -> Bool)
-> Eq UnusedRoboDirective
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnusedRoboDirective -> UnusedRoboDirective -> Bool
== :: UnusedRoboDirective -> UnusedRoboDirective -> Bool
$c/= :: UnusedRoboDirective -> UnusedRoboDirective -> Bool
/= :: UnusedRoboDirective -> UnusedRoboDirective -> Bool
Core.Eq, Int -> UnusedRoboDirective -> ShowS
[UnusedRoboDirective] -> ShowS
UnusedRoboDirective -> String
(Int -> UnusedRoboDirective -> ShowS)
-> (UnusedRoboDirective -> String)
-> ([UnusedRoboDirective] -> ShowS)
-> Show UnusedRoboDirective
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UnusedRoboDirective -> ShowS
showsPrec :: Int -> UnusedRoboDirective -> ShowS
$cshow :: UnusedRoboDirective -> String
show :: UnusedRoboDirective -> String
$cshowList :: [UnusedRoboDirective] -> ShowS
showList :: [UnusedRoboDirective] -> ShowS
Core.Show, (forall x. UnusedRoboDirective -> Rep UnusedRoboDirective x)
-> (forall x. Rep UnusedRoboDirective x -> UnusedRoboDirective)
-> Generic UnusedRoboDirective
forall x. Rep UnusedRoboDirective x -> UnusedRoboDirective
forall x. UnusedRoboDirective -> Rep UnusedRoboDirective x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UnusedRoboDirective -> Rep UnusedRoboDirective x
from :: forall x. UnusedRoboDirective -> Rep UnusedRoboDirective x
$cto :: forall x. Rep UnusedRoboDirective x -> UnusedRoboDirective
to :: forall x. Rep UnusedRoboDirective x -> UnusedRoboDirective
Core.Generic)

-- | Creates a value of 'UnusedRoboDirective' with the minimum fields required to make a request.
newUnusedRoboDirective ::
  UnusedRoboDirective
newUnusedRoboDirective :: UnusedRoboDirective
newUnusedRoboDirective =
  UnusedRoboDirective {resourceName :: Maybe Text
resourceName = Maybe Text
forall a. Maybe a
Core.Nothing}

instance Core.FromJSON UnusedRoboDirective where
  parseJSON :: Value -> Parser UnusedRoboDirective
parseJSON =
    String
-> (Object -> Parser UnusedRoboDirective)
-> Value
-> Parser UnusedRoboDirective
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"UnusedRoboDirective"
      (\Object
o -> Maybe Text -> UnusedRoboDirective
UnusedRoboDirective (Maybe Text -> UnusedRoboDirective)
-> Parser (Maybe Text) -> Parser UnusedRoboDirective
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"resourceName"))

instance Core.ToJSON UnusedRoboDirective where
  toJSON :: UnusedRoboDirective -> Value
toJSON UnusedRoboDirective {Maybe Text
resourceName :: UnusedRoboDirective -> Maybe Text
resourceName :: Maybe Text
..} =
    [Pair] -> Value
Core.object
      ([Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes [(Key
"resourceName" Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Text
resourceName])

-- | This insight is a recommendation to upgrade a given library to the specified version, in order to avoid dependencies on non-SDK APIs.
--
-- /See:/ 'newUpgradeInsight' smart constructor.
data UpgradeInsight = UpgradeInsight
  { -- | The name of the package to be upgraded.
    UpgradeInsight -> Maybe Text
packageName :: (Core.Maybe Core.Text),
    -- | The suggested version to upgrade to. Optional: In case we are not sure which version solves this problem
    UpgradeInsight -> Maybe Text
upgradeToVersion :: (Core.Maybe Core.Text)
  }
  deriving (UpgradeInsight -> UpgradeInsight -> Bool
(UpgradeInsight -> UpgradeInsight -> Bool)
-> (UpgradeInsight -> UpgradeInsight -> Bool) -> Eq UpgradeInsight
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UpgradeInsight -> UpgradeInsight -> Bool
== :: UpgradeInsight -> UpgradeInsight -> Bool
$c/= :: UpgradeInsight -> UpgradeInsight -> Bool
/= :: UpgradeInsight -> UpgradeInsight -> Bool
Core.Eq, Int -> UpgradeInsight -> ShowS
[UpgradeInsight] -> ShowS
UpgradeInsight -> String
(Int -> UpgradeInsight -> ShowS)
-> (UpgradeInsight -> String)
-> ([UpgradeInsight] -> ShowS)
-> Show UpgradeInsight
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UpgradeInsight -> ShowS
showsPrec :: Int -> UpgradeInsight -> ShowS
$cshow :: UpgradeInsight -> String
show :: UpgradeInsight -> String
$cshowList :: [UpgradeInsight] -> ShowS
showList :: [UpgradeInsight] -> ShowS
Core.Show, (forall x. UpgradeInsight -> Rep UpgradeInsight x)
-> (forall x. Rep UpgradeInsight x -> UpgradeInsight)
-> Generic UpgradeInsight
forall x. Rep UpgradeInsight x -> UpgradeInsight
forall x. UpgradeInsight -> Rep UpgradeInsight x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UpgradeInsight -> Rep UpgradeInsight x
from :: forall x. UpgradeInsight -> Rep UpgradeInsight x
$cto :: forall x. Rep UpgradeInsight x -> UpgradeInsight
to :: forall x. Rep UpgradeInsight x -> UpgradeInsight
Core.Generic)

-- | Creates a value of 'UpgradeInsight' with the minimum fields required to make a request.
newUpgradeInsight ::
  UpgradeInsight
newUpgradeInsight :: UpgradeInsight
newUpgradeInsight =
  UpgradeInsight
    { packageName :: Maybe Text
packageName = Maybe Text
forall a. Maybe a
Core.Nothing,
      upgradeToVersion :: Maybe Text
upgradeToVersion = Maybe Text
forall a. Maybe a
Core.Nothing
    }

instance Core.FromJSON UpgradeInsight where
  parseJSON :: Value -> Parser UpgradeInsight
parseJSON =
    String
-> (Object -> Parser UpgradeInsight)
-> Value
-> Parser UpgradeInsight
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"UpgradeInsight"
      ( \Object
o ->
          Maybe Text -> Maybe Text -> UpgradeInsight
UpgradeInsight
            (Maybe Text -> Maybe Text -> UpgradeInsight)
-> Parser (Maybe Text) -> Parser (Maybe Text -> UpgradeInsight)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"packageName")
            Parser (Maybe Text -> UpgradeInsight)
-> Parser (Maybe Text) -> Parser UpgradeInsight
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Core.<*> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"upgradeToVersion")
      )

instance Core.ToJSON UpgradeInsight where
  toJSON :: UpgradeInsight -> Value
toJSON UpgradeInsight {Maybe Text
packageName :: UpgradeInsight -> Maybe Text
upgradeToVersion :: UpgradeInsight -> Maybe Text
packageName :: Maybe Text
upgradeToVersion :: Maybe Text
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes
          [ (Key
"packageName" Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Text
packageName,
            (Key
"upgradeToVersion" Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Text
upgradeToVersion
          ]
      )

-- | Additional details of a used Robo directive.
--
-- /See:/ 'newUsedRoboDirective' smart constructor.
newtype UsedRoboDirective = UsedRoboDirective
  { -- | The name of the resource that was used.
    UsedRoboDirective -> Maybe Text
resourceName :: (Core.Maybe Core.Text)
  }
  deriving (UsedRoboDirective -> UsedRoboDirective -> Bool
(UsedRoboDirective -> UsedRoboDirective -> Bool)
-> (UsedRoboDirective -> UsedRoboDirective -> Bool)
-> Eq UsedRoboDirective
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UsedRoboDirective -> UsedRoboDirective -> Bool
== :: UsedRoboDirective -> UsedRoboDirective -> Bool
$c/= :: UsedRoboDirective -> UsedRoboDirective -> Bool
/= :: UsedRoboDirective -> UsedRoboDirective -> Bool
Core.Eq, Int -> UsedRoboDirective -> ShowS
[UsedRoboDirective] -> ShowS
UsedRoboDirective -> String
(Int -> UsedRoboDirective -> ShowS)
-> (UsedRoboDirective -> String)
-> ([UsedRoboDirective] -> ShowS)
-> Show UsedRoboDirective
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UsedRoboDirective -> ShowS
showsPrec :: Int -> UsedRoboDirective -> ShowS
$cshow :: UsedRoboDirective -> String
show :: UsedRoboDirective -> String
$cshowList :: [UsedRoboDirective] -> ShowS
showList :: [UsedRoboDirective] -> ShowS
Core.Show, (forall x. UsedRoboDirective -> Rep UsedRoboDirective x)
-> (forall x. Rep UsedRoboDirective x -> UsedRoboDirective)
-> Generic UsedRoboDirective
forall x. Rep UsedRoboDirective x -> UsedRoboDirective
forall x. UsedRoboDirective -> Rep UsedRoboDirective x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UsedRoboDirective -> Rep UsedRoboDirective x
from :: forall x. UsedRoboDirective -> Rep UsedRoboDirective x
$cto :: forall x. Rep UsedRoboDirective x -> UsedRoboDirective
to :: forall x. Rep UsedRoboDirective x -> UsedRoboDirective
Core.Generic)

-- | Creates a value of 'UsedRoboDirective' with the minimum fields required to make a request.
newUsedRoboDirective ::
  UsedRoboDirective
newUsedRoboDirective :: UsedRoboDirective
newUsedRoboDirective =
  UsedRoboDirective {resourceName :: Maybe Text
resourceName = Maybe Text
forall a. Maybe a
Core.Nothing}

instance Core.FromJSON UsedRoboDirective where
  parseJSON :: Value -> Parser UsedRoboDirective
parseJSON =
    String
-> (Object -> Parser UsedRoboDirective)
-> Value
-> Parser UsedRoboDirective
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"UsedRoboDirective"
      (\Object
o -> Maybe Text -> UsedRoboDirective
UsedRoboDirective (Maybe Text -> UsedRoboDirective)
-> Parser (Maybe Text) -> Parser UsedRoboDirective
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"resourceName"))

instance Core.ToJSON UsedRoboDirective where
  toJSON :: UsedRoboDirective -> Value
toJSON UsedRoboDirective {Maybe Text
resourceName :: UsedRoboDirective -> Maybe Text
resourceName :: Maybe Text
..} =
    [Pair] -> Value
Core.object
      ([Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes [(Key
"resourceName" Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Text
resourceName])

-- | Additional details of a used Robo directive with an ignore action. Note: This is a different scenario than unused directive.
--
-- /See:/ 'newUsedRoboIgnoreDirective' smart constructor.
newtype UsedRoboIgnoreDirective = UsedRoboIgnoreDirective
  { -- | The name of the resource that was ignored.
    UsedRoboIgnoreDirective -> Maybe Text
resourceName :: (Core.Maybe Core.Text)
  }
  deriving (UsedRoboIgnoreDirective -> UsedRoboIgnoreDirective -> Bool
(UsedRoboIgnoreDirective -> UsedRoboIgnoreDirective -> Bool)
-> (UsedRoboIgnoreDirective -> UsedRoboIgnoreDirective -> Bool)
-> Eq UsedRoboIgnoreDirective
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UsedRoboIgnoreDirective -> UsedRoboIgnoreDirective -> Bool
== :: UsedRoboIgnoreDirective -> UsedRoboIgnoreDirective -> Bool
$c/= :: UsedRoboIgnoreDirective -> UsedRoboIgnoreDirective -> Bool
/= :: UsedRoboIgnoreDirective -> UsedRoboIgnoreDirective -> Bool
Core.Eq, Int -> UsedRoboIgnoreDirective -> ShowS
[UsedRoboIgnoreDirective] -> ShowS
UsedRoboIgnoreDirective -> String
(Int -> UsedRoboIgnoreDirective -> ShowS)
-> (UsedRoboIgnoreDirective -> String)
-> ([UsedRoboIgnoreDirective] -> ShowS)
-> Show UsedRoboIgnoreDirective
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UsedRoboIgnoreDirective -> ShowS
showsPrec :: Int -> UsedRoboIgnoreDirective -> ShowS
$cshow :: UsedRoboIgnoreDirective -> String
show :: UsedRoboIgnoreDirective -> String
$cshowList :: [UsedRoboIgnoreDirective] -> ShowS
showList :: [UsedRoboIgnoreDirective] -> ShowS
Core.Show, (forall x.
 UsedRoboIgnoreDirective -> Rep UsedRoboIgnoreDirective x)
-> (forall x.
    Rep UsedRoboIgnoreDirective x -> UsedRoboIgnoreDirective)
-> Generic UsedRoboIgnoreDirective
forall x. Rep UsedRoboIgnoreDirective x -> UsedRoboIgnoreDirective
forall x. UsedRoboIgnoreDirective -> Rep UsedRoboIgnoreDirective x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UsedRoboIgnoreDirective -> Rep UsedRoboIgnoreDirective x
from :: forall x. UsedRoboIgnoreDirective -> Rep UsedRoboIgnoreDirective x
$cto :: forall x. Rep UsedRoboIgnoreDirective x -> UsedRoboIgnoreDirective
to :: forall x. Rep UsedRoboIgnoreDirective x -> UsedRoboIgnoreDirective
Core.Generic)

-- | Creates a value of 'UsedRoboIgnoreDirective' with the minimum fields required to make a request.
newUsedRoboIgnoreDirective ::
  UsedRoboIgnoreDirective
newUsedRoboIgnoreDirective :: UsedRoboIgnoreDirective
newUsedRoboIgnoreDirective =
  UsedRoboIgnoreDirective {resourceName :: Maybe Text
resourceName = Maybe Text
forall a. Maybe a
Core.Nothing}

instance Core.FromJSON UsedRoboIgnoreDirective where
  parseJSON :: Value -> Parser UsedRoboIgnoreDirective
parseJSON =
    String
-> (Object -> Parser UsedRoboIgnoreDirective)
-> Value
-> Parser UsedRoboIgnoreDirective
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"UsedRoboIgnoreDirective"
      ( \Object
o ->
          Maybe Text -> UsedRoboIgnoreDirective
UsedRoboIgnoreDirective (Maybe Text -> UsedRoboIgnoreDirective)
-> Parser (Maybe Text) -> Parser UsedRoboIgnoreDirective
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Core..:? Key
"resourceName")
      )

instance Core.ToJSON UsedRoboIgnoreDirective where
  toJSON :: UsedRoboIgnoreDirective -> Value
toJSON UsedRoboIgnoreDirective {Maybe Text
resourceName :: UsedRoboIgnoreDirective -> Maybe Text
resourceName :: Maybe Text
..} =
    [Pair] -> Value
Core.object
      ([Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Core.catMaybes [(Key
"resourceName" Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Core.<$> Maybe Text
resourceName])