{-# 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.
    stackTrace :: (Core.Maybe StackTrace)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON ANR where
  parseJSON =
    Core.withObject
      "ANR"
      (\o -> ANR Core.<$> (o Core..:? "stackTrace"))

instance Core.ToJSON ANR where
  toJSON ANR {..} =
    Core.object
      (Core.catMaybes [("stackTrace" Core..=) Core.<$> stackTrace])

-- | A suggestion to use deep links for a Robo run.
--
-- /See:/ 'newAvailableDeepLinks' smart constructor.
data AvailableDeepLinks = AvailableDeepLinks
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON AvailableDeepLinks where
  parseJSON =
    Core.withObject
      "AvailableDeepLinks"
      (\o -> Core.pure AvailableDeepLinks)

instance Core.ToJSON AvailableDeepLinks where
  toJSON = Core.const 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
    screenId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON BlankScreen where
  parseJSON =
    Core.withObject
      "BlankScreen"
      (\o -> BlankScreen Core.<$> (o Core..:? "screenId"))

instance Core.ToJSON BlankScreen where
  toJSON BlankScreen {..} =
    Core.object
      (Core.catMaybes [("screenId" Core..=) Core.<$> 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.
    crashPackage :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON CrashDialogError where
  parseJSON =
    Core.withObject
      "CrashDialogError"
      (\o -> CrashDialogError Core.<$> (o Core..:? "crashPackage"))

instance Core.ToJSON CrashDialogError where
  toJSON CrashDialogError {..} =
    Core.object
      (Core.catMaybes [("crashPackage" Core..=) Core.<$> crashPackage])

-- | Additional details about encountered login screens.
--
-- /See:/ 'newEncounteredLoginScreen' smart constructor.
data EncounteredLoginScreen = EncounteredLoginScreen
  { -- | Number of encountered distinct login screens.
    distinctScreens :: (Core.Maybe Core.Int32),
    -- | Subset of login screens.
    screenIds :: (Core.Maybe [Core.Text])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON EncounteredLoginScreen where
  parseJSON =
    Core.withObject
      "EncounteredLoginScreen"
      ( \o ->
          EncounteredLoginScreen
            Core.<$> (o Core..:? "distinctScreens")
            Core.<*> (o Core..:? "screenIds")
      )

instance Core.ToJSON EncounteredLoginScreen where
  toJSON EncounteredLoginScreen {..} =
    Core.object
      ( Core.catMaybes
          [ ("distinctScreens" Core..=) Core.<$> distinctScreens,
            ("screenIds" Core..=) Core.<$> 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.
    distinctScreens :: (Core.Maybe Core.Int32),
    -- | Subset of screens which contain non Android UI widgets.
    screenIds :: (Core.Maybe [Core.Text])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON EncounteredNonAndroidUiWidgetScreen where
  parseJSON =
    Core.withObject
      "EncounteredNonAndroidUiWidgetScreen"
      ( \o ->
          EncounteredNonAndroidUiWidgetScreen
            Core.<$> (o Core..:? "distinctScreens")
            Core.<*> (o Core..:? "screenIds")
      )

instance Core.ToJSON EncounteredNonAndroidUiWidgetScreen where
  toJSON EncounteredNonAndroidUiWidgetScreen {..} =
    Core.object
      ( Core.catMaybes
          [ ("distinctScreens" Core..=) Core.<$> distinctScreens,
            ("screenIds" Core..=) Core.<$> screenIds
          ]
      )

-- | Failed to install the APK.
--
-- /See:/ 'newFailedToInstall' smart constructor.
data FailedToInstall = FailedToInstall
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON FailedToInstall where
  parseJSON =
    Core.withObject
      "FailedToInstall"
      (\o -> Core.pure FailedToInstall)

instance Core.ToJSON FailedToInstall where
  toJSON = Core.const Core.emptyObject

-- | Additional details for a fatal exception.
--
-- /See:/ 'newFatalException' smart constructor.
newtype FatalException = FatalException
  { -- | The stack trace of the fatal exception. Optional.
    stackTrace :: (Core.Maybe StackTrace)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON FatalException where
  parseJSON =
    Core.withObject
      "FatalException"
      (\o -> FatalException Core.<$> (o Core..:? "stackTrace"))

instance Core.ToJSON FatalException where
  toJSON FatalException {..} =
    Core.object
      (Core.catMaybes [("stackTrace" Core..=) Core.<$> 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.
    inAppPurchasesFlowsExplored :: (Core.Maybe Core.Int32),
    -- | The total number of in-app purchases flows started.
    inAppPurchasesFlowsStarted :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON InAppPurchasesFound where
  parseJSON =
    Core.withObject
      "InAppPurchasesFound"
      ( \o ->
          InAppPurchasesFound
            Core.<$> (o Core..:? "inAppPurchasesFlowsExplored")
            Core.<*> (o Core..:? "inAppPurchasesFlowsStarted")
      )

instance Core.ToJSON InAppPurchasesFound where
  toJSON InAppPurchasesFound {..} =
    Core.object
      ( Core.catMaybes
          [ ("inAppPurchasesFlowsExplored" Core..=)
              Core.<$> inAppPurchasesFlowsExplored,
            ("inAppPurchasesFlowsStarted" Core..=)
              Core.<$> inAppPurchasesFlowsStarted
          ]
      )

-- | A warning that Robo did not crawl potentially important parts of the app.
--
-- /See:/ 'newInsufficientCoverage' smart constructor.
data InsufficientCoverage = InsufficientCoverage
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON InsufficientCoverage where
  parseJSON =
    Core.withObject
      "InsufficientCoverage"
      (\o -> Core.pure InsufficientCoverage)

instance Core.ToJSON InsufficientCoverage where
  toJSON = Core.const Core.emptyObject

-- | Additional details for an iOS app crash.
--
-- /See:/ 'newIosAppCrashed' smart constructor.
newtype IosAppCrashed = IosAppCrashed
  { -- | The stack trace, if one is available. Optional.
    stackTrace :: (Core.Maybe StackTrace)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON IosAppCrashed where
  parseJSON =
    Core.withObject
      "IosAppCrashed"
      (\o -> IosAppCrashed Core.<$> (o Core..:? "stackTrace"))

instance Core.ToJSON IosAppCrashed where
  toJSON IosAppCrashed {..} =
    Core.object
      (Core.catMaybes [("stackTrace" Core..=) Core.<$> stackTrace])

-- | Failed to find the launcher activity of an app.
--
-- /See:/ 'newLauncherActivityNotFound' smart constructor.
data LauncherActivityNotFound = LauncherActivityNotFound
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON LauncherActivityNotFound where
  parseJSON =
    Core.withObject
      "LauncherActivityNotFound"
      (\o -> Core.pure LauncherActivityNotFound)

instance Core.ToJSON LauncherActivityNotFound where
  toJSON = Core.const Core.emptyObject

-- | Additional details for a native crash.
--
-- /See:/ 'newNativeCrash' smart constructor.
newtype NativeCrash = NativeCrash
  { -- | The stack trace of the native crash. Optional.
    stackTrace :: (Core.Maybe StackTrace)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON NativeCrash where
  parseJSON =
    Core.withObject
      "NativeCrash"
      (\o -> NativeCrash Core.<$> (o Core..:? "stackTrace"))

instance Core.ToJSON NativeCrash where
  toJSON NativeCrash {..} =
    Core.object
      (Core.catMaybes [("stackTrace" Core..=) Core.<$> 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
    apiSignature :: (Core.Maybe Core.Text),
    -- | Example stack traces of this API being called.
    exampleStackTraces :: (Core.Maybe [Core.Text]),
    -- | Optional debugging insights for non-SDK API violations.
    insights :: (Core.Maybe [NonSdkApiInsight]),
    -- | The total number of times this API was observed to have been called.
    invocationCount :: (Core.Maybe Core.Int32),
    -- | Which list this API appears on
    list :: (Core.Maybe NonSdkApi_List)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'NonSdkApi' with the minimum fields required to make a request.
newNonSdkApi ::
  NonSdkApi
newNonSdkApi =
  NonSdkApi
    { apiSignature = Core.Nothing,
      exampleStackTraces = Core.Nothing,
      insights = Core.Nothing,
      invocationCount = Core.Nothing,
      list = Core.Nothing
    }

instance Core.FromJSON NonSdkApi where
  parseJSON =
    Core.withObject
      "NonSdkApi"
      ( \o ->
          NonSdkApi
            Core.<$> (o Core..:? "apiSignature")
            Core.<*> (o Core..:? "exampleStackTraces")
            Core.<*> (o Core..:? "insights")
            Core.<*> (o Core..:? "invocationCount")
            Core.<*> (o Core..:? "list")
      )

instance Core.ToJSON NonSdkApi where
  toJSON NonSdkApi {..} =
    Core.object
      ( Core.catMaybes
          [ ("apiSignature" Core..=) Core.<$> apiSignature,
            ("exampleStackTraces" Core..=) Core.<$> exampleStackTraces,
            ("insights" Core..=) Core.<$> insights,
            ("invocationCount" Core..=) Core.<$> invocationCount,
            ("list" Core..=) Core.<$> 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).
    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)
    matcherId :: (Core.Maybe Core.Text),
    -- | An insight indicating that the hidden API usage originates from a Google-provided library.
    pendingGoogleUpdateInsight :: (Core.Maybe PendingGoogleUpdateInsight),
    -- | An insight indicating that the hidden API usage originates from the use of a library that needs to be upgraded.
    upgradeInsight :: (Core.Maybe UpgradeInsight)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON NonSdkApiInsight where
  parseJSON =
    Core.withObject
      "NonSdkApiInsight"
      ( \o ->
          NonSdkApiInsight
            Core.<$> (o Core..:? "exampleTraceMessages")
            Core.<*> (o Core..:? "matcherId")
            Core.<*> (o Core..:? "pendingGoogleUpdateInsight")
            Core.<*> (o Core..:? "upgradeInsight")
      )

instance Core.ToJSON NonSdkApiInsight where
  toJSON NonSdkApiInsight {..} =
    Core.object
      ( Core.catMaybes
          [ ("exampleTraceMessages" Core..=) Core.<$> exampleTraceMessages,
            ("matcherId" Core..=) Core.<$> matcherId,
            ("pendingGoogleUpdateInsight" Core..=)
              Core.<$> pendingGoogleUpdateInsight,
            ("upgradeInsight" Core..=) Core.<$> 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.
    apiSignatures :: (Core.Maybe [Core.Text]),
    -- | Total number of unique hidden API\'s accessed.
    uniqueApis :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON NonSdkApiUsageViolation where
  parseJSON =
    Core.withObject
      "NonSdkApiUsageViolation"
      ( \o ->
          NonSdkApiUsageViolation
            Core.<$> (o Core..:? "apiSignatures")
            Core.<*> (o Core..:? "uniqueApis")
      )

instance Core.ToJSON NonSdkApiUsageViolation where
  toJSON NonSdkApiUsageViolation {..} =
    Core.object
      ( Core.catMaybes
          [ ("apiSignatures" Core..=) Core.<$> apiSignatures,
            ("uniqueApis" Core..=) Core.<$> 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.
    exampleApis :: (Core.Maybe [NonSdkApi]),
    -- | Minimum API level required for the application to run.
    minSdkVersion :: (Core.Maybe Core.Int32),
    -- | Specifies the API Level on which the application is designed to run.
    targetSdkVersion :: (Core.Maybe Core.Int32),
    -- | Total number of unique Non-SDK API\'s accessed.
    uniqueApis :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON NonSdkApiUsageViolationReport where
  parseJSON =
    Core.withObject
      "NonSdkApiUsageViolationReport"
      ( \o ->
          NonSdkApiUsageViolationReport
            Core.<$> (o Core..:? "exampleApis")
            Core.<*> (o Core..:? "minSdkVersion")
            Core.<*> (o Core..:? "targetSdkVersion")
            Core.<*> (o Core..:? "uniqueApis")
      )

instance Core.ToJSON NonSdkApiUsageViolationReport where
  toJSON NonSdkApiUsageViolationReport {..} =
    Core.object
      ( Core.catMaybes
          [ ("exampleApis" Core..=) Core.<$> exampleApis,
            ("minSdkVersion" Core..=) Core.<$> minSdkVersion,
            ("targetSdkVersion" Core..=) Core.<$> targetSdkVersion,
            ("uniqueApis" Core..=) Core.<$> 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
    resourceName :: (Core.Maybe [Core.Text]),
    -- | The screen id of the elements
    screenId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON OverlappingUIElements where
  parseJSON =
    Core.withObject
      "OverlappingUIElements"
      ( \o ->
          OverlappingUIElements
            Core.<$> (o Core..:? "resourceName")
            Core.<*> (o Core..:? "screenId")
      )

instance Core.ToJSON OverlappingUIElements where
  toJSON OverlappingUIElements {..} =
    Core.object
      ( Core.catMaybes
          [ ("resourceName" Core..=) Core.<$> resourceName,
            ("screenId" Core..=) Core.<$> 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.
    nameOfGoogleLibrary :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON PendingGoogleUpdateInsight where
  parseJSON =
    Core.withObject
      "PendingGoogleUpdateInsight"
      ( \o ->
          PendingGoogleUpdateInsight
            Core.<$> (o Core..:? "nameOfGoogleLibrary")
      )

instance Core.ToJSON PendingGoogleUpdateInsight where
  toJSON PendingGoogleUpdateInsight {..} =
    Core.object
      ( Core.catMaybes
          [("nameOfGoogleLibrary" Core..=) Core.<$> nameOfGoogleLibrary]
      )

-- | A notification that Robo signed in with Google.
--
-- /See:/ 'newPerformedGoogleLogin' smart constructor.
data PerformedGoogleLogin = PerformedGoogleLogin
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON PerformedGoogleLogin where
  parseJSON =
    Core.withObject
      "PerformedGoogleLogin"
      (\o -> Core.pure PerformedGoogleLogin)

instance Core.ToJSON PerformedGoogleLogin where
  toJSON = Core.const 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.
    totalActions :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON PerformedMonkeyActions where
  parseJSON =
    Core.withObject
      "PerformedMonkeyActions"
      ( \o ->
          PerformedMonkeyActions Core.<$> (o Core..:? "totalActions")
      )

instance Core.ToJSON PerformedMonkeyActions where
  toJSON PerformedMonkeyActions {..} =
    Core.object
      (Core.catMaybes [("totalActions" Core..=) Core.<$> totalActions])

-- | Execution stats for a user-provided Robo script.
--
-- /See:/ 'newRoboScriptExecution' smart constructor.
data RoboScriptExecution = RoboScriptExecution
  { -- | The number of Robo script actions executed successfully.
    successfulActions :: (Core.Maybe Core.Int32),
    -- | The total number of actions in the Robo script.
    totalActions :: (Core.Maybe Core.Int32)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON RoboScriptExecution where
  parseJSON =
    Core.withObject
      "RoboScriptExecution"
      ( \o ->
          RoboScriptExecution
            Core.<$> (o Core..:? "successfulActions")
            Core.<*> (o Core..:? "totalActions")
      )

instance Core.ToJSON RoboScriptExecution where
  toJSON RoboScriptExecution {..} =
    Core.object
      ( Core.catMaybes
          [ ("successfulActions" Core..=) Core.<$> successfulActions,
            ("totalActions" Core..=) Core.<$> totalActions
          ]
      )

-- | A stacktrace.
--
-- /See:/ 'newStackTrace' smart constructor.
newtype StackTrace = StackTrace
  { -- | The stack trace message.
    --
    -- Required
    exception :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON StackTrace where
  parseJSON =
    Core.withObject
      "StackTrace"
      (\o -> StackTrace Core.<$> (o Core..:? "exception"))

instance Core.ToJSON StackTrace where
  toJSON StackTrace {..} =
    Core.object
      (Core.catMaybes [("exception" Core..=) Core.<$> exception])

-- | User provided intent failed to resolve to an activity.
--
-- /See:/ 'newStartActivityNotFound' smart constructor.
data StartActivityNotFound = StartActivityNotFound
  { action :: (Core.Maybe Core.Text),
    uri :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON StartActivityNotFound where
  parseJSON =
    Core.withObject
      "StartActivityNotFound"
      ( \o ->
          StartActivityNotFound
            Core.<$> (o Core..:? "action")
            Core.<*> (o Core..:? "uri")
      )

instance Core.ToJSON StartActivityNotFound where
  toJSON StartActivityNotFound {..} =
    Core.object
      ( Core.catMaybes
          [("action" Core..=) Core.<$> action, ("uri" Core..=) Core.<$> 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
    depth :: (Core.Maybe Core.Int32),
    -- | The screen id of the element
    screenId :: (Core.Maybe Core.Text),
    -- | The screen state id of the element
    screenStateId :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON UIElementTooDeep where
  parseJSON =
    Core.withObject
      "UIElementTooDeep"
      ( \o ->
          UIElementTooDeep
            Core.<$> (o Core..:? "depth")
            Core.<*> (o Core..:? "screenId")
            Core.<*> (o Core..:? "screenStateId")
      )

instance Core.ToJSON UIElementTooDeep where
  toJSON UIElementTooDeep {..} =
    Core.object
      ( Core.catMaybes
          [ ("depth" Core..=) Core.<$> depth,
            ("screenId" Core..=) Core.<$> screenId,
            ("screenStateId" Core..=) Core.<$> screenStateId
          ]
      )

-- | Default unspecified warning.
--
-- /See:/ 'newUnspecifiedWarning' smart constructor.
data UnspecifiedWarning = UnspecifiedWarning
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON UnspecifiedWarning where
  parseJSON =
    Core.withObject
      "UnspecifiedWarning"
      (\o -> Core.pure UnspecifiedWarning)

instance Core.ToJSON UnspecifiedWarning where
  toJSON = Core.const Core.emptyObject

-- | Additional details of an unused robodirective.
--
-- /See:/ 'newUnusedRoboDirective' smart constructor.
newtype UnusedRoboDirective = UnusedRoboDirective
  { -- | The name of the resource that was unused.
    resourceName :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON UnusedRoboDirective where
  parseJSON =
    Core.withObject
      "UnusedRoboDirective"
      (\o -> UnusedRoboDirective Core.<$> (o Core..:? "resourceName"))

instance Core.ToJSON UnusedRoboDirective where
  toJSON UnusedRoboDirective {..} =
    Core.object
      (Core.catMaybes [("resourceName" Core..=) Core.<$> 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.
    packageName :: (Core.Maybe Core.Text),
    -- | The suggested version to upgrade to. Optional: In case we are not sure which version solves this problem
    upgradeToVersion :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON UpgradeInsight where
  parseJSON =
    Core.withObject
      "UpgradeInsight"
      ( \o ->
          UpgradeInsight
            Core.<$> (o Core..:? "packageName")
            Core.<*> (o Core..:? "upgradeToVersion")
      )

instance Core.ToJSON UpgradeInsight where
  toJSON UpgradeInsight {..} =
    Core.object
      ( Core.catMaybes
          [ ("packageName" Core..=) Core.<$> packageName,
            ("upgradeToVersion" Core..=) Core.<$> upgradeToVersion
          ]
      )

-- | Additional details of a used Robo directive.
--
-- /See:/ 'newUsedRoboDirective' smart constructor.
newtype UsedRoboDirective = UsedRoboDirective
  { -- | The name of the resource that was used.
    resourceName :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON UsedRoboDirective where
  parseJSON =
    Core.withObject
      "UsedRoboDirective"
      (\o -> UsedRoboDirective Core.<$> (o Core..:? "resourceName"))

instance Core.ToJSON UsedRoboDirective where
  toJSON UsedRoboDirective {..} =
    Core.object
      (Core.catMaybes [("resourceName" Core..=) Core.<$> 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.
    resourceName :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

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

instance Core.FromJSON UsedRoboIgnoreDirective where
  parseJSON =
    Core.withObject
      "UsedRoboIgnoreDirective"
      ( \o ->
          UsedRoboIgnoreDirective Core.<$> (o Core..:? "resourceName")
      )

instance Core.ToJSON UsedRoboIgnoreDirective where
  toJSON UsedRoboIgnoreDirective {..} =
    Core.object
      (Core.catMaybes [("resourceName" Core..=) Core.<$> resourceName])