{-# 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.OpenSearch.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.OpenSearch.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.OpenSearch.Types.DomainPackageStatus
import Amazonka.OpenSearch.Types.ErrorDetails
import Amazonka.OpenSearch.Types.PackageType
import qualified Amazonka.Prelude as Prelude

-- | Information about a package that is associated with a domain. For more
-- information, see
-- <https://docs.aws.amazon.com/opensearch-service/latest/developerguide/custom-packages.html Custom packages for Amazon OpenSearch Service>.
--
-- /See:/ 'newDomainPackageDetails' smart constructor.
data DomainPackageDetails = DomainPackageDetails'
  { -- | Name of the domain that the package is associated with.
    DomainPackageDetails -> Maybe Text
domainName :: Prelude.Maybe Prelude.Text,
    -- | State of the association.
    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 package 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,
    -- | The type of package.
    DomainPackageDetails -> Maybe PackageType
packageType :: Prelude.Maybe PackageType,
    -- | The current version of the package.
    DomainPackageDetails -> Maybe Text
packageVersion :: Prelude.Maybe Prelude.Text,
    -- | Denotes the location of the package on the OpenSearch Service cluster
    -- nodes. It\'s the same as @synonym_path@ for dictionary files.
    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 that the package is associated with.
--
-- 'domainPackageStatus', 'domainPackageDetails_domainPackageStatus' - State of the association.
--
-- '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 package association status.
--
-- 'packageID', 'domainPackageDetails_packageID' - Internal ID of the package.
--
-- 'packageName', 'domainPackageDetails_packageName' - User-specified name of the package.
--
-- 'packageType', 'domainPackageDetails_packageType' - The type of package.
--
-- 'packageVersion', 'domainPackageDetails_packageVersion' - The current version of the package.
--
-- 'referencePath', 'domainPackageDetails_referencePath' - Denotes the location of the package on the OpenSearch Service cluster
-- nodes. It\'s the same as @synonym_path@ for dictionary files.
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 that the package is associated 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.
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 package 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)

-- | The type of package.
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)

-- | The current version of the package.
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)

-- | Denotes the location of the package on the OpenSearch Service cluster
-- nodes. It\'s the same as @synonym_path@ for dictionary files.
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