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

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

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

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Inspector2.Types.PackageSortBy
import Amazonka.Inspector2.Types.SortOrder
import Amazonka.Inspector2.Types.StringFilter
import qualified Amazonka.Prelude as Prelude

-- | The details that define an aggregation based on operating system package
-- type.
--
-- /See:/ 'newPackageAggregation' smart constructor.
data PackageAggregation = PackageAggregation'
  { -- | The names of packages to aggregate findings on.
    PackageAggregation -> Maybe (NonEmpty StringFilter)
packageNames :: Prelude.Maybe (Prelude.NonEmpty StringFilter),
    -- | The value to sort results by.
    PackageAggregation -> Maybe PackageSortBy
sortBy :: Prelude.Maybe PackageSortBy,
    -- | The order to sort results by.
    PackageAggregation -> Maybe SortOrder
sortOrder :: Prelude.Maybe SortOrder
  }
  deriving (PackageAggregation -> PackageAggregation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackageAggregation -> PackageAggregation -> Bool
$c/= :: PackageAggregation -> PackageAggregation -> Bool
== :: PackageAggregation -> PackageAggregation -> Bool
$c== :: PackageAggregation -> PackageAggregation -> Bool
Prelude.Eq, ReadPrec [PackageAggregation]
ReadPrec PackageAggregation
Int -> ReadS PackageAggregation
ReadS [PackageAggregation]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PackageAggregation]
$creadListPrec :: ReadPrec [PackageAggregation]
readPrec :: ReadPrec PackageAggregation
$creadPrec :: ReadPrec PackageAggregation
readList :: ReadS [PackageAggregation]
$creadList :: ReadS [PackageAggregation]
readsPrec :: Int -> ReadS PackageAggregation
$creadsPrec :: Int -> ReadS PackageAggregation
Prelude.Read, Int -> PackageAggregation -> ShowS
[PackageAggregation] -> ShowS
PackageAggregation -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PackageAggregation] -> ShowS
$cshowList :: [PackageAggregation] -> ShowS
show :: PackageAggregation -> String
$cshow :: PackageAggregation -> String
showsPrec :: Int -> PackageAggregation -> ShowS
$cshowsPrec :: Int -> PackageAggregation -> ShowS
Prelude.Show, forall x. Rep PackageAggregation x -> PackageAggregation
forall x. PackageAggregation -> Rep PackageAggregation x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PackageAggregation x -> PackageAggregation
$cfrom :: forall x. PackageAggregation -> Rep PackageAggregation x
Prelude.Generic)

-- |
-- Create a value of 'PackageAggregation' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'packageNames', 'packageAggregation_packageNames' - The names of packages to aggregate findings on.
--
-- 'sortBy', 'packageAggregation_sortBy' - The value to sort results by.
--
-- 'sortOrder', 'packageAggregation_sortOrder' - The order to sort results by.
newPackageAggregation ::
  PackageAggregation
newPackageAggregation :: PackageAggregation
newPackageAggregation =
  PackageAggregation'
    { $sel:packageNames:PackageAggregation' :: Maybe (NonEmpty StringFilter)
packageNames = forall a. Maybe a
Prelude.Nothing,
      $sel:sortBy:PackageAggregation' :: Maybe PackageSortBy
sortBy = forall a. Maybe a
Prelude.Nothing,
      $sel:sortOrder:PackageAggregation' :: Maybe SortOrder
sortOrder = forall a. Maybe a
Prelude.Nothing
    }

-- | The names of packages to aggregate findings on.
packageAggregation_packageNames :: Lens.Lens' PackageAggregation (Prelude.Maybe (Prelude.NonEmpty StringFilter))
packageAggregation_packageNames :: Lens' PackageAggregation (Maybe (NonEmpty StringFilter))
packageAggregation_packageNames = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PackageAggregation' {Maybe (NonEmpty StringFilter)
packageNames :: Maybe (NonEmpty StringFilter)
$sel:packageNames:PackageAggregation' :: PackageAggregation -> Maybe (NonEmpty StringFilter)
packageNames} -> Maybe (NonEmpty StringFilter)
packageNames) (\s :: PackageAggregation
s@PackageAggregation' {} Maybe (NonEmpty StringFilter)
a -> PackageAggregation
s {$sel:packageNames:PackageAggregation' :: Maybe (NonEmpty StringFilter)
packageNames = Maybe (NonEmpty StringFilter)
a} :: PackageAggregation) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The value to sort results by.
packageAggregation_sortBy :: Lens.Lens' PackageAggregation (Prelude.Maybe PackageSortBy)
packageAggregation_sortBy :: Lens' PackageAggregation (Maybe PackageSortBy)
packageAggregation_sortBy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PackageAggregation' {Maybe PackageSortBy
sortBy :: Maybe PackageSortBy
$sel:sortBy:PackageAggregation' :: PackageAggregation -> Maybe PackageSortBy
sortBy} -> Maybe PackageSortBy
sortBy) (\s :: PackageAggregation
s@PackageAggregation' {} Maybe PackageSortBy
a -> PackageAggregation
s {$sel:sortBy:PackageAggregation' :: Maybe PackageSortBy
sortBy = Maybe PackageSortBy
a} :: PackageAggregation)

-- | The order to sort results by.
packageAggregation_sortOrder :: Lens.Lens' PackageAggregation (Prelude.Maybe SortOrder)
packageAggregation_sortOrder :: Lens' PackageAggregation (Maybe SortOrder)
packageAggregation_sortOrder = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PackageAggregation' {Maybe SortOrder
sortOrder :: Maybe SortOrder
$sel:sortOrder:PackageAggregation' :: PackageAggregation -> Maybe SortOrder
sortOrder} -> Maybe SortOrder
sortOrder) (\s :: PackageAggregation
s@PackageAggregation' {} Maybe SortOrder
a -> PackageAggregation
s {$sel:sortOrder:PackageAggregation' :: Maybe SortOrder
sortOrder = Maybe SortOrder
a} :: PackageAggregation)

instance Prelude.Hashable PackageAggregation where
  hashWithSalt :: Int -> PackageAggregation -> Int
hashWithSalt Int
_salt PackageAggregation' {Maybe (NonEmpty StringFilter)
Maybe PackageSortBy
Maybe SortOrder
sortOrder :: Maybe SortOrder
sortBy :: Maybe PackageSortBy
packageNames :: Maybe (NonEmpty StringFilter)
$sel:sortOrder:PackageAggregation' :: PackageAggregation -> Maybe SortOrder
$sel:sortBy:PackageAggregation' :: PackageAggregation -> Maybe PackageSortBy
$sel:packageNames:PackageAggregation' :: PackageAggregation -> Maybe (NonEmpty StringFilter)
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty StringFilter)
packageNames
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe PackageSortBy
sortBy
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SortOrder
sortOrder

instance Prelude.NFData PackageAggregation where
  rnf :: PackageAggregation -> ()
rnf PackageAggregation' {Maybe (NonEmpty StringFilter)
Maybe PackageSortBy
Maybe SortOrder
sortOrder :: Maybe SortOrder
sortBy :: Maybe PackageSortBy
packageNames :: Maybe (NonEmpty StringFilter)
$sel:sortOrder:PackageAggregation' :: PackageAggregation -> Maybe SortOrder
$sel:sortBy:PackageAggregation' :: PackageAggregation -> Maybe PackageSortBy
$sel:packageNames:PackageAggregation' :: PackageAggregation -> Maybe (NonEmpty StringFilter)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty StringFilter)
packageNames
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe PackageSortBy
sortBy
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SortOrder
sortOrder

instance Data.ToJSON PackageAggregation where
  toJSON :: PackageAggregation -> Value
toJSON PackageAggregation' {Maybe (NonEmpty StringFilter)
Maybe PackageSortBy
Maybe SortOrder
sortOrder :: Maybe SortOrder
sortBy :: Maybe PackageSortBy
packageNames :: Maybe (NonEmpty StringFilter)
$sel:sortOrder:PackageAggregation' :: PackageAggregation -> Maybe SortOrder
$sel:sortBy:PackageAggregation' :: PackageAggregation -> Maybe PackageSortBy
$sel:packageNames:PackageAggregation' :: PackageAggregation -> Maybe (NonEmpty StringFilter)
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"packageNames" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (NonEmpty StringFilter)
packageNames,
            (Key
"sortBy" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe PackageSortBy
sortBy,
            (Key
"sortOrder" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe SortOrder
sortOrder
          ]
      )