{-# 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.ElasticSearch.Types.DomainPackageDetails
-- 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.ElasticSearch.Types.DomainPackageDetails where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.ElasticSearch.Types.DomainPackageStatus
import Amazonka.ElasticSearch.Types.ErrorDetails
import Amazonka.ElasticSearch.Types.PackageType
import qualified Amazonka.Prelude as Prelude

-- | Information on a package that is associated with a domain.
--
-- /See:/ 'newDomainPackageDetails' smart constructor.
data DomainPackageDetails = DomainPackageDetails'
  { -- | Name of the domain you\'ve associated a package with.
    DomainPackageDetails -> Maybe Text
domainName :: Prelude.Maybe Prelude.Text,
    -- | State of the association. Values are
    -- ASSOCIATING\/ASSOCIATION_FAILED\/ACTIVE\/DISSOCIATING\/DISSOCIATION_FAILED.
    DomainPackageDetails -> Maybe DomainPackageStatus
domainPackageStatus :: Prelude.Maybe DomainPackageStatus,
    -- | Additional information if the package is in an error state. Null
    -- otherwise.
    DomainPackageDetails -> Maybe ErrorDetails
errorDetails :: Prelude.Maybe ErrorDetails,
    -- | Timestamp of the most-recent update to the association status.
    DomainPackageDetails -> Maybe POSIX
lastUpdated :: Prelude.Maybe Data.POSIX,
    -- | Internal ID of the package.
    DomainPackageDetails -> Maybe Text
packageID :: Prelude.Maybe Prelude.Text,
    -- | User specified name of the package.
    DomainPackageDetails -> Maybe Text
packageName :: Prelude.Maybe Prelude.Text,
    -- | Currently supports only TXT-DICTIONARY.
    DomainPackageDetails -> Maybe PackageType
packageType :: Prelude.Maybe PackageType,
    DomainPackageDetails -> Maybe Text
packageVersion :: Prelude.Maybe Prelude.Text,
    -- | The relative path on Amazon ES nodes, which can be used as synonym_path
    -- when the package is synonym file.
    DomainPackageDetails -> Maybe Text
referencePath :: Prelude.Maybe Prelude.Text
  }
  deriving (DomainPackageDetails -> DomainPackageDetails -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DomainPackageDetails -> DomainPackageDetails -> Bool
$c/= :: DomainPackageDetails -> DomainPackageDetails -> Bool
== :: DomainPackageDetails -> DomainPackageDetails -> Bool
$c== :: DomainPackageDetails -> DomainPackageDetails -> Bool
Prelude.Eq, ReadPrec [DomainPackageDetails]
ReadPrec DomainPackageDetails
Int -> ReadS DomainPackageDetails
ReadS [DomainPackageDetails]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DomainPackageDetails]
$creadListPrec :: ReadPrec [DomainPackageDetails]
readPrec :: ReadPrec DomainPackageDetails
$creadPrec :: ReadPrec DomainPackageDetails
readList :: ReadS [DomainPackageDetails]
$creadList :: ReadS [DomainPackageDetails]
readsPrec :: Int -> ReadS DomainPackageDetails
$creadsPrec :: Int -> ReadS DomainPackageDetails
Prelude.Read, Int -> DomainPackageDetails -> ShowS
[DomainPackageDetails] -> ShowS
DomainPackageDetails -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DomainPackageDetails] -> ShowS
$cshowList :: [DomainPackageDetails] -> ShowS
show :: DomainPackageDetails -> String
$cshow :: DomainPackageDetails -> String
showsPrec :: Int -> DomainPackageDetails -> ShowS
$cshowsPrec :: Int -> DomainPackageDetails -> ShowS
Prelude.Show, forall x. Rep DomainPackageDetails x -> DomainPackageDetails
forall x. DomainPackageDetails -> Rep DomainPackageDetails x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DomainPackageDetails x -> DomainPackageDetails
$cfrom :: forall x. DomainPackageDetails -> Rep DomainPackageDetails x
Prelude.Generic)

-- |
-- Create a value of 'DomainPackageDetails' 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:
--
-- 'domainName', 'domainPackageDetails_domainName' - Name of the domain you\'ve associated a package with.
--
-- 'domainPackageStatus', 'domainPackageDetails_domainPackageStatus' - State of the association. Values are
-- ASSOCIATING\/ASSOCIATION_FAILED\/ACTIVE\/DISSOCIATING\/DISSOCIATION_FAILED.
--
-- 'errorDetails', 'domainPackageDetails_errorDetails' - Additional information if the package is in an error state. Null
-- otherwise.
--
-- 'lastUpdated', 'domainPackageDetails_lastUpdated' - Timestamp of the most-recent update to the association status.
--
-- 'packageID', 'domainPackageDetails_packageID' - Internal ID of the package.
--
-- 'packageName', 'domainPackageDetails_packageName' - User specified name of the package.
--
-- 'packageType', 'domainPackageDetails_packageType' - Currently supports only TXT-DICTIONARY.
--
-- 'packageVersion', 'domainPackageDetails_packageVersion' - Undocumented member.
--
-- 'referencePath', 'domainPackageDetails_referencePath' - The relative path on Amazon ES nodes, which can be used as synonym_path
-- when the package is synonym file.
newDomainPackageDetails ::
  DomainPackageDetails
newDomainPackageDetails :: DomainPackageDetails
newDomainPackageDetails =
  DomainPackageDetails'
    { $sel:domainName:DomainPackageDetails' :: Maybe Text
domainName = forall a. Maybe a
Prelude.Nothing,
      $sel:domainPackageStatus:DomainPackageDetails' :: Maybe DomainPackageStatus
domainPackageStatus = forall a. Maybe a
Prelude.Nothing,
      $sel:errorDetails:DomainPackageDetails' :: Maybe ErrorDetails
errorDetails = forall a. Maybe a
Prelude.Nothing,
      $sel:lastUpdated:DomainPackageDetails' :: Maybe POSIX
lastUpdated = forall a. Maybe a
Prelude.Nothing,
      $sel:packageID:DomainPackageDetails' :: Maybe Text
packageID = forall a. Maybe a
Prelude.Nothing,
      $sel:packageName:DomainPackageDetails' :: Maybe Text
packageName = forall a. Maybe a
Prelude.Nothing,
      $sel:packageType:DomainPackageDetails' :: Maybe PackageType
packageType = forall a. Maybe a
Prelude.Nothing,
      $sel:packageVersion:DomainPackageDetails' :: Maybe Text
packageVersion = forall a. Maybe a
Prelude.Nothing,
      $sel:referencePath:DomainPackageDetails' :: Maybe Text
referencePath = forall a. Maybe a
Prelude.Nothing
    }

-- | Name of the domain you\'ve associated a package with.
domainPackageDetails_domainName :: Lens.Lens' DomainPackageDetails (Prelude.Maybe Prelude.Text)
domainPackageDetails_domainName :: Lens' DomainPackageDetails (Maybe Text)
domainPackageDetails_domainName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainPackageDetails' {Maybe Text
domainName :: Maybe Text
$sel:domainName:DomainPackageDetails' :: DomainPackageDetails -> Maybe Text
domainName} -> Maybe Text
domainName) (\s :: DomainPackageDetails
s@DomainPackageDetails' {} Maybe Text
a -> DomainPackageDetails
s {$sel:domainName:DomainPackageDetails' :: Maybe Text
domainName = Maybe Text
a} :: DomainPackageDetails)

-- | State of the association. Values are
-- ASSOCIATING\/ASSOCIATION_FAILED\/ACTIVE\/DISSOCIATING\/DISSOCIATION_FAILED.
domainPackageDetails_domainPackageStatus :: Lens.Lens' DomainPackageDetails (Prelude.Maybe DomainPackageStatus)
domainPackageDetails_domainPackageStatus :: Lens' DomainPackageDetails (Maybe DomainPackageStatus)
domainPackageDetails_domainPackageStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainPackageDetails' {Maybe DomainPackageStatus
domainPackageStatus :: Maybe DomainPackageStatus
$sel:domainPackageStatus:DomainPackageDetails' :: DomainPackageDetails -> Maybe DomainPackageStatus
domainPackageStatus} -> Maybe DomainPackageStatus
domainPackageStatus) (\s :: DomainPackageDetails
s@DomainPackageDetails' {} Maybe DomainPackageStatus
a -> DomainPackageDetails
s {$sel:domainPackageStatus:DomainPackageDetails' :: Maybe DomainPackageStatus
domainPackageStatus = Maybe DomainPackageStatus
a} :: DomainPackageDetails)

-- | Additional information if the package is in an error state. Null
-- otherwise.
domainPackageDetails_errorDetails :: Lens.Lens' DomainPackageDetails (Prelude.Maybe ErrorDetails)
domainPackageDetails_errorDetails :: Lens' DomainPackageDetails (Maybe ErrorDetails)
domainPackageDetails_errorDetails = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainPackageDetails' {Maybe ErrorDetails
errorDetails :: Maybe ErrorDetails
$sel:errorDetails:DomainPackageDetails' :: DomainPackageDetails -> Maybe ErrorDetails
errorDetails} -> Maybe ErrorDetails
errorDetails) (\s :: DomainPackageDetails
s@DomainPackageDetails' {} Maybe ErrorDetails
a -> DomainPackageDetails
s {$sel:errorDetails:DomainPackageDetails' :: Maybe ErrorDetails
errorDetails = Maybe ErrorDetails
a} :: DomainPackageDetails)

-- | Timestamp of the most-recent update to the association status.
domainPackageDetails_lastUpdated :: Lens.Lens' DomainPackageDetails (Prelude.Maybe Prelude.UTCTime)
domainPackageDetails_lastUpdated :: Lens' DomainPackageDetails (Maybe UTCTime)
domainPackageDetails_lastUpdated = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainPackageDetails' {Maybe POSIX
lastUpdated :: Maybe POSIX
$sel:lastUpdated:DomainPackageDetails' :: DomainPackageDetails -> Maybe POSIX
lastUpdated} -> Maybe POSIX
lastUpdated) (\s :: DomainPackageDetails
s@DomainPackageDetails' {} Maybe POSIX
a -> DomainPackageDetails
s {$sel:lastUpdated:DomainPackageDetails' :: Maybe POSIX
lastUpdated = Maybe POSIX
a} :: DomainPackageDetails) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | Internal ID of the package.
domainPackageDetails_packageID :: Lens.Lens' DomainPackageDetails (Prelude.Maybe Prelude.Text)
domainPackageDetails_packageID :: Lens' DomainPackageDetails (Maybe Text)
domainPackageDetails_packageID = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainPackageDetails' {Maybe Text
packageID :: Maybe Text
$sel:packageID:DomainPackageDetails' :: DomainPackageDetails -> Maybe Text
packageID} -> Maybe Text
packageID) (\s :: DomainPackageDetails
s@DomainPackageDetails' {} Maybe Text
a -> DomainPackageDetails
s {$sel:packageID:DomainPackageDetails' :: Maybe Text
packageID = Maybe Text
a} :: DomainPackageDetails)

-- | User specified name of the package.
domainPackageDetails_packageName :: Lens.Lens' DomainPackageDetails (Prelude.Maybe Prelude.Text)
domainPackageDetails_packageName :: Lens' DomainPackageDetails (Maybe Text)
domainPackageDetails_packageName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainPackageDetails' {Maybe Text
packageName :: Maybe Text
$sel:packageName:DomainPackageDetails' :: DomainPackageDetails -> Maybe Text
packageName} -> Maybe Text
packageName) (\s :: DomainPackageDetails
s@DomainPackageDetails' {} Maybe Text
a -> DomainPackageDetails
s {$sel:packageName:DomainPackageDetails' :: Maybe Text
packageName = Maybe Text
a} :: DomainPackageDetails)

-- | Currently supports only TXT-DICTIONARY.
domainPackageDetails_packageType :: Lens.Lens' DomainPackageDetails (Prelude.Maybe PackageType)
domainPackageDetails_packageType :: Lens' DomainPackageDetails (Maybe PackageType)
domainPackageDetails_packageType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainPackageDetails' {Maybe PackageType
packageType :: Maybe PackageType
$sel:packageType:DomainPackageDetails' :: DomainPackageDetails -> Maybe PackageType
packageType} -> Maybe PackageType
packageType) (\s :: DomainPackageDetails
s@DomainPackageDetails' {} Maybe PackageType
a -> DomainPackageDetails
s {$sel:packageType:DomainPackageDetails' :: Maybe PackageType
packageType = Maybe PackageType
a} :: DomainPackageDetails)

-- | Undocumented member.
domainPackageDetails_packageVersion :: Lens.Lens' DomainPackageDetails (Prelude.Maybe Prelude.Text)
domainPackageDetails_packageVersion :: Lens' DomainPackageDetails (Maybe Text)
domainPackageDetails_packageVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainPackageDetails' {Maybe Text
packageVersion :: Maybe Text
$sel:packageVersion:DomainPackageDetails' :: DomainPackageDetails -> Maybe Text
packageVersion} -> Maybe Text
packageVersion) (\s :: DomainPackageDetails
s@DomainPackageDetails' {} Maybe Text
a -> DomainPackageDetails
s {$sel:packageVersion:DomainPackageDetails' :: Maybe Text
packageVersion = Maybe Text
a} :: DomainPackageDetails)

-- | The relative path on Amazon ES nodes, which can be used as synonym_path
-- when the package is synonym file.
domainPackageDetails_referencePath :: Lens.Lens' DomainPackageDetails (Prelude.Maybe Prelude.Text)
domainPackageDetails_referencePath :: Lens' DomainPackageDetails (Maybe Text)
domainPackageDetails_referencePath = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainPackageDetails' {Maybe Text
referencePath :: Maybe Text
$sel:referencePath:DomainPackageDetails' :: DomainPackageDetails -> Maybe Text
referencePath} -> Maybe Text
referencePath) (\s :: DomainPackageDetails
s@DomainPackageDetails' {} Maybe Text
a -> DomainPackageDetails
s {$sel:referencePath:DomainPackageDetails' :: Maybe Text
referencePath = Maybe Text
a} :: DomainPackageDetails)

instance Data.FromJSON DomainPackageDetails where
  parseJSON :: Value -> Parser DomainPackageDetails
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"DomainPackageDetails"
      ( \Object
x ->
          Maybe Text
-> Maybe DomainPackageStatus
-> Maybe ErrorDetails
-> Maybe POSIX
-> Maybe Text
-> Maybe Text
-> Maybe PackageType
-> Maybe Text
-> Maybe Text
-> DomainPackageDetails
DomainPackageDetails'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"DomainName")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"DomainPackageStatus")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ErrorDetails")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"LastUpdated")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"PackageID")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"PackageName")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"PackageType")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"PackageVersion")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ReferencePath")
      )

instance Prelude.Hashable DomainPackageDetails where
  hashWithSalt :: Int -> DomainPackageDetails -> Int
hashWithSalt Int
_salt DomainPackageDetails' {Maybe Text
Maybe POSIX
Maybe DomainPackageStatus
Maybe ErrorDetails
Maybe PackageType
referencePath :: Maybe Text
packageVersion :: Maybe Text
packageType :: Maybe PackageType
packageName :: Maybe Text
packageID :: Maybe Text
lastUpdated :: Maybe POSIX
errorDetails :: Maybe ErrorDetails
domainPackageStatus :: Maybe DomainPackageStatus
domainName :: Maybe Text
$sel:referencePath:DomainPackageDetails' :: DomainPackageDetails -> Maybe Text
$sel:packageVersion:DomainPackageDetails' :: DomainPackageDetails -> Maybe Text
$sel:packageType:DomainPackageDetails' :: DomainPackageDetails -> Maybe PackageType
$sel:packageName:DomainPackageDetails' :: DomainPackageDetails -> Maybe Text
$sel:packageID:DomainPackageDetails' :: DomainPackageDetails -> Maybe Text
$sel:lastUpdated:DomainPackageDetails' :: DomainPackageDetails -> Maybe POSIX
$sel:errorDetails:DomainPackageDetails' :: DomainPackageDetails -> Maybe ErrorDetails
$sel:domainPackageStatus:DomainPackageDetails' :: DomainPackageDetails -> Maybe DomainPackageStatus
$sel:domainName:DomainPackageDetails' :: DomainPackageDetails -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
domainName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DomainPackageStatus
domainPackageStatus
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ErrorDetails
errorDetails
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
lastUpdated
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
packageID
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
packageName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe PackageType
packageType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
packageVersion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
referencePath

instance Prelude.NFData DomainPackageDetails where
  rnf :: DomainPackageDetails -> ()
rnf DomainPackageDetails' {Maybe Text
Maybe POSIX
Maybe DomainPackageStatus
Maybe ErrorDetails
Maybe PackageType
referencePath :: Maybe Text
packageVersion :: Maybe Text
packageType :: Maybe PackageType
packageName :: Maybe Text
packageID :: Maybe Text
lastUpdated :: Maybe POSIX
errorDetails :: Maybe ErrorDetails
domainPackageStatus :: Maybe DomainPackageStatus
domainName :: Maybe Text
$sel:referencePath:DomainPackageDetails' :: DomainPackageDetails -> Maybe Text
$sel:packageVersion:DomainPackageDetails' :: DomainPackageDetails -> Maybe Text
$sel:packageType:DomainPackageDetails' :: DomainPackageDetails -> Maybe PackageType
$sel:packageName:DomainPackageDetails' :: DomainPackageDetails -> Maybe Text
$sel:packageID:DomainPackageDetails' :: DomainPackageDetails -> Maybe Text
$sel:lastUpdated:DomainPackageDetails' :: DomainPackageDetails -> Maybe POSIX
$sel:errorDetails:DomainPackageDetails' :: DomainPackageDetails -> Maybe ErrorDetails
$sel:domainPackageStatus:DomainPackageDetails' :: DomainPackageDetails -> Maybe DomainPackageStatus
$sel:domainName:DomainPackageDetails' :: DomainPackageDetails -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
domainName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe DomainPackageStatus
domainPackageStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ErrorDetails
errorDetails
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
lastUpdated
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
packageID
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
packageName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe PackageType
packageType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
packageVersion
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
referencePath