{-# LANGUAGE CPP                 #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE DataKinds           #-}

-- |
-- Module      : Data.EBird.CLI
-- Copyright   : (c) 2023 Finley McIlwaine
-- License     : MIT (see LICENSE)
--
-- Maintainer  : Finley McIlwaine <finleymcilwaine@gmail.com>
--
-- Functions used to implement a command-line utility for interacting with the
-- [eBird API](https://documenter.getpostman.com/view/664302/S1ENwy59).

module Data.EBird.CLI where

import Control.Exception
import Data.Aeson
import Data.Aeson.Encode.Pretty
import Data.Attoparsec.Text qualified as A
#if !MIN_VERSION_bytestring(0,11,0)
-- Data.ByteString.Char8 does not export 'toStrict' until 0.11.0.0
import Data.ByteString.Lazy qualified as BS (toStrict)
#endif
import Data.ByteString.Char8 qualified as BS
import Data.Char
import Data.Text (Text)
import Data.Text qualified as Text
import Data.Text.IO qualified as Text
import Options.Applicative
import System.Directory
import System.Environment
import System.Exit
import System.FilePath
import Text.Printf

import Data.EBird.API
import Data.EBird.Client

-- | Entry point for the @ebird@ CLI. Parses the command arguments, selects an
-- API key, and executes the command.
--
-- The API key may be provided as a command-line option. If the key option is
-- not provided, it is read from the file @~\/.ebird\/key.txt@. If that file is
-- unavailable for reading, and no key option is provided, the application
-- exits (if the command requires a key).
eBirdCli :: IO ()
eBirdCli :: IO ()
eBirdCli = do
    (Maybe Text
optKey, EBirdCommand
c) <- ParserInfo (Maybe Text, EBirdCommand)
-> IO (Maybe Text, EBirdCommand)
forall a. ParserInfo a -> IO a
execParser ParserInfo (Maybe Text, EBirdCommand)
opts
    Maybe Text
fileKey <- IO (Maybe Text)
readEBirdAPIKey
    let getKey :: IO Text
getKey =
          case Maybe Text
optKey Maybe Text -> Maybe Text -> Maybe Text
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Text
fileKey of
            Just Text
k -> Text -> IO Text
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
k
            Maybe Text
Nothing -> do
              String -> IO Text
forall a. String -> IO a
eBirdFail
                ( String
"An API key is required for this command, but no API key\n" String -> String -> String
forall a. Semigroup a => a -> a -> a
<>
                  String
"was provided via the `-k` option and no API key file was\n" String -> String -> String
forall a. Semigroup a => a -> a -> a
<>
                  String
"found at ~/.ebird/key.txt. Exiting."
                )
    IO Text -> EBirdCommand -> IO ()
runEBirdCommand IO Text
getKey EBirdCommand
c
  where
    opts :: ParserInfo (Maybe Text, EBirdCommand)
    opts :: ParserInfo (Maybe Text, EBirdCommand)
opts =
      Parser (Maybe Text, EBirdCommand)
-> InfoMod (Maybe Text, EBirdCommand)
-> ParserInfo (Maybe Text, EBirdCommand)
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (Parser (Maybe Text, EBirdCommand)
eBirdCommand Parser (Maybe Text, EBirdCommand)
-> Parser
     ((Maybe Text, EBirdCommand) -> (Maybe Text, EBirdCommand))
-> Parser (Maybe Text, EBirdCommand)
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser ((Maybe Text, EBirdCommand) -> (Maybe Text, EBirdCommand))
forall a. Parser (a -> a)
helper)
        (    String -> InfoMod (Maybe Text, EBirdCommand)
forall a. String -> InfoMod a
header String
"ebird-cli - Go birding on your command line!"
          InfoMod (Maybe Text, EBirdCommand)
-> InfoMod (Maybe Text, EBirdCommand)
-> InfoMod (Maybe Text, EBirdCommand)
forall a. Semigroup a => a -> a -> a
<> String -> InfoMod (Maybe Text, EBirdCommand)
forall a. String -> InfoMod a
progDesc String
"Query the official eBird API"
        )

-- | Read an eBird API key from @~\/.ebird\/key.txt@. If the file exists and is
-- available for reading, the result is 'Just' the contents of the file,
-- stripped of leading/trailing whitespace. Otherwise, the result is 'Nothing'.
readEBirdAPIKey :: IO (Maybe Text)
readEBirdAPIKey :: IO (Maybe Text)
readEBirdAPIKey = do
    String
home <- IO String
getHomeDirectory
    IO (Maybe Text)
-> (IOException -> IO (Maybe Text)) -> IO (Maybe Text)
forall e a. Exception e => IO a -> (e -> IO a) -> IO a
catch
      ( Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Maybe Text) -> (Text -> Text) -> Text -> Maybe Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
Text.strip (Text -> Maybe Text) -> IO Text -> IO (Maybe Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
          String -> IO Text
Text.readFile (String
home String -> String -> String
</> String
".ebird" String -> String -> String
</> String
"key" String -> String -> String
<.> String
"txt")
      )
      ( \(IOException
_ :: IOException) -> Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Text
forall a. Maybe a
Nothing
      )

-- | Run an 'EBirdCommand' with a given API key.
runEBirdCommand
  :: IO Text
  -- ^ Get an API key (this may fail if not found or provided)
  -> EBirdCommand
  -- ^ Command to execute
  -> IO ()
runEBirdCommand :: IO Text -> EBirdCommand -> IO ()
runEBirdCommand IO Text
getAPIKey = \case
    RecentObservationsCommand RecentObservationsOptions{Maybe Bool
Maybe Integer
Maybe RegionCode
Maybe SPPLocale
Maybe TaxonomyCategories
RegionCode
recentObservationsRegion :: RegionCode
recentObservationsBack :: Maybe Integer
recentObservationsCategories :: Maybe TaxonomyCategories
recentObservationsHotspots :: Maybe Bool
recentObservationsProvisionals :: Maybe Bool
recentObservationsMaxResults :: Maybe Integer
recentObservationsSubregions :: Maybe RegionCode
recentObservationsSPPLocale :: Maybe SPPLocale
recentObservationsRegion :: RecentObservationsOptions -> RegionCode
recentObservationsBack :: RecentObservationsOptions -> Maybe Integer
recentObservationsCategories :: RecentObservationsOptions -> Maybe TaxonomyCategories
recentObservationsHotspots :: RecentObservationsOptions -> Maybe Bool
recentObservationsProvisionals :: RecentObservationsOptions -> Maybe Bool
recentObservationsMaxResults :: RecentObservationsOptions -> Maybe Integer
recentObservationsSubregions :: RecentObservationsOptions -> Maybe RegionCode
recentObservationsSPPLocale :: RecentObservationsOptions -> Maybe SPPLocale
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      Either ClientError [Observation 'Simple]
res <- ClientM [Observation 'Simple]
-> IO (Either ClientError [Observation 'Simple])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [Observation 'Simple]
 -> IO (Either ClientError [Observation 'Simple]))
-> ClientM [Observation 'Simple]
-> IO (Either ClientError [Observation 'Simple])
forall a b. (a -> b) -> a -> b
$
        Text
-> RegionCode
-> Maybe Integer
-> Maybe TaxonomyCategories
-> Maybe Bool
-> Maybe Bool
-> Maybe Integer
-> Maybe RegionCode
-> Maybe SPPLocale
-> ClientM [Observation 'Simple]
recentObservations_ Text
apiKey
          RegionCode
recentObservationsRegion
          Maybe Integer
recentObservationsBack
          Maybe TaxonomyCategories
recentObservationsCategories
          Maybe Bool
recentObservationsHotspots
          Maybe Bool
recentObservationsProvisionals
          Maybe Integer
recentObservationsMaxResults
          Maybe RegionCode
recentObservationsSubregions
          Maybe SPPLocale
recentObservationsSPPLocale
      Either ClientError [Observation 'Simple] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [Observation 'Simple]
res

    RecentNotableObservationsCommand RecentNotableObservationsOptions{Maybe Bool
Maybe Integer
Maybe DetailLevel
Maybe RegionCode
Maybe SPPLocale
RegionCode
recentNotableObservationsRegion :: RegionCode
recentNotableObservationsBack :: Maybe Integer
recentNotableObservationsDetail :: Maybe DetailLevel
recentNotableObservationsHotspots :: Maybe Bool
recentNotableObservationsMaxResults :: Maybe Integer
recentNotableObservationsSubregions :: Maybe RegionCode
recentNotableObservationsSPPLocale :: Maybe SPPLocale
recentNotableObservationsRegion :: RecentNotableObservationsOptions -> RegionCode
recentNotableObservationsBack :: RecentNotableObservationsOptions -> Maybe Integer
recentNotableObservationsDetail :: RecentNotableObservationsOptions -> Maybe DetailLevel
recentNotableObservationsHotspots :: RecentNotableObservationsOptions -> Maybe Bool
recentNotableObservationsMaxResults :: RecentNotableObservationsOptions -> Maybe Integer
recentNotableObservationsSubregions :: RecentNotableObservationsOptions -> Maybe RegionCode
recentNotableObservationsSPPLocale :: RecentNotableObservationsOptions -> Maybe SPPLocale
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      Either ClientError [SomeObservation]
res <- ClientM [SomeObservation]
-> IO (Either ClientError [SomeObservation])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [SomeObservation]
 -> IO (Either ClientError [SomeObservation]))
-> ClientM [SomeObservation]
-> IO (Either ClientError [SomeObservation])
forall a b. (a -> b) -> a -> b
$
        Text
-> RegionCode
-> Maybe Integer
-> Maybe DetailLevel
-> Maybe Bool
-> Maybe Integer
-> Maybe RegionCode
-> Maybe SPPLocale
-> ClientM [SomeObservation]
recentNotableObservations_ Text
apiKey
          RegionCode
recentNotableObservationsRegion
          Maybe Integer
recentNotableObservationsBack
          Maybe DetailLevel
recentNotableObservationsDetail
          Maybe Bool
recentNotableObservationsHotspots
          Maybe Integer
recentNotableObservationsMaxResults
          Maybe RegionCode
recentNotableObservationsSubregions
          Maybe SPPLocale
recentNotableObservationsSPPLocale
      Either ClientError [SomeObservation] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [SomeObservation]
res

    RecentSpeciesObservationsCommand RecentSpeciesObservationsOptions{Maybe Bool
Maybe Integer
Maybe RegionCode
Maybe SPPLocale
RegionCode
SpeciesCode
recentSpeciesObservationsRegion :: RegionCode
recentSpeciesObservationsSpecies :: SpeciesCode
recentSpeciesObservationsBack :: Maybe Integer
recentSpeciesObservationsHotspots :: Maybe Bool
recentSpeciesObservationsProvisionals :: Maybe Bool
recentSpeciesObservationsMaxResults :: Maybe Integer
recentSpeciesObservationsSubregions :: Maybe RegionCode
recentSpeciesObservationsSPPLocale :: Maybe SPPLocale
recentSpeciesObservationsRegion :: RecentSpeciesObservationsOptions -> RegionCode
recentSpeciesObservationsSpecies :: RecentSpeciesObservationsOptions -> SpeciesCode
recentSpeciesObservationsBack :: RecentSpeciesObservationsOptions -> Maybe Integer
recentSpeciesObservationsHotspots :: RecentSpeciesObservationsOptions -> Maybe Bool
recentSpeciesObservationsProvisionals :: RecentSpeciesObservationsOptions -> Maybe Bool
recentSpeciesObservationsMaxResults :: RecentSpeciesObservationsOptions -> Maybe Integer
recentSpeciesObservationsSubregions :: RecentSpeciesObservationsOptions -> Maybe RegionCode
recentSpeciesObservationsSPPLocale :: RecentSpeciesObservationsOptions -> Maybe SPPLocale
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      Either ClientError [Observation 'Simple]
res <- ClientM [Observation 'Simple]
-> IO (Either ClientError [Observation 'Simple])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [Observation 'Simple]
 -> IO (Either ClientError [Observation 'Simple]))
-> ClientM [Observation 'Simple]
-> IO (Either ClientError [Observation 'Simple])
forall a b. (a -> b) -> a -> b
$
        Text
-> RegionCode
-> SpeciesCode
-> Maybe Integer
-> Maybe Bool
-> Maybe Bool
-> Maybe Integer
-> Maybe RegionCode
-> Maybe SPPLocale
-> ClientM [Observation 'Simple]
recentSpeciesObservations_ Text
apiKey
          RegionCode
recentSpeciesObservationsRegion
          SpeciesCode
recentSpeciesObservationsSpecies
          Maybe Integer
recentSpeciesObservationsBack
          Maybe Bool
recentSpeciesObservationsHotspots
          Maybe Bool
recentSpeciesObservationsProvisionals
          Maybe Integer
recentSpeciesObservationsMaxResults
          Maybe RegionCode
recentSpeciesObservationsSubregions
          Maybe SPPLocale
recentSpeciesObservationsSPPLocale
      Either ClientError [Observation 'Simple] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [Observation 'Simple]
res

    RecentNearbyObservationsCommand RecentNearbyObservationsOptions{Double
Maybe Bool
Maybe Integer
Maybe SortObservationsBy
Maybe SPPLocale
Maybe TaxonomyCategories
recentNearbyObservationsLatitude :: Double
recentNearbyObservationsLongitude :: Double
recentNearbyObservationsDist :: Maybe Integer
recentNearbyObservationsBack :: Maybe Integer
recentNearbyObservationsCategories :: Maybe TaxonomyCategories
recentNearbyObservationsHotspots :: Maybe Bool
recentNearbyObservationsProvisionals :: Maybe Bool
recentNearbyObservationsMaxResults :: Maybe Integer
recentNearbyObservationsSortBy :: Maybe SortObservationsBy
recentNearbyObservationsSPPLocale :: Maybe SPPLocale
recentNearbyObservationsLatitude :: RecentNearbyObservationsOptions -> Double
recentNearbyObservationsLongitude :: RecentNearbyObservationsOptions -> Double
recentNearbyObservationsDist :: RecentNearbyObservationsOptions -> Maybe Integer
recentNearbyObservationsBack :: RecentNearbyObservationsOptions -> Maybe Integer
recentNearbyObservationsCategories :: RecentNearbyObservationsOptions -> Maybe TaxonomyCategories
recentNearbyObservationsHotspots :: RecentNearbyObservationsOptions -> Maybe Bool
recentNearbyObservationsProvisionals :: RecentNearbyObservationsOptions -> Maybe Bool
recentNearbyObservationsMaxResults :: RecentNearbyObservationsOptions -> Maybe Integer
recentNearbyObservationsSortBy :: RecentNearbyObservationsOptions -> Maybe SortObservationsBy
recentNearbyObservationsSPPLocale :: RecentNearbyObservationsOptions -> Maybe SPPLocale
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      Either ClientError [Observation 'Simple]
res <- ClientM [Observation 'Simple]
-> IO (Either ClientError [Observation 'Simple])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [Observation 'Simple]
 -> IO (Either ClientError [Observation 'Simple]))
-> ClientM [Observation 'Simple]
-> IO (Either ClientError [Observation 'Simple])
forall a b. (a -> b) -> a -> b
$
        Text
-> Double
-> Double
-> Maybe Integer
-> Maybe Integer
-> Maybe TaxonomyCategories
-> Maybe Bool
-> Maybe Bool
-> Maybe Integer
-> Maybe SortObservationsBy
-> Maybe SPPLocale
-> ClientM [Observation 'Simple]
recentNearbyObservations_ Text
apiKey
          Double
recentNearbyObservationsLatitude
          Double
recentNearbyObservationsLongitude
          Maybe Integer
recentNearbyObservationsDist
          Maybe Integer
recentNearbyObservationsBack
          Maybe TaxonomyCategories
recentNearbyObservationsCategories
          Maybe Bool
recentNearbyObservationsHotspots
          Maybe Bool
recentNearbyObservationsProvisionals
          Maybe Integer
recentNearbyObservationsMaxResults
          Maybe SortObservationsBy
recentNearbyObservationsSortBy
          Maybe SPPLocale
recentNearbyObservationsSPPLocale
      Either ClientError [Observation 'Simple] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [Observation 'Simple]
res

    RecentNearbySpeciesObservationsCommand RecentNearbySpeciesObservationsOptions{Double
Maybe Bool
Maybe Integer
Maybe SortObservationsBy
Maybe SPPLocale
Maybe TaxonomyCategories
SpeciesCode
recentNearbySpeciesObservationsSpecies :: SpeciesCode
recentNearbySpeciesObservationsLatitude :: Double
recentNearbySpeciesObservationsLongitude :: Double
recentNearbySpeciesObservationsDist :: Maybe Integer
recentNearbySpeciesObservationsBack :: Maybe Integer
recentNearbySpeciesObservationsCategories :: Maybe TaxonomyCategories
recentNearbySpeciesObservationsHotspots :: Maybe Bool
recentNearbySpeciesObservationsProvisionals :: Maybe Bool
recentNearbySpeciesObservationsMaxResults :: Maybe Integer
recentNearbySpeciesObservationsSortBy :: Maybe SortObservationsBy
recentNearbySpeciesObservationsSPPLocale :: Maybe SPPLocale
recentNearbySpeciesObservationsSpecies :: RecentNearbySpeciesObservationsOptions -> SpeciesCode
recentNearbySpeciesObservationsLatitude :: RecentNearbySpeciesObservationsOptions -> Double
recentNearbySpeciesObservationsLongitude :: RecentNearbySpeciesObservationsOptions -> Double
recentNearbySpeciesObservationsDist :: RecentNearbySpeciesObservationsOptions -> Maybe Integer
recentNearbySpeciesObservationsBack :: RecentNearbySpeciesObservationsOptions -> Maybe Integer
recentNearbySpeciesObservationsCategories :: RecentNearbySpeciesObservationsOptions -> Maybe TaxonomyCategories
recentNearbySpeciesObservationsHotspots :: RecentNearbySpeciesObservationsOptions -> Maybe Bool
recentNearbySpeciesObservationsProvisionals :: RecentNearbySpeciesObservationsOptions -> Maybe Bool
recentNearbySpeciesObservationsMaxResults :: RecentNearbySpeciesObservationsOptions -> Maybe Integer
recentNearbySpeciesObservationsSortBy :: RecentNearbySpeciesObservationsOptions -> Maybe SortObservationsBy
recentNearbySpeciesObservationsSPPLocale :: RecentNearbySpeciesObservationsOptions -> Maybe SPPLocale
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      Either ClientError [Observation 'Simple]
res <- ClientM [Observation 'Simple]
-> IO (Either ClientError [Observation 'Simple])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [Observation 'Simple]
 -> IO (Either ClientError [Observation 'Simple]))
-> ClientM [Observation 'Simple]
-> IO (Either ClientError [Observation 'Simple])
forall a b. (a -> b) -> a -> b
$
        Text
-> SpeciesCode
-> Double
-> Double
-> Maybe Integer
-> Maybe Integer
-> Maybe TaxonomyCategories
-> Maybe Bool
-> Maybe Bool
-> Maybe Integer
-> Maybe SortObservationsBy
-> Maybe SPPLocale
-> ClientM [Observation 'Simple]
recentNearbySpeciesObservations_ Text
apiKey
          SpeciesCode
recentNearbySpeciesObservationsSpecies
          Double
recentNearbySpeciesObservationsLatitude
          Double
recentNearbySpeciesObservationsLongitude
          Maybe Integer
recentNearbySpeciesObservationsDist
          Maybe Integer
recentNearbySpeciesObservationsBack
          Maybe TaxonomyCategories
recentNearbySpeciesObservationsCategories
          Maybe Bool
recentNearbySpeciesObservationsHotspots
          Maybe Bool
recentNearbySpeciesObservationsProvisionals
          Maybe Integer
recentNearbySpeciesObservationsMaxResults
          Maybe SortObservationsBy
recentNearbySpeciesObservationsSortBy
          Maybe SPPLocale
recentNearbySpeciesObservationsSPPLocale
      Either ClientError [Observation 'Simple] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [Observation 'Simple]
res

    RecentNearestSpeciesObservationsCommand RecentNearestSpeciesObservationsOptions{Double
Maybe Bool
Maybe Integer
Maybe SPPLocale
SpeciesCode
recentNearestSpeciesObservationsSpecies :: SpeciesCode
recentNearestSpeciesObservationsLatitude :: Double
recentNearestSpeciesObservationsLongitude :: Double
recentNearestSpeciesObservationsDist :: Maybe Integer
recentNearestSpeciesObservationsBack :: Maybe Integer
recentNearestSpeciesObservationsHotspots :: Maybe Bool
recentNearestSpeciesObservationsProvisionals :: Maybe Bool
recentNearestSpeciesObservationsMaxResults :: Maybe Integer
recentNearestSpeciesObservationsSPPLocale :: Maybe SPPLocale
recentNearestSpeciesObservationsSpecies :: RecentNearestSpeciesObservationsOptions -> SpeciesCode
recentNearestSpeciesObservationsLatitude :: RecentNearestSpeciesObservationsOptions -> Double
recentNearestSpeciesObservationsLongitude :: RecentNearestSpeciesObservationsOptions -> Double
recentNearestSpeciesObservationsDist :: RecentNearestSpeciesObservationsOptions -> Maybe Integer
recentNearestSpeciesObservationsBack :: RecentNearestSpeciesObservationsOptions -> Maybe Integer
recentNearestSpeciesObservationsHotspots :: RecentNearestSpeciesObservationsOptions -> Maybe Bool
recentNearestSpeciesObservationsProvisionals :: RecentNearestSpeciesObservationsOptions -> Maybe Bool
recentNearestSpeciesObservationsMaxResults :: RecentNearestSpeciesObservationsOptions -> Maybe Integer
recentNearestSpeciesObservationsSPPLocale :: RecentNearestSpeciesObservationsOptions -> Maybe SPPLocale
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      Either ClientError [Observation 'Simple]
res <- ClientM [Observation 'Simple]
-> IO (Either ClientError [Observation 'Simple])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [Observation 'Simple]
 -> IO (Either ClientError [Observation 'Simple]))
-> ClientM [Observation 'Simple]
-> IO (Either ClientError [Observation 'Simple])
forall a b. (a -> b) -> a -> b
$
        Text
-> SpeciesCode
-> Double
-> Double
-> Maybe Integer
-> Maybe Integer
-> Maybe Bool
-> Maybe Bool
-> Maybe Integer
-> Maybe SPPLocale
-> ClientM [Observation 'Simple]
recentNearestSpeciesObservations_ Text
apiKey
          SpeciesCode
recentNearestSpeciesObservationsSpecies
          Double
recentNearestSpeciesObservationsLatitude
          Double
recentNearestSpeciesObservationsLongitude
          Maybe Integer
recentNearestSpeciesObservationsDist
          Maybe Integer
recentNearestSpeciesObservationsBack
          Maybe Bool
recentNearestSpeciesObservationsHotspots
          Maybe Bool
recentNearestSpeciesObservationsProvisionals
          Maybe Integer
recentNearestSpeciesObservationsMaxResults
          Maybe SPPLocale
recentNearestSpeciesObservationsSPPLocale
      Either ClientError [Observation 'Simple] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [Observation 'Simple]
res

    RecentNearbyNotableObservationsCommand RecentNearbyNotableObservationsOptions{Double
Maybe Bool
Maybe Integer
Maybe DetailLevel
Maybe SPPLocale
recentNearbyNotableObservationsLatitude :: Double
recentNearbyNotableObservationsLongitude :: Double
recentNearbyNotableObservationsDist :: Maybe Integer
recentNearbyNotableObservationsDetail :: Maybe DetailLevel
recentNearbyNotableObservationsBack :: Maybe Integer
recentNearbyNotableObservationsHotspots :: Maybe Bool
recentNearbyNotableObservationsMaxResults :: Maybe Integer
recentNearbyNotableObservationsSPPLocale :: Maybe SPPLocale
recentNearbyNotableObservationsLatitude :: RecentNearbyNotableObservationsOptions -> Double
recentNearbyNotableObservationsLongitude :: RecentNearbyNotableObservationsOptions -> Double
recentNearbyNotableObservationsDist :: RecentNearbyNotableObservationsOptions -> Maybe Integer
recentNearbyNotableObservationsDetail :: RecentNearbyNotableObservationsOptions -> Maybe DetailLevel
recentNearbyNotableObservationsBack :: RecentNearbyNotableObservationsOptions -> Maybe Integer
recentNearbyNotableObservationsHotspots :: RecentNearbyNotableObservationsOptions -> Maybe Bool
recentNearbyNotableObservationsMaxResults :: RecentNearbyNotableObservationsOptions -> Maybe Integer
recentNearbyNotableObservationsSPPLocale :: RecentNearbyNotableObservationsOptions -> Maybe SPPLocale
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      Either ClientError [SomeObservation]
res <- ClientM [SomeObservation]
-> IO (Either ClientError [SomeObservation])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [SomeObservation]
 -> IO (Either ClientError [SomeObservation]))
-> ClientM [SomeObservation]
-> IO (Either ClientError [SomeObservation])
forall a b. (a -> b) -> a -> b
$
        Text
-> Double
-> Double
-> Maybe Integer
-> Maybe DetailLevel
-> Maybe Integer
-> Maybe Bool
-> Maybe Integer
-> Maybe SPPLocale
-> ClientM [SomeObservation]
recentNearbyNotableObservations_ Text
apiKey
          Double
recentNearbyNotableObservationsLatitude
          Double
recentNearbyNotableObservationsLongitude
          Maybe Integer
recentNearbyNotableObservationsDist
          Maybe DetailLevel
recentNearbyNotableObservationsDetail
          Maybe Integer
recentNearbyNotableObservationsBack
          Maybe Bool
recentNearbyNotableObservationsHotspots
          Maybe Integer
recentNearbyNotableObservationsMaxResults
          Maybe SPPLocale
recentNearbyNotableObservationsSPPLocale
      Either ClientError [SomeObservation] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [SomeObservation]
res

    HistoricalObservationsCommand HistoricalObservationsOptions{Maybe Bool
Maybe Integer
Maybe DetailLevel
Maybe SelectObservation
Maybe RegionCode
Maybe SPPLocale
Maybe TaxonomyCategories
RegionCode
EBirdDate
historicalObservationsRegion :: RegionCode
historicalObservationsDate :: EBirdDate
historicalObservationsCategories :: Maybe TaxonomyCategories
historicalObservationsDetail :: Maybe DetailLevel
historicalObservationsHotspots :: Maybe Bool
historicalObservationsProvisionals :: Maybe Bool
historicalObservationsMaxResults :: Maybe Integer
historicalObservationsRank :: Maybe SelectObservation
historicalObservationsSubregions :: Maybe RegionCode
historicalObservationsSPPLocale :: Maybe SPPLocale
historicalObservationsRegion :: HistoricalObservationsOptions -> RegionCode
historicalObservationsDate :: HistoricalObservationsOptions -> EBirdDate
historicalObservationsCategories :: HistoricalObservationsOptions -> Maybe TaxonomyCategories
historicalObservationsDetail :: HistoricalObservationsOptions -> Maybe DetailLevel
historicalObservationsHotspots :: HistoricalObservationsOptions -> Maybe Bool
historicalObservationsProvisionals :: HistoricalObservationsOptions -> Maybe Bool
historicalObservationsMaxResults :: HistoricalObservationsOptions -> Maybe Integer
historicalObservationsRank :: HistoricalObservationsOptions -> Maybe SelectObservation
historicalObservationsSubregions :: HistoricalObservationsOptions -> Maybe RegionCode
historicalObservationsSPPLocale :: HistoricalObservationsOptions -> Maybe SPPLocale
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      let (Integer
y,Integer
m,Integer
d) = EBirdDate -> (Integer, Integer, Integer)
eBirdDateToGregorian EBirdDate
historicalObservationsDate
      Either ClientError [SomeObservation]
res <- ClientM [SomeObservation]
-> IO (Either ClientError [SomeObservation])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [SomeObservation]
 -> IO (Either ClientError [SomeObservation]))
-> ClientM [SomeObservation]
-> IO (Either ClientError [SomeObservation])
forall a b. (a -> b) -> a -> b
$
        Text
-> RegionCode
-> Integer
-> Integer
-> Integer
-> Maybe TaxonomyCategories
-> Maybe DetailLevel
-> Maybe Bool
-> Maybe Bool
-> Maybe Integer
-> Maybe SelectObservation
-> Maybe RegionCode
-> Maybe SPPLocale
-> ClientM [SomeObservation]
historicalObservations_ Text
apiKey
          RegionCode
historicalObservationsRegion
          Integer
y Integer
m Integer
d
          Maybe TaxonomyCategories
historicalObservationsCategories
          Maybe DetailLevel
historicalObservationsDetail
          Maybe Bool
historicalObservationsHotspots
          Maybe Bool
historicalObservationsProvisionals
          Maybe Integer
historicalObservationsMaxResults
          Maybe SelectObservation
historicalObservationsRank
          Maybe RegionCode
historicalObservationsSubregions
          Maybe SPPLocale
historicalObservationsSPPLocale
      Either ClientError [SomeObservation] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [SomeObservation]
res

    RecentChecklistsCommand RecentChecklistsOptions{Maybe Integer
RegionCode
recentChecklistsRegion :: RegionCode
recentChecklistsMaxResults :: Maybe Integer
recentChecklistsRegion :: RecentChecklistsOptions -> RegionCode
recentChecklistsMaxResults :: RecentChecklistsOptions -> Maybe Integer
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      Either ClientError [ChecklistFeedEntry]
res <- ClientM [ChecklistFeedEntry]
-> IO (Either ClientError [ChecklistFeedEntry])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [ChecklistFeedEntry]
 -> IO (Either ClientError [ChecklistFeedEntry]))
-> ClientM [ChecklistFeedEntry]
-> IO (Either ClientError [ChecklistFeedEntry])
forall a b. (a -> b) -> a -> b
$
        Text -> RegionCode -> Maybe Integer -> ClientM [ChecklistFeedEntry]
recentChecklists_ Text
apiKey
          RegionCode
recentChecklistsRegion
          Maybe Integer
recentChecklistsMaxResults
      Either ClientError [ChecklistFeedEntry] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [ChecklistFeedEntry]
res

    Top100Command Top100Options{Maybe Integer
Maybe RankTop100By
Region
EBirdDate
top100Region :: Region
top100Date :: EBirdDate
top100RankedBy :: Maybe RankTop100By
top100MaxResults :: Maybe Integer
top100Region :: Top100Options -> Region
top100Date :: Top100Options -> EBirdDate
top100RankedBy :: Top100Options -> Maybe RankTop100By
top100MaxResults :: Top100Options -> Maybe Integer
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      let (Integer
y,Integer
m,Integer
d) = EBirdDate -> (Integer, Integer, Integer)
eBirdDateToGregorian EBirdDate
top100Date
      Either ClientError [Top100ListEntry]
res <- ClientM [Top100ListEntry]
-> IO (Either ClientError [Top100ListEntry])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [Top100ListEntry]
 -> IO (Either ClientError [Top100ListEntry]))
-> ClientM [Top100ListEntry]
-> IO (Either ClientError [Top100ListEntry])
forall a b. (a -> b) -> a -> b
$
        Text
-> Region
-> Integer
-> Integer
-> Integer
-> Maybe RankTop100By
-> Maybe Integer
-> ClientM [Top100ListEntry]
top100_ Text
apiKey
          Region
top100Region
          Integer
y Integer
m Integer
d
          Maybe RankTop100By
top100RankedBy
          Maybe Integer
top100MaxResults
      Either ClientError [Top100ListEntry] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [Top100ListEntry]
res

    ChecklistFeedCommand ChecklistFeedOptions{Maybe Integer
Maybe SortChecklistsBy
Region
EBirdDate
checklistFeedRegion :: Region
checklistFeedDate :: EBirdDate
checklistFeedSortBy :: Maybe SortChecklistsBy
checklistFeedMaxResults :: Maybe Integer
checklistFeedRegion :: ChecklistFeedOptions -> Region
checklistFeedDate :: ChecklistFeedOptions -> EBirdDate
checklistFeedSortBy :: ChecklistFeedOptions -> Maybe SortChecklistsBy
checklistFeedMaxResults :: ChecklistFeedOptions -> Maybe Integer
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      let (Integer
y,Integer
m,Integer
d) = EBirdDate -> (Integer, Integer, Integer)
eBirdDateToGregorian EBirdDate
checklistFeedDate
      Either ClientError [ChecklistFeedEntry]
res <- ClientM [ChecklistFeedEntry]
-> IO (Either ClientError [ChecklistFeedEntry])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [ChecklistFeedEntry]
 -> IO (Either ClientError [ChecklistFeedEntry]))
-> ClientM [ChecklistFeedEntry]
-> IO (Either ClientError [ChecklistFeedEntry])
forall a b. (a -> b) -> a -> b
$
        Text
-> Region
-> Integer
-> Integer
-> Integer
-> Maybe SortChecklistsBy
-> Maybe Integer
-> ClientM [ChecklistFeedEntry]
checklistFeed_ Text
apiKey
          Region
checklistFeedRegion
          Integer
y Integer
m Integer
d
          Maybe SortChecklistsBy
checklistFeedSortBy
          Maybe Integer
checklistFeedMaxResults
      Either ClientError [ChecklistFeedEntry] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [ChecklistFeedEntry]
res

    RegionalStatisticsCommand RegionalStatisticsOptions{Region
EBirdDate
regionalStatisticsRegion :: Region
regionalStatisticsDate :: EBirdDate
regionalStatisticsRegion :: RegionalStatisticsOptions -> Region
regionalStatisticsDate :: RegionalStatisticsOptions -> EBirdDate
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      let (Integer
y,Integer
m,Integer
d) = EBirdDate -> (Integer, Integer, Integer)
eBirdDateToGregorian EBirdDate
regionalStatisticsDate
      Either ClientError RegionalStatistics
res <- ClientM RegionalStatistics
-> IO (Either ClientError RegionalStatistics)
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM RegionalStatistics
 -> IO (Either ClientError RegionalStatistics))
-> ClientM RegionalStatistics
-> IO (Either ClientError RegionalStatistics)
forall a b. (a -> b) -> a -> b
$
        Text
-> Region
-> Integer
-> Integer
-> Integer
-> ClientM RegionalStatistics
regionalStatistics_ Text
apiKey
          Region
regionalStatisticsRegion
          Integer
y Integer
m Integer
d
      Either ClientError RegionalStatistics -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError RegionalStatistics
res

    SpeciesListCommand SpeciesListOptions{Region
speciesListRegion :: Region
speciesListRegion :: SpeciesListOptions -> Region
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      Either ClientError [SpeciesCode]
res <- ClientM [SpeciesCode] -> IO (Either ClientError [SpeciesCode])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [SpeciesCode] -> IO (Either ClientError [SpeciesCode]))
-> ClientM [SpeciesCode] -> IO (Either ClientError [SpeciesCode])
forall a b. (a -> b) -> a -> b
$
        Text -> Region -> ClientM [SpeciesCode]
speciesList_ Text
apiKey Region
speciesListRegion
      Either ClientError [SpeciesCode] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [SpeciesCode]
res

    ViewChecklistCommand ViewChecklistOptions{Text
viewChecklistSubId :: Text
viewChecklistSubId :: ViewChecklistOptions -> Text
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      Either ClientError Checklist
res <- ClientM Checklist -> IO (Either ClientError Checklist)
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM Checklist -> IO (Either ClientError Checklist))
-> ClientM Checklist -> IO (Either ClientError Checklist)
forall a b. (a -> b) -> a -> b
$
        Text -> Text -> ClientM Checklist
viewChecklist_ Text
apiKey Text
viewChecklistSubId
      Either ClientError Checklist -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError Checklist
res

    RegionHotspotsCommand RegionHotspotsOptions{Maybe Integer
Maybe CSVOrJSONFormat
RegionCode
regionHotspotsRegion :: RegionCode
regionHotspotsBack :: Maybe Integer
regionHotspotsFmt :: Maybe CSVOrJSONFormat
regionHotspotsRegion :: RegionHotspotsOptions -> RegionCode
regionHotspotsBack :: RegionHotspotsOptions -> Maybe Integer
regionHotspotsFmt :: RegionHotspotsOptions -> Maybe CSVOrJSONFormat
..} -> do
      Either ClientError [Hotspot]
res <- ClientM [Hotspot] -> IO (Either ClientError [Hotspot])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [Hotspot] -> IO (Either ClientError [Hotspot]))
-> ClientM [Hotspot] -> IO (Either ClientError [Hotspot])
forall a b. (a -> b) -> a -> b
$
        RegionCode
-> Maybe Integer -> Maybe CSVOrJSONFormat -> ClientM [Hotspot]
regionHotspots_
          RegionCode
regionHotspotsRegion
          Maybe Integer
regionHotspotsBack
          Maybe CSVOrJSONFormat
regionHotspotsFmt
      Either ClientError [Hotspot] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [Hotspot]
res

    NearbyHotspotsCommand NearbyHotspotsOptions{Double
Maybe Integer
Maybe CSVOrJSONFormat
nearbyHotspotsLatitude :: Double
nearbyHotspotsLongitude :: Double
nearbyHotspotsBack :: Maybe Integer
nearbyHotspotsDist :: Maybe Integer
nearbyHotspotsFmt :: Maybe CSVOrJSONFormat
nearbyHotspotsLatitude :: NearbyHotspotsOptions -> Double
nearbyHotspotsLongitude :: NearbyHotspotsOptions -> Double
nearbyHotspotsBack :: NearbyHotspotsOptions -> Maybe Integer
nearbyHotspotsDist :: NearbyHotspotsOptions -> Maybe Integer
nearbyHotspotsFmt :: NearbyHotspotsOptions -> Maybe CSVOrJSONFormat
..} -> do
      Either ClientError [Hotspot]
res <- ClientM [Hotspot] -> IO (Either ClientError [Hotspot])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [Hotspot] -> IO (Either ClientError [Hotspot]))
-> ClientM [Hotspot] -> IO (Either ClientError [Hotspot])
forall a b. (a -> b) -> a -> b
$
        Double
-> Double
-> Maybe Integer
-> Maybe Integer
-> Maybe CSVOrJSONFormat
-> ClientM [Hotspot]
nearbyHotspots_
          Double
nearbyHotspotsLatitude
          Double
nearbyHotspotsLongitude
          Maybe Integer
nearbyHotspotsDist
          Maybe Integer
nearbyHotspotsBack
          Maybe CSVOrJSONFormat
nearbyHotspotsFmt
      Either ClientError [Hotspot] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [Hotspot]
res

    HotspotInfoCommand HotspotInfoOptions{Text
hotspotInfoLocation :: Text
hotspotInfoLocation :: HotspotInfoOptions -> Text
..} -> do
      Either ClientError LocationData
res <- ClientM LocationData -> IO (Either ClientError LocationData)
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM LocationData -> IO (Either ClientError LocationData))
-> ClientM LocationData -> IO (Either ClientError LocationData)
forall a b. (a -> b) -> a -> b
$ Text -> ClientM LocationData
hotspotInfo Text
hotspotInfoLocation
      Either ClientError LocationData -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError LocationData
res

    TaxonomyCommand TaxonomyOptions{Maybe Text
Maybe CSVOrJSONFormat
Maybe SPPLocale
Maybe SpeciesCodes
Maybe TaxonomyCategories
taxonomyTaxonomyCategories :: Maybe TaxonomyCategories
taxonomyFormat :: Maybe CSVOrJSONFormat
taxonomySPPLocale :: Maybe SPPLocale
taxonomySpecies :: Maybe SpeciesCodes
taxonomyVersion :: Maybe Text
taxonomyTaxonomyCategories :: TaxonomyOptions -> Maybe TaxonomyCategories
taxonomyFormat :: TaxonomyOptions -> Maybe CSVOrJSONFormat
taxonomySPPLocale :: TaxonomyOptions -> Maybe SPPLocale
taxonomySpecies :: TaxonomyOptions -> Maybe SpeciesCodes
taxonomyVersion :: TaxonomyOptions -> Maybe Text
..} -> do
      Either ClientError [Taxon]
res <- ClientM [Taxon] -> IO (Either ClientError [Taxon])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [Taxon] -> IO (Either ClientError [Taxon]))
-> ClientM [Taxon] -> IO (Either ClientError [Taxon])
forall a b. (a -> b) -> a -> b
$
        Maybe TaxonomyCategories
-> Maybe CSVOrJSONFormat
-> Maybe SPPLocale
-> Maybe SpeciesCodes
-> Maybe Text
-> ClientM [Taxon]
taxonomy_
          Maybe TaxonomyCategories
taxonomyTaxonomyCategories
          Maybe CSVOrJSONFormat
taxonomyFormat
          Maybe SPPLocale
taxonomySPPLocale
          Maybe SpeciesCodes
taxonomySpecies
          Maybe Text
taxonomyVersion
      Either ClientError [Taxon] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [Taxon]
res

    TaxonomicFormsCommand TaxonomicFormsOptions{SpeciesCode
taxonomicFormsSpecies :: SpeciesCode
taxonomicFormsSpecies :: TaxonomicFormsOptions -> SpeciesCode
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      Either ClientError SpeciesCodes
res <- ClientM SpeciesCodes -> IO (Either ClientError SpeciesCodes)
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM SpeciesCodes -> IO (Either ClientError SpeciesCodes))
-> ClientM SpeciesCodes -> IO (Either ClientError SpeciesCodes)
forall a b. (a -> b) -> a -> b
$
        Text -> SpeciesCode -> ClientM SpeciesCodes
taxonomicForms_ Text
apiKey
          SpeciesCode
taxonomicFormsSpecies
      Either ClientError SpeciesCodes -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError SpeciesCodes
res

    TaxaLocaleCodesCommand TaxaLocaleCodesOptions{Maybe SPPLocale
taxaLocaleCodesAcceptLanguage :: Maybe SPPLocale
taxaLocaleCodesAcceptLanguage :: TaxaLocaleCodesOptions -> Maybe SPPLocale
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      Either ClientError [SPPLocaleListEntry]
res <- ClientM [SPPLocaleListEntry]
-> IO (Either ClientError [SPPLocaleListEntry])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [SPPLocaleListEntry]
 -> IO (Either ClientError [SPPLocaleListEntry]))
-> ClientM [SPPLocaleListEntry]
-> IO (Either ClientError [SPPLocaleListEntry])
forall a b. (a -> b) -> a -> b
$
        Text -> Maybe SPPLocale -> ClientM [SPPLocaleListEntry]
taxaLocaleCodes_ Text
apiKey
          Maybe SPPLocale
taxaLocaleCodesAcceptLanguage
      Either ClientError [SPPLocaleListEntry] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [SPPLocaleListEntry]
res

    EBirdCommand
TaxonomyVersionsCommand -> ClientM [TaxonomyVersionListEntry]
-> IO (Either ClientError [TaxonomyVersionListEntry])
forall a. ClientM a -> IO (Either ClientError a)
askEBird ClientM [TaxonomyVersionListEntry]
taxonomyVersions IO (Either ClientError [TaxonomyVersionListEntry])
-> (Either ClientError [TaxonomyVersionListEntry] -> IO ())
-> IO ()
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Either ClientError [TaxonomyVersionListEntry] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse

    TaxonomicGroupsCommand TaxonomicGroupsOptions{Maybe SPPLocale
SPPGrouping
taxonomicGroupsSPPGrouping :: SPPGrouping
taxonomicGroupsSPPLocale :: Maybe SPPLocale
taxonomicGroupsSPPGrouping :: TaxonomicGroupsOptions -> SPPGrouping
taxonomicGroupsSPPLocale :: TaxonomicGroupsOptions -> Maybe SPPLocale
..} -> do
      Either ClientError [TaxonomicGroupListEntry]
res <- ClientM [TaxonomicGroupListEntry]
-> IO (Either ClientError [TaxonomicGroupListEntry])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [TaxonomicGroupListEntry]
 -> IO (Either ClientError [TaxonomicGroupListEntry]))
-> ClientM [TaxonomicGroupListEntry]
-> IO (Either ClientError [TaxonomicGroupListEntry])
forall a b. (a -> b) -> a -> b
$
        SPPGrouping -> Maybe SPPLocale -> ClientM [TaxonomicGroupListEntry]
taxonomicGroups_
          SPPGrouping
taxonomicGroupsSPPGrouping
          Maybe SPPLocale
taxonomicGroupsSPPLocale
      Either ClientError [TaxonomicGroupListEntry] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [TaxonomicGroupListEntry]
res

    RegionInfoCommand RegionInfoOptions{Maybe RegionNameFormat
Region
regionInfoRegion :: Region
regionInfoRegionNameFormat :: Maybe RegionNameFormat
regionInfoRegion :: RegionInfoOptions -> Region
regionInfoRegionNameFormat :: RegionInfoOptions -> Maybe RegionNameFormat
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      Either ClientError RegionInfo
res <- ClientM RegionInfo -> IO (Either ClientError RegionInfo)
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM RegionInfo -> IO (Either ClientError RegionInfo))
-> ClientM RegionInfo -> IO (Either ClientError RegionInfo)
forall a b. (a -> b) -> a -> b
$
        Text -> Region -> Maybe RegionNameFormat -> ClientM RegionInfo
regionInfo_ Text
apiKey
          Region
regionInfoRegion
          Maybe RegionNameFormat
regionInfoRegionNameFormat
      Either ClientError RegionInfo -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError RegionInfo
res

    SubregionListCommand SubregionListOptions{RegionCode
RegionType
subregionListParentRegionCode :: RegionCode
subregionListRegionType :: RegionType
subregionListParentRegionCode :: SubregionListOptions -> RegionCode
subregionListRegionType :: SubregionListOptions -> RegionType
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      Either ClientError [RegionListEntry]
res <- ClientM [RegionListEntry]
-> IO (Either ClientError [RegionListEntry])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [RegionListEntry]
 -> IO (Either ClientError [RegionListEntry]))
-> ClientM [RegionListEntry]
-> IO (Either ClientError [RegionListEntry])
forall a b. (a -> b) -> a -> b
$
        Text -> RegionType -> RegionCode -> ClientM [RegionListEntry]
subregionList Text
apiKey
          RegionType
subregionListRegionType
          RegionCode
subregionListParentRegionCode
      Either ClientError [RegionListEntry] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [RegionListEntry]
res

    AdjacentRegionsCommand AdjacentRegionsOptions{Region
adjacentRegionsRegion :: Region
adjacentRegionsRegion :: AdjacentRegionsOptions -> Region
..} -> do
      Text
apiKey <- IO Text
getAPIKey
      Either ClientError [RegionListEntry]
res <- ClientM [RegionListEntry]
-> IO (Either ClientError [RegionListEntry])
forall a. ClientM a -> IO (Either ClientError a)
askEBird (ClientM [RegionListEntry]
 -> IO (Either ClientError [RegionListEntry]))
-> ClientM [RegionListEntry]
-> IO (Either ClientError [RegionListEntry])
forall a b. (a -> b) -> a -> b
$
        Text -> Region -> ClientM [RegionListEntry]
adjacentRegions Text
apiKey
          Region
adjacentRegionsRegion
      Either ClientError [RegionListEntry] -> IO ()
forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse Either ClientError [RegionListEntry]
res
  where
    handleResponse :: ToJSON a => Either ClientError a -> IO ()
    handleResponse :: forall a. ToJSON a => Either ClientError a -> IO ()
handleResponse = \case
      Right a
v -> a -> IO ()
forall a. ToJSON a => a -> IO ()
printResJSON a
v
      Left ClientError
err ->
        String -> IO ()
forall a. String -> IO a
eBirdFail (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$
          String
"An error occurred while executing the request:\n" String -> String -> String
forall a. Semigroup a => a -> a -> a
<>
          ClientError -> String
forall a. Show a => a -> String
show ClientError
err


-- | Simply prints a value as prettified JSON
printResJSON :: ToJSON a => a -> IO ()
printResJSON :: forall a. ToJSON a => a -> IO ()
printResJSON = ByteString -> IO ()
BS.putStrLn (ByteString -> IO ()) -> (a -> ByteString) -> a -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
BS.toStrict (ByteString -> ByteString) -> (a -> ByteString) -> a -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ByteString
forall a. ToJSON a => a -> ByteString
encodePretty

-- | Print a string to stderr, prepended with a context string, and exit with
-- failure status.
eBirdFail :: String -> IO a
eBirdFail :: forall a. String -> IO a
eBirdFail String
msg = do
  String
progName <- IO String
getProgName
  String -> IO a
forall a. String -> IO a
die
    ( String
progName String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
": Something went wrong!\n\n"
      String -> String -> String
forall a. Semigroup a => a -> a -> a
<> [String] -> String
unlines ((String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String
"  " String -> String -> String
forall a. Semigroup a => a -> a -> a
<>) (String -> [String]
lines String
msg))
    )

-------------------------------------------------------------------------------
-- Command types
-------------------------------------------------------------------------------

-- | Each 'EBirdCommand' corresponds to an endpoint of the eBird API
data EBirdCommand
    = RecentObservationsCommand RecentObservationsOptions
    | RecentNotableObservationsCommand RecentNotableObservationsOptions
    | RecentSpeciesObservationsCommand RecentSpeciesObservationsOptions
    | RecentNearbyObservationsCommand RecentNearbyObservationsOptions
    | RecentNearbySpeciesObservationsCommand RecentNearbySpeciesObservationsOptions
    | RecentNearestSpeciesObservationsCommand RecentNearestSpeciesObservationsOptions
    | RecentNearbyNotableObservationsCommand RecentNearbyNotableObservationsOptions
    | HistoricalObservationsCommand HistoricalObservationsOptions
    | RecentChecklistsCommand RecentChecklistsOptions
    | Top100Command Top100Options
    | ChecklistFeedCommand ChecklistFeedOptions
    | RegionalStatisticsCommand RegionalStatisticsOptions
    | SpeciesListCommand SpeciesListOptions
    | ViewChecklistCommand ViewChecklistOptions
    | RegionHotspotsCommand RegionHotspotsOptions
    | NearbyHotspotsCommand NearbyHotspotsOptions
    | HotspotInfoCommand HotspotInfoOptions
    | TaxonomyCommand TaxonomyOptions
    | TaxonomicFormsCommand TaxonomicFormsOptions
    | TaxaLocaleCodesCommand TaxaLocaleCodesOptions
    | TaxonomyVersionsCommand
    | TaxonomicGroupsCommand TaxonomicGroupsOptions
    | RegionInfoCommand RegionInfoOptions
    | SubregionListCommand SubregionListOptions
    | AdjacentRegionsCommand AdjacentRegionsOptions
  deriving (Int -> EBirdCommand -> String -> String
[EBirdCommand] -> String -> String
EBirdCommand -> String
(Int -> EBirdCommand -> String -> String)
-> (EBirdCommand -> String)
-> ([EBirdCommand] -> String -> String)
-> Show EBirdCommand
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> EBirdCommand -> String -> String
showsPrec :: Int -> EBirdCommand -> String -> String
$cshow :: EBirdCommand -> String
show :: EBirdCommand -> String
$cshowList :: [EBirdCommand] -> String -> String
showList :: [EBirdCommand] -> String -> String
Show, EBirdCommand -> EBirdCommand -> Bool
(EBirdCommand -> EBirdCommand -> Bool)
-> (EBirdCommand -> EBirdCommand -> Bool) -> Eq EBirdCommand
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EBirdCommand -> EBirdCommand -> Bool
== :: EBirdCommand -> EBirdCommand -> Bool
$c/= :: EBirdCommand -> EBirdCommand -> Bool
/= :: EBirdCommand -> EBirdCommand -> Bool
Eq)

-- | Options for the @recent-observations@ command.
data RecentObservationsOptions =
    RecentObservationsOptions
      { RecentObservationsOptions -> RegionCode
recentObservationsRegion :: RegionCode
      , RecentObservationsOptions -> Maybe Integer
recentObservationsBack :: Maybe Integer
      , RecentObservationsOptions -> Maybe TaxonomyCategories
recentObservationsCategories :: Maybe TaxonomyCategories
      , RecentObservationsOptions -> Maybe Bool
recentObservationsHotspots :: Maybe Bool
      , RecentObservationsOptions -> Maybe Bool
recentObservationsProvisionals :: Maybe Bool
      , RecentObservationsOptions -> Maybe Integer
recentObservationsMaxResults :: Maybe Integer
      , RecentObservationsOptions -> Maybe RegionCode
recentObservationsSubregions :: Maybe RegionCode
      , RecentObservationsOptions -> Maybe SPPLocale
recentObservationsSPPLocale :: Maybe SPPLocale
      }
  deriving (Int -> RecentObservationsOptions -> String -> String
[RecentObservationsOptions] -> String -> String
RecentObservationsOptions -> String
(Int -> RecentObservationsOptions -> String -> String)
-> (RecentObservationsOptions -> String)
-> ([RecentObservationsOptions] -> String -> String)
-> Show RecentObservationsOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RecentObservationsOptions -> String -> String
showsPrec :: Int -> RecentObservationsOptions -> String -> String
$cshow :: RecentObservationsOptions -> String
show :: RecentObservationsOptions -> String
$cshowList :: [RecentObservationsOptions] -> String -> String
showList :: [RecentObservationsOptions] -> String -> String
Show, ReadPrec [RecentObservationsOptions]
ReadPrec RecentObservationsOptions
Int -> ReadS RecentObservationsOptions
ReadS [RecentObservationsOptions]
(Int -> ReadS RecentObservationsOptions)
-> ReadS [RecentObservationsOptions]
-> ReadPrec RecentObservationsOptions
-> ReadPrec [RecentObservationsOptions]
-> Read RecentObservationsOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RecentObservationsOptions
readsPrec :: Int -> ReadS RecentObservationsOptions
$creadList :: ReadS [RecentObservationsOptions]
readList :: ReadS [RecentObservationsOptions]
$creadPrec :: ReadPrec RecentObservationsOptions
readPrec :: ReadPrec RecentObservationsOptions
$creadListPrec :: ReadPrec [RecentObservationsOptions]
readListPrec :: ReadPrec [RecentObservationsOptions]
Read, RecentObservationsOptions -> RecentObservationsOptions -> Bool
(RecentObservationsOptions -> RecentObservationsOptions -> Bool)
-> (RecentObservationsOptions -> RecentObservationsOptions -> Bool)
-> Eq RecentObservationsOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RecentObservationsOptions -> RecentObservationsOptions -> Bool
== :: RecentObservationsOptions -> RecentObservationsOptions -> Bool
$c/= :: RecentObservationsOptions -> RecentObservationsOptions -> Bool
/= :: RecentObservationsOptions -> RecentObservationsOptions -> Bool
Eq)

-- | Options for the @recent-notable-observations@ command.
data RecentNotableObservationsOptions =
    RecentNotableObservationsOptions
      { RecentNotableObservationsOptions -> RegionCode
recentNotableObservationsRegion :: RegionCode
      , RecentNotableObservationsOptions -> Maybe Integer
recentNotableObservationsBack :: Maybe Integer
      , RecentNotableObservationsOptions -> Maybe DetailLevel
recentNotableObservationsDetail :: Maybe DetailLevel
      , RecentNotableObservationsOptions -> Maybe Bool
recentNotableObservationsHotspots :: Maybe Bool
      , RecentNotableObservationsOptions -> Maybe Integer
recentNotableObservationsMaxResults :: Maybe Integer
      , RecentNotableObservationsOptions -> Maybe RegionCode
recentNotableObservationsSubregions :: Maybe RegionCode
      , RecentNotableObservationsOptions -> Maybe SPPLocale
recentNotableObservationsSPPLocale :: Maybe SPPLocale
      }
  deriving (Int -> RecentNotableObservationsOptions -> String -> String
[RecentNotableObservationsOptions] -> String -> String
RecentNotableObservationsOptions -> String
(Int -> RecentNotableObservationsOptions -> String -> String)
-> (RecentNotableObservationsOptions -> String)
-> ([RecentNotableObservationsOptions] -> String -> String)
-> Show RecentNotableObservationsOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RecentNotableObservationsOptions -> String -> String
showsPrec :: Int -> RecentNotableObservationsOptions -> String -> String
$cshow :: RecentNotableObservationsOptions -> String
show :: RecentNotableObservationsOptions -> String
$cshowList :: [RecentNotableObservationsOptions] -> String -> String
showList :: [RecentNotableObservationsOptions] -> String -> String
Show, ReadPrec [RecentNotableObservationsOptions]
ReadPrec RecentNotableObservationsOptions
Int -> ReadS RecentNotableObservationsOptions
ReadS [RecentNotableObservationsOptions]
(Int -> ReadS RecentNotableObservationsOptions)
-> ReadS [RecentNotableObservationsOptions]
-> ReadPrec RecentNotableObservationsOptions
-> ReadPrec [RecentNotableObservationsOptions]
-> Read RecentNotableObservationsOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RecentNotableObservationsOptions
readsPrec :: Int -> ReadS RecentNotableObservationsOptions
$creadList :: ReadS [RecentNotableObservationsOptions]
readList :: ReadS [RecentNotableObservationsOptions]
$creadPrec :: ReadPrec RecentNotableObservationsOptions
readPrec :: ReadPrec RecentNotableObservationsOptions
$creadListPrec :: ReadPrec [RecentNotableObservationsOptions]
readListPrec :: ReadPrec [RecentNotableObservationsOptions]
Read, RecentNotableObservationsOptions
-> RecentNotableObservationsOptions -> Bool
(RecentNotableObservationsOptions
 -> RecentNotableObservationsOptions -> Bool)
-> (RecentNotableObservationsOptions
    -> RecentNotableObservationsOptions -> Bool)
-> Eq RecentNotableObservationsOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RecentNotableObservationsOptions
-> RecentNotableObservationsOptions -> Bool
== :: RecentNotableObservationsOptions
-> RecentNotableObservationsOptions -> Bool
$c/= :: RecentNotableObservationsOptions
-> RecentNotableObservationsOptions -> Bool
/= :: RecentNotableObservationsOptions
-> RecentNotableObservationsOptions -> Bool
Eq)

-- | Options for the @recent-species-observations@ command.
data RecentSpeciesObservationsOptions =
    RecentSpeciesObservationsOptions
      { RecentSpeciesObservationsOptions -> RegionCode
recentSpeciesObservationsRegion :: RegionCode
      , RecentSpeciesObservationsOptions -> SpeciesCode
recentSpeciesObservationsSpecies :: SpeciesCode
      , RecentSpeciesObservationsOptions -> Maybe Integer
recentSpeciesObservationsBack :: Maybe Integer
      , RecentSpeciesObservationsOptions -> Maybe Bool
recentSpeciesObservationsHotspots :: Maybe Bool
      , RecentSpeciesObservationsOptions -> Maybe Bool
recentSpeciesObservationsProvisionals :: Maybe Bool
      , RecentSpeciesObservationsOptions -> Maybe Integer
recentSpeciesObservationsMaxResults :: Maybe Integer
      , RecentSpeciesObservationsOptions -> Maybe RegionCode
recentSpeciesObservationsSubregions :: Maybe RegionCode
      , RecentSpeciesObservationsOptions -> Maybe SPPLocale
recentSpeciesObservationsSPPLocale :: Maybe SPPLocale
      }
  deriving (Int -> RecentSpeciesObservationsOptions -> String -> String
[RecentSpeciesObservationsOptions] -> String -> String
RecentSpeciesObservationsOptions -> String
(Int -> RecentSpeciesObservationsOptions -> String -> String)
-> (RecentSpeciesObservationsOptions -> String)
-> ([RecentSpeciesObservationsOptions] -> String -> String)
-> Show RecentSpeciesObservationsOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RecentSpeciesObservationsOptions -> String -> String
showsPrec :: Int -> RecentSpeciesObservationsOptions -> String -> String
$cshow :: RecentSpeciesObservationsOptions -> String
show :: RecentSpeciesObservationsOptions -> String
$cshowList :: [RecentSpeciesObservationsOptions] -> String -> String
showList :: [RecentSpeciesObservationsOptions] -> String -> String
Show, ReadPrec [RecentSpeciesObservationsOptions]
ReadPrec RecentSpeciesObservationsOptions
Int -> ReadS RecentSpeciesObservationsOptions
ReadS [RecentSpeciesObservationsOptions]
(Int -> ReadS RecentSpeciesObservationsOptions)
-> ReadS [RecentSpeciesObservationsOptions]
-> ReadPrec RecentSpeciesObservationsOptions
-> ReadPrec [RecentSpeciesObservationsOptions]
-> Read RecentSpeciesObservationsOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RecentSpeciesObservationsOptions
readsPrec :: Int -> ReadS RecentSpeciesObservationsOptions
$creadList :: ReadS [RecentSpeciesObservationsOptions]
readList :: ReadS [RecentSpeciesObservationsOptions]
$creadPrec :: ReadPrec RecentSpeciesObservationsOptions
readPrec :: ReadPrec RecentSpeciesObservationsOptions
$creadListPrec :: ReadPrec [RecentSpeciesObservationsOptions]
readListPrec :: ReadPrec [RecentSpeciesObservationsOptions]
Read, RecentSpeciesObservationsOptions
-> RecentSpeciesObservationsOptions -> Bool
(RecentSpeciesObservationsOptions
 -> RecentSpeciesObservationsOptions -> Bool)
-> (RecentSpeciesObservationsOptions
    -> RecentSpeciesObservationsOptions -> Bool)
-> Eq RecentSpeciesObservationsOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RecentSpeciesObservationsOptions
-> RecentSpeciesObservationsOptions -> Bool
== :: RecentSpeciesObservationsOptions
-> RecentSpeciesObservationsOptions -> Bool
$c/= :: RecentSpeciesObservationsOptions
-> RecentSpeciesObservationsOptions -> Bool
/= :: RecentSpeciesObservationsOptions
-> RecentSpeciesObservationsOptions -> Bool
Eq)

-- | Options for the @recent-nearby-observations@ command.
data RecentNearbyObservationsOptions =
    RecentNearbyObservationsOptions
      { RecentNearbyObservationsOptions -> Double
recentNearbyObservationsLatitude :: Double
      , RecentNearbyObservationsOptions -> Double
recentNearbyObservationsLongitude :: Double
      , RecentNearbyObservationsOptions -> Maybe Integer
recentNearbyObservationsDist :: Maybe Integer
      , RecentNearbyObservationsOptions -> Maybe Integer
recentNearbyObservationsBack :: Maybe Integer
      , RecentNearbyObservationsOptions -> Maybe TaxonomyCategories
recentNearbyObservationsCategories :: Maybe TaxonomyCategories
      , RecentNearbyObservationsOptions -> Maybe Bool
recentNearbyObservationsHotspots :: Maybe Bool
      , RecentNearbyObservationsOptions -> Maybe Bool
recentNearbyObservationsProvisionals :: Maybe Bool
      , RecentNearbyObservationsOptions -> Maybe Integer
recentNearbyObservationsMaxResults :: Maybe Integer
      , RecentNearbyObservationsOptions -> Maybe SortObservationsBy
recentNearbyObservationsSortBy :: Maybe SortObservationsBy
      , RecentNearbyObservationsOptions -> Maybe SPPLocale
recentNearbyObservationsSPPLocale :: Maybe SPPLocale
      }
  deriving (Int -> RecentNearbyObservationsOptions -> String -> String
[RecentNearbyObservationsOptions] -> String -> String
RecentNearbyObservationsOptions -> String
(Int -> RecentNearbyObservationsOptions -> String -> String)
-> (RecentNearbyObservationsOptions -> String)
-> ([RecentNearbyObservationsOptions] -> String -> String)
-> Show RecentNearbyObservationsOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RecentNearbyObservationsOptions -> String -> String
showsPrec :: Int -> RecentNearbyObservationsOptions -> String -> String
$cshow :: RecentNearbyObservationsOptions -> String
show :: RecentNearbyObservationsOptions -> String
$cshowList :: [RecentNearbyObservationsOptions] -> String -> String
showList :: [RecentNearbyObservationsOptions] -> String -> String
Show, ReadPrec [RecentNearbyObservationsOptions]
ReadPrec RecentNearbyObservationsOptions
Int -> ReadS RecentNearbyObservationsOptions
ReadS [RecentNearbyObservationsOptions]
(Int -> ReadS RecentNearbyObservationsOptions)
-> ReadS [RecentNearbyObservationsOptions]
-> ReadPrec RecentNearbyObservationsOptions
-> ReadPrec [RecentNearbyObservationsOptions]
-> Read RecentNearbyObservationsOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RecentNearbyObservationsOptions
readsPrec :: Int -> ReadS RecentNearbyObservationsOptions
$creadList :: ReadS [RecentNearbyObservationsOptions]
readList :: ReadS [RecentNearbyObservationsOptions]
$creadPrec :: ReadPrec RecentNearbyObservationsOptions
readPrec :: ReadPrec RecentNearbyObservationsOptions
$creadListPrec :: ReadPrec [RecentNearbyObservationsOptions]
readListPrec :: ReadPrec [RecentNearbyObservationsOptions]
Read, RecentNearbyObservationsOptions
-> RecentNearbyObservationsOptions -> Bool
(RecentNearbyObservationsOptions
 -> RecentNearbyObservationsOptions -> Bool)
-> (RecentNearbyObservationsOptions
    -> RecentNearbyObservationsOptions -> Bool)
-> Eq RecentNearbyObservationsOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RecentNearbyObservationsOptions
-> RecentNearbyObservationsOptions -> Bool
== :: RecentNearbyObservationsOptions
-> RecentNearbyObservationsOptions -> Bool
$c/= :: RecentNearbyObservationsOptions
-> RecentNearbyObservationsOptions -> Bool
/= :: RecentNearbyObservationsOptions
-> RecentNearbyObservationsOptions -> Bool
Eq)

-- | Options for the @recent-nearby-species-observations@ command.
data RecentNearbySpeciesObservationsOptions =
    RecentNearbySpeciesObservationsOptions
      { RecentNearbySpeciesObservationsOptions -> SpeciesCode
recentNearbySpeciesObservationsSpecies :: SpeciesCode
      , RecentNearbySpeciesObservationsOptions -> Double
recentNearbySpeciesObservationsLatitude :: Double
      , RecentNearbySpeciesObservationsOptions -> Double
recentNearbySpeciesObservationsLongitude :: Double
      , RecentNearbySpeciesObservationsOptions -> Maybe Integer
recentNearbySpeciesObservationsDist :: Maybe Integer
      , RecentNearbySpeciesObservationsOptions -> Maybe Integer
recentNearbySpeciesObservationsBack :: Maybe Integer
      , RecentNearbySpeciesObservationsOptions -> Maybe TaxonomyCategories
recentNearbySpeciesObservationsCategories :: Maybe TaxonomyCategories
      , RecentNearbySpeciesObservationsOptions -> Maybe Bool
recentNearbySpeciesObservationsHotspots :: Maybe Bool
      , RecentNearbySpeciesObservationsOptions -> Maybe Bool
recentNearbySpeciesObservationsProvisionals :: Maybe Bool
      , RecentNearbySpeciesObservationsOptions -> Maybe Integer
recentNearbySpeciesObservationsMaxResults :: Maybe Integer
      , RecentNearbySpeciesObservationsOptions -> Maybe SortObservationsBy
recentNearbySpeciesObservationsSortBy :: Maybe SortObservationsBy
      , RecentNearbySpeciesObservationsOptions -> Maybe SPPLocale
recentNearbySpeciesObservationsSPPLocale :: Maybe SPPLocale
      }
  deriving (Int -> RecentNearbySpeciesObservationsOptions -> String -> String
[RecentNearbySpeciesObservationsOptions] -> String -> String
RecentNearbySpeciesObservationsOptions -> String
(Int -> RecentNearbySpeciesObservationsOptions -> String -> String)
-> (RecentNearbySpeciesObservationsOptions -> String)
-> ([RecentNearbySpeciesObservationsOptions] -> String -> String)
-> Show RecentNearbySpeciesObservationsOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RecentNearbySpeciesObservationsOptions -> String -> String
showsPrec :: Int -> RecentNearbySpeciesObservationsOptions -> String -> String
$cshow :: RecentNearbySpeciesObservationsOptions -> String
show :: RecentNearbySpeciesObservationsOptions -> String
$cshowList :: [RecentNearbySpeciesObservationsOptions] -> String -> String
showList :: [RecentNearbySpeciesObservationsOptions] -> String -> String
Show, ReadPrec [RecentNearbySpeciesObservationsOptions]
ReadPrec RecentNearbySpeciesObservationsOptions
Int -> ReadS RecentNearbySpeciesObservationsOptions
ReadS [RecentNearbySpeciesObservationsOptions]
(Int -> ReadS RecentNearbySpeciesObservationsOptions)
-> ReadS [RecentNearbySpeciesObservationsOptions]
-> ReadPrec RecentNearbySpeciesObservationsOptions
-> ReadPrec [RecentNearbySpeciesObservationsOptions]
-> Read RecentNearbySpeciesObservationsOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RecentNearbySpeciesObservationsOptions
readsPrec :: Int -> ReadS RecentNearbySpeciesObservationsOptions
$creadList :: ReadS [RecentNearbySpeciesObservationsOptions]
readList :: ReadS [RecentNearbySpeciesObservationsOptions]
$creadPrec :: ReadPrec RecentNearbySpeciesObservationsOptions
readPrec :: ReadPrec RecentNearbySpeciesObservationsOptions
$creadListPrec :: ReadPrec [RecentNearbySpeciesObservationsOptions]
readListPrec :: ReadPrec [RecentNearbySpeciesObservationsOptions]
Read, RecentNearbySpeciesObservationsOptions
-> RecentNearbySpeciesObservationsOptions -> Bool
(RecentNearbySpeciesObservationsOptions
 -> RecentNearbySpeciesObservationsOptions -> Bool)
-> (RecentNearbySpeciesObservationsOptions
    -> RecentNearbySpeciesObservationsOptions -> Bool)
-> Eq RecentNearbySpeciesObservationsOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RecentNearbySpeciesObservationsOptions
-> RecentNearbySpeciesObservationsOptions -> Bool
== :: RecentNearbySpeciesObservationsOptions
-> RecentNearbySpeciesObservationsOptions -> Bool
$c/= :: RecentNearbySpeciesObservationsOptions
-> RecentNearbySpeciesObservationsOptions -> Bool
/= :: RecentNearbySpeciesObservationsOptions
-> RecentNearbySpeciesObservationsOptions -> Bool
Eq)

-- | Options for the @recent-nearest-species-observations@ command.
data RecentNearestSpeciesObservationsOptions =
    RecentNearestSpeciesObservationsOptions
      { RecentNearestSpeciesObservationsOptions -> SpeciesCode
recentNearestSpeciesObservationsSpecies :: SpeciesCode
      , RecentNearestSpeciesObservationsOptions -> Double
recentNearestSpeciesObservationsLatitude :: Double
      , RecentNearestSpeciesObservationsOptions -> Double
recentNearestSpeciesObservationsLongitude :: Double
      , RecentNearestSpeciesObservationsOptions -> Maybe Integer
recentNearestSpeciesObservationsDist :: Maybe Integer
      , RecentNearestSpeciesObservationsOptions -> Maybe Integer
recentNearestSpeciesObservationsBack :: Maybe Integer
      , RecentNearestSpeciesObservationsOptions -> Maybe Bool
recentNearestSpeciesObservationsHotspots :: Maybe Bool
      , RecentNearestSpeciesObservationsOptions -> Maybe Bool
recentNearestSpeciesObservationsProvisionals :: Maybe Bool
      , RecentNearestSpeciesObservationsOptions -> Maybe Integer
recentNearestSpeciesObservationsMaxResults :: Maybe Integer
      , RecentNearestSpeciesObservationsOptions -> Maybe SPPLocale
recentNearestSpeciesObservationsSPPLocale :: Maybe SPPLocale
      }
  deriving (Int -> RecentNearestSpeciesObservationsOptions -> String -> String
[RecentNearestSpeciesObservationsOptions] -> String -> String
RecentNearestSpeciesObservationsOptions -> String
(Int
 -> RecentNearestSpeciesObservationsOptions -> String -> String)
-> (RecentNearestSpeciesObservationsOptions -> String)
-> ([RecentNearestSpeciesObservationsOptions] -> String -> String)
-> Show RecentNearestSpeciesObservationsOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RecentNearestSpeciesObservationsOptions -> String -> String
showsPrec :: Int -> RecentNearestSpeciesObservationsOptions -> String -> String
$cshow :: RecentNearestSpeciesObservationsOptions -> String
show :: RecentNearestSpeciesObservationsOptions -> String
$cshowList :: [RecentNearestSpeciesObservationsOptions] -> String -> String
showList :: [RecentNearestSpeciesObservationsOptions] -> String -> String
Show, ReadPrec [RecentNearestSpeciesObservationsOptions]
ReadPrec RecentNearestSpeciesObservationsOptions
Int -> ReadS RecentNearestSpeciesObservationsOptions
ReadS [RecentNearestSpeciesObservationsOptions]
(Int -> ReadS RecentNearestSpeciesObservationsOptions)
-> ReadS [RecentNearestSpeciesObservationsOptions]
-> ReadPrec RecentNearestSpeciesObservationsOptions
-> ReadPrec [RecentNearestSpeciesObservationsOptions]
-> Read RecentNearestSpeciesObservationsOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RecentNearestSpeciesObservationsOptions
readsPrec :: Int -> ReadS RecentNearestSpeciesObservationsOptions
$creadList :: ReadS [RecentNearestSpeciesObservationsOptions]
readList :: ReadS [RecentNearestSpeciesObservationsOptions]
$creadPrec :: ReadPrec RecentNearestSpeciesObservationsOptions
readPrec :: ReadPrec RecentNearestSpeciesObservationsOptions
$creadListPrec :: ReadPrec [RecentNearestSpeciesObservationsOptions]
readListPrec :: ReadPrec [RecentNearestSpeciesObservationsOptions]
Read, RecentNearestSpeciesObservationsOptions
-> RecentNearestSpeciesObservationsOptions -> Bool
(RecentNearestSpeciesObservationsOptions
 -> RecentNearestSpeciesObservationsOptions -> Bool)
-> (RecentNearestSpeciesObservationsOptions
    -> RecentNearestSpeciesObservationsOptions -> Bool)
-> Eq RecentNearestSpeciesObservationsOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RecentNearestSpeciesObservationsOptions
-> RecentNearestSpeciesObservationsOptions -> Bool
== :: RecentNearestSpeciesObservationsOptions
-> RecentNearestSpeciesObservationsOptions -> Bool
$c/= :: RecentNearestSpeciesObservationsOptions
-> RecentNearestSpeciesObservationsOptions -> Bool
/= :: RecentNearestSpeciesObservationsOptions
-> RecentNearestSpeciesObservationsOptions -> Bool
Eq)

-- | Options for the @recent-nearby-notable-observations@ command.
data RecentNearbyNotableObservationsOptions =
    RecentNearbyNotableObservationsOptions
      { RecentNearbyNotableObservationsOptions -> Double
recentNearbyNotableObservationsLatitude :: Double
      , RecentNearbyNotableObservationsOptions -> Double
recentNearbyNotableObservationsLongitude :: Double
      , RecentNearbyNotableObservationsOptions -> Maybe Integer
recentNearbyNotableObservationsDist :: Maybe Integer
      , RecentNearbyNotableObservationsOptions -> Maybe DetailLevel
recentNearbyNotableObservationsDetail :: Maybe DetailLevel
      , RecentNearbyNotableObservationsOptions -> Maybe Integer
recentNearbyNotableObservationsBack :: Maybe Integer
      , RecentNearbyNotableObservationsOptions -> Maybe Bool
recentNearbyNotableObservationsHotspots :: Maybe Bool
      , RecentNearbyNotableObservationsOptions -> Maybe Integer
recentNearbyNotableObservationsMaxResults :: Maybe Integer
      , RecentNearbyNotableObservationsOptions -> Maybe SPPLocale
recentNearbyNotableObservationsSPPLocale :: Maybe SPPLocale
      }
  deriving (Int -> RecentNearbyNotableObservationsOptions -> String -> String
[RecentNearbyNotableObservationsOptions] -> String -> String
RecentNearbyNotableObservationsOptions -> String
(Int -> RecentNearbyNotableObservationsOptions -> String -> String)
-> (RecentNearbyNotableObservationsOptions -> String)
-> ([RecentNearbyNotableObservationsOptions] -> String -> String)
-> Show RecentNearbyNotableObservationsOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RecentNearbyNotableObservationsOptions -> String -> String
showsPrec :: Int -> RecentNearbyNotableObservationsOptions -> String -> String
$cshow :: RecentNearbyNotableObservationsOptions -> String
show :: RecentNearbyNotableObservationsOptions -> String
$cshowList :: [RecentNearbyNotableObservationsOptions] -> String -> String
showList :: [RecentNearbyNotableObservationsOptions] -> String -> String
Show, ReadPrec [RecentNearbyNotableObservationsOptions]
ReadPrec RecentNearbyNotableObservationsOptions
Int -> ReadS RecentNearbyNotableObservationsOptions
ReadS [RecentNearbyNotableObservationsOptions]
(Int -> ReadS RecentNearbyNotableObservationsOptions)
-> ReadS [RecentNearbyNotableObservationsOptions]
-> ReadPrec RecentNearbyNotableObservationsOptions
-> ReadPrec [RecentNearbyNotableObservationsOptions]
-> Read RecentNearbyNotableObservationsOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RecentNearbyNotableObservationsOptions
readsPrec :: Int -> ReadS RecentNearbyNotableObservationsOptions
$creadList :: ReadS [RecentNearbyNotableObservationsOptions]
readList :: ReadS [RecentNearbyNotableObservationsOptions]
$creadPrec :: ReadPrec RecentNearbyNotableObservationsOptions
readPrec :: ReadPrec RecentNearbyNotableObservationsOptions
$creadListPrec :: ReadPrec [RecentNearbyNotableObservationsOptions]
readListPrec :: ReadPrec [RecentNearbyNotableObservationsOptions]
Read, RecentNearbyNotableObservationsOptions
-> RecentNearbyNotableObservationsOptions -> Bool
(RecentNearbyNotableObservationsOptions
 -> RecentNearbyNotableObservationsOptions -> Bool)
-> (RecentNearbyNotableObservationsOptions
    -> RecentNearbyNotableObservationsOptions -> Bool)
-> Eq RecentNearbyNotableObservationsOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RecentNearbyNotableObservationsOptions
-> RecentNearbyNotableObservationsOptions -> Bool
== :: RecentNearbyNotableObservationsOptions
-> RecentNearbyNotableObservationsOptions -> Bool
$c/= :: RecentNearbyNotableObservationsOptions
-> RecentNearbyNotableObservationsOptions -> Bool
/= :: RecentNearbyNotableObservationsOptions
-> RecentNearbyNotableObservationsOptions -> Bool
Eq)

-- | Options for the @historical-observations@ command.
data HistoricalObservationsOptions =
    HistoricalObservationsOptions
      { HistoricalObservationsOptions -> RegionCode
historicalObservationsRegion :: RegionCode
      , HistoricalObservationsOptions -> EBirdDate
historicalObservationsDate :: EBirdDate
      , HistoricalObservationsOptions -> Maybe TaxonomyCategories
historicalObservationsCategories :: Maybe TaxonomyCategories
      , HistoricalObservationsOptions -> Maybe DetailLevel
historicalObservationsDetail :: Maybe DetailLevel
      , HistoricalObservationsOptions -> Maybe Bool
historicalObservationsHotspots :: Maybe Bool
      , HistoricalObservationsOptions -> Maybe Bool
historicalObservationsProvisionals :: Maybe Bool
      , HistoricalObservationsOptions -> Maybe Integer
historicalObservationsMaxResults :: Maybe Integer
      , HistoricalObservationsOptions -> Maybe SelectObservation
historicalObservationsRank :: Maybe SelectObservation
      , HistoricalObservationsOptions -> Maybe RegionCode
historicalObservationsSubregions :: Maybe RegionCode
      , HistoricalObservationsOptions -> Maybe SPPLocale
historicalObservationsSPPLocale :: Maybe SPPLocale
      }
  deriving (Int -> HistoricalObservationsOptions -> String -> String
[HistoricalObservationsOptions] -> String -> String
HistoricalObservationsOptions -> String
(Int -> HistoricalObservationsOptions -> String -> String)
-> (HistoricalObservationsOptions -> String)
-> ([HistoricalObservationsOptions] -> String -> String)
-> Show HistoricalObservationsOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> HistoricalObservationsOptions -> String -> String
showsPrec :: Int -> HistoricalObservationsOptions -> String -> String
$cshow :: HistoricalObservationsOptions -> String
show :: HistoricalObservationsOptions -> String
$cshowList :: [HistoricalObservationsOptions] -> String -> String
showList :: [HistoricalObservationsOptions] -> String -> String
Show, ReadPrec [HistoricalObservationsOptions]
ReadPrec HistoricalObservationsOptions
Int -> ReadS HistoricalObservationsOptions
ReadS [HistoricalObservationsOptions]
(Int -> ReadS HistoricalObservationsOptions)
-> ReadS [HistoricalObservationsOptions]
-> ReadPrec HistoricalObservationsOptions
-> ReadPrec [HistoricalObservationsOptions]
-> Read HistoricalObservationsOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS HistoricalObservationsOptions
readsPrec :: Int -> ReadS HistoricalObservationsOptions
$creadList :: ReadS [HistoricalObservationsOptions]
readList :: ReadS [HistoricalObservationsOptions]
$creadPrec :: ReadPrec HistoricalObservationsOptions
readPrec :: ReadPrec HistoricalObservationsOptions
$creadListPrec :: ReadPrec [HistoricalObservationsOptions]
readListPrec :: ReadPrec [HistoricalObservationsOptions]
Read, HistoricalObservationsOptions
-> HistoricalObservationsOptions -> Bool
(HistoricalObservationsOptions
 -> HistoricalObservationsOptions -> Bool)
-> (HistoricalObservationsOptions
    -> HistoricalObservationsOptions -> Bool)
-> Eq HistoricalObservationsOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HistoricalObservationsOptions
-> HistoricalObservationsOptions -> Bool
== :: HistoricalObservationsOptions
-> HistoricalObservationsOptions -> Bool
$c/= :: HistoricalObservationsOptions
-> HistoricalObservationsOptions -> Bool
/= :: HistoricalObservationsOptions
-> HistoricalObservationsOptions -> Bool
Eq)

-- | Options for the @recent-checklists@ command.
data RecentChecklistsOptions =
    RecentChecklistsOptions
      { RecentChecklistsOptions -> RegionCode
recentChecklistsRegion :: RegionCode
      , RecentChecklistsOptions -> Maybe Integer
recentChecklistsMaxResults :: Maybe Integer
      }
  deriving (Int -> RecentChecklistsOptions -> String -> String
[RecentChecklistsOptions] -> String -> String
RecentChecklistsOptions -> String
(Int -> RecentChecklistsOptions -> String -> String)
-> (RecentChecklistsOptions -> String)
-> ([RecentChecklistsOptions] -> String -> String)
-> Show RecentChecklistsOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RecentChecklistsOptions -> String -> String
showsPrec :: Int -> RecentChecklistsOptions -> String -> String
$cshow :: RecentChecklistsOptions -> String
show :: RecentChecklistsOptions -> String
$cshowList :: [RecentChecklistsOptions] -> String -> String
showList :: [RecentChecklistsOptions] -> String -> String
Show, ReadPrec [RecentChecklistsOptions]
ReadPrec RecentChecklistsOptions
Int -> ReadS RecentChecklistsOptions
ReadS [RecentChecklistsOptions]
(Int -> ReadS RecentChecklistsOptions)
-> ReadS [RecentChecklistsOptions]
-> ReadPrec RecentChecklistsOptions
-> ReadPrec [RecentChecklistsOptions]
-> Read RecentChecklistsOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RecentChecklistsOptions
readsPrec :: Int -> ReadS RecentChecklistsOptions
$creadList :: ReadS [RecentChecklistsOptions]
readList :: ReadS [RecentChecklistsOptions]
$creadPrec :: ReadPrec RecentChecklistsOptions
readPrec :: ReadPrec RecentChecklistsOptions
$creadListPrec :: ReadPrec [RecentChecklistsOptions]
readListPrec :: ReadPrec [RecentChecklistsOptions]
Read, RecentChecklistsOptions -> RecentChecklistsOptions -> Bool
(RecentChecklistsOptions -> RecentChecklistsOptions -> Bool)
-> (RecentChecklistsOptions -> RecentChecklistsOptions -> Bool)
-> Eq RecentChecklistsOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RecentChecklistsOptions -> RecentChecklistsOptions -> Bool
== :: RecentChecklistsOptions -> RecentChecklistsOptions -> Bool
$c/= :: RecentChecklistsOptions -> RecentChecklistsOptions -> Bool
/= :: RecentChecklistsOptions -> RecentChecklistsOptions -> Bool
Eq)

-- | Options for the @top-100@ command.
data Top100Options =
    Top100Options
      { Top100Options -> Region
top100Region :: Region
      , Top100Options -> EBirdDate
top100Date :: EBirdDate
      , Top100Options -> Maybe RankTop100By
top100RankedBy :: Maybe RankTop100By
      , Top100Options -> Maybe Integer
top100MaxResults :: Maybe Integer
      }
  deriving (Int -> Top100Options -> String -> String
[Top100Options] -> String -> String
Top100Options -> String
(Int -> Top100Options -> String -> String)
-> (Top100Options -> String)
-> ([Top100Options] -> String -> String)
-> Show Top100Options
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Top100Options -> String -> String
showsPrec :: Int -> Top100Options -> String -> String
$cshow :: Top100Options -> String
show :: Top100Options -> String
$cshowList :: [Top100Options] -> String -> String
showList :: [Top100Options] -> String -> String
Show, ReadPrec [Top100Options]
ReadPrec Top100Options
Int -> ReadS Top100Options
ReadS [Top100Options]
(Int -> ReadS Top100Options)
-> ReadS [Top100Options]
-> ReadPrec Top100Options
-> ReadPrec [Top100Options]
-> Read Top100Options
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Top100Options
readsPrec :: Int -> ReadS Top100Options
$creadList :: ReadS [Top100Options]
readList :: ReadS [Top100Options]
$creadPrec :: ReadPrec Top100Options
readPrec :: ReadPrec Top100Options
$creadListPrec :: ReadPrec [Top100Options]
readListPrec :: ReadPrec [Top100Options]
Read, Top100Options -> Top100Options -> Bool
(Top100Options -> Top100Options -> Bool)
-> (Top100Options -> Top100Options -> Bool) -> Eq Top100Options
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Top100Options -> Top100Options -> Bool
== :: Top100Options -> Top100Options -> Bool
$c/= :: Top100Options -> Top100Options -> Bool
/= :: Top100Options -> Top100Options -> Bool
Eq)

-- | Options for the @checklist-feed@ command.
data ChecklistFeedOptions =
    ChecklistFeedOptions
      { ChecklistFeedOptions -> Region
checklistFeedRegion :: Region
      , ChecklistFeedOptions -> EBirdDate
checklistFeedDate :: EBirdDate
      , ChecklistFeedOptions -> Maybe SortChecklistsBy
checklistFeedSortBy :: Maybe SortChecklistsBy
      , ChecklistFeedOptions -> Maybe Integer
checklistFeedMaxResults :: Maybe Integer
      }
  deriving (Int -> ChecklistFeedOptions -> String -> String
[ChecklistFeedOptions] -> String -> String
ChecklistFeedOptions -> String
(Int -> ChecklistFeedOptions -> String -> String)
-> (ChecklistFeedOptions -> String)
-> ([ChecklistFeedOptions] -> String -> String)
-> Show ChecklistFeedOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ChecklistFeedOptions -> String -> String
showsPrec :: Int -> ChecklistFeedOptions -> String -> String
$cshow :: ChecklistFeedOptions -> String
show :: ChecklistFeedOptions -> String
$cshowList :: [ChecklistFeedOptions] -> String -> String
showList :: [ChecklistFeedOptions] -> String -> String
Show, ReadPrec [ChecklistFeedOptions]
ReadPrec ChecklistFeedOptions
Int -> ReadS ChecklistFeedOptions
ReadS [ChecklistFeedOptions]
(Int -> ReadS ChecklistFeedOptions)
-> ReadS [ChecklistFeedOptions]
-> ReadPrec ChecklistFeedOptions
-> ReadPrec [ChecklistFeedOptions]
-> Read ChecklistFeedOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ChecklistFeedOptions
readsPrec :: Int -> ReadS ChecklistFeedOptions
$creadList :: ReadS [ChecklistFeedOptions]
readList :: ReadS [ChecklistFeedOptions]
$creadPrec :: ReadPrec ChecklistFeedOptions
readPrec :: ReadPrec ChecklistFeedOptions
$creadListPrec :: ReadPrec [ChecklistFeedOptions]
readListPrec :: ReadPrec [ChecklistFeedOptions]
Read, ChecklistFeedOptions -> ChecklistFeedOptions -> Bool
(ChecklistFeedOptions -> ChecklistFeedOptions -> Bool)
-> (ChecklistFeedOptions -> ChecklistFeedOptions -> Bool)
-> Eq ChecklistFeedOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ChecklistFeedOptions -> ChecklistFeedOptions -> Bool
== :: ChecklistFeedOptions -> ChecklistFeedOptions -> Bool
$c/= :: ChecklistFeedOptions -> ChecklistFeedOptions -> Bool
/= :: ChecklistFeedOptions -> ChecklistFeedOptions -> Bool
Eq)

-- | Options for the @regional-statistics@ command.
data RegionalStatisticsOptions =
    RegionalStatisticsOptions
      { RegionalStatisticsOptions -> Region
regionalStatisticsRegion :: Region
      , RegionalStatisticsOptions -> EBirdDate
regionalStatisticsDate :: EBirdDate
      }
  deriving (Int -> RegionalStatisticsOptions -> String -> String
[RegionalStatisticsOptions] -> String -> String
RegionalStatisticsOptions -> String
(Int -> RegionalStatisticsOptions -> String -> String)
-> (RegionalStatisticsOptions -> String)
-> ([RegionalStatisticsOptions] -> String -> String)
-> Show RegionalStatisticsOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RegionalStatisticsOptions -> String -> String
showsPrec :: Int -> RegionalStatisticsOptions -> String -> String
$cshow :: RegionalStatisticsOptions -> String
show :: RegionalStatisticsOptions -> String
$cshowList :: [RegionalStatisticsOptions] -> String -> String
showList :: [RegionalStatisticsOptions] -> String -> String
Show, ReadPrec [RegionalStatisticsOptions]
ReadPrec RegionalStatisticsOptions
Int -> ReadS RegionalStatisticsOptions
ReadS [RegionalStatisticsOptions]
(Int -> ReadS RegionalStatisticsOptions)
-> ReadS [RegionalStatisticsOptions]
-> ReadPrec RegionalStatisticsOptions
-> ReadPrec [RegionalStatisticsOptions]
-> Read RegionalStatisticsOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RegionalStatisticsOptions
readsPrec :: Int -> ReadS RegionalStatisticsOptions
$creadList :: ReadS [RegionalStatisticsOptions]
readList :: ReadS [RegionalStatisticsOptions]
$creadPrec :: ReadPrec RegionalStatisticsOptions
readPrec :: ReadPrec RegionalStatisticsOptions
$creadListPrec :: ReadPrec [RegionalStatisticsOptions]
readListPrec :: ReadPrec [RegionalStatisticsOptions]
Read, RegionalStatisticsOptions -> RegionalStatisticsOptions -> Bool
(RegionalStatisticsOptions -> RegionalStatisticsOptions -> Bool)
-> (RegionalStatisticsOptions -> RegionalStatisticsOptions -> Bool)
-> Eq RegionalStatisticsOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RegionalStatisticsOptions -> RegionalStatisticsOptions -> Bool
== :: RegionalStatisticsOptions -> RegionalStatisticsOptions -> Bool
$c/= :: RegionalStatisticsOptions -> RegionalStatisticsOptions -> Bool
/= :: RegionalStatisticsOptions -> RegionalStatisticsOptions -> Bool
Eq)

-- | Options for the @species-list@ command.
newtype SpeciesListOptions =
    SpeciesListOptions
      { SpeciesListOptions -> Region
speciesListRegion :: Region
      }
  deriving (Int -> SpeciesListOptions -> String -> String
[SpeciesListOptions] -> String -> String
SpeciesListOptions -> String
(Int -> SpeciesListOptions -> String -> String)
-> (SpeciesListOptions -> String)
-> ([SpeciesListOptions] -> String -> String)
-> Show SpeciesListOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> SpeciesListOptions -> String -> String
showsPrec :: Int -> SpeciesListOptions -> String -> String
$cshow :: SpeciesListOptions -> String
show :: SpeciesListOptions -> String
$cshowList :: [SpeciesListOptions] -> String -> String
showList :: [SpeciesListOptions] -> String -> String
Show, ReadPrec [SpeciesListOptions]
ReadPrec SpeciesListOptions
Int -> ReadS SpeciesListOptions
ReadS [SpeciesListOptions]
(Int -> ReadS SpeciesListOptions)
-> ReadS [SpeciesListOptions]
-> ReadPrec SpeciesListOptions
-> ReadPrec [SpeciesListOptions]
-> Read SpeciesListOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SpeciesListOptions
readsPrec :: Int -> ReadS SpeciesListOptions
$creadList :: ReadS [SpeciesListOptions]
readList :: ReadS [SpeciesListOptions]
$creadPrec :: ReadPrec SpeciesListOptions
readPrec :: ReadPrec SpeciesListOptions
$creadListPrec :: ReadPrec [SpeciesListOptions]
readListPrec :: ReadPrec [SpeciesListOptions]
Read, SpeciesListOptions -> SpeciesListOptions -> Bool
(SpeciesListOptions -> SpeciesListOptions -> Bool)
-> (SpeciesListOptions -> SpeciesListOptions -> Bool)
-> Eq SpeciesListOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SpeciesListOptions -> SpeciesListOptions -> Bool
== :: SpeciesListOptions -> SpeciesListOptions -> Bool
$c/= :: SpeciesListOptions -> SpeciesListOptions -> Bool
/= :: SpeciesListOptions -> SpeciesListOptions -> Bool
Eq)

-- | Options for the @view-checklist@ command.
newtype ViewChecklistOptions =
    ViewChecklistOptions
      { ViewChecklistOptions -> Text
viewChecklistSubId :: Text
      }
  deriving (Int -> ViewChecklistOptions -> String -> String
[ViewChecklistOptions] -> String -> String
ViewChecklistOptions -> String
(Int -> ViewChecklistOptions -> String -> String)
-> (ViewChecklistOptions -> String)
-> ([ViewChecklistOptions] -> String -> String)
-> Show ViewChecklistOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ViewChecklistOptions -> String -> String
showsPrec :: Int -> ViewChecklistOptions -> String -> String
$cshow :: ViewChecklistOptions -> String
show :: ViewChecklistOptions -> String
$cshowList :: [ViewChecklistOptions] -> String -> String
showList :: [ViewChecklistOptions] -> String -> String
Show, ReadPrec [ViewChecklistOptions]
ReadPrec ViewChecklistOptions
Int -> ReadS ViewChecklistOptions
ReadS [ViewChecklistOptions]
(Int -> ReadS ViewChecklistOptions)
-> ReadS [ViewChecklistOptions]
-> ReadPrec ViewChecklistOptions
-> ReadPrec [ViewChecklistOptions]
-> Read ViewChecklistOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ViewChecklistOptions
readsPrec :: Int -> ReadS ViewChecklistOptions
$creadList :: ReadS [ViewChecklistOptions]
readList :: ReadS [ViewChecklistOptions]
$creadPrec :: ReadPrec ViewChecklistOptions
readPrec :: ReadPrec ViewChecklistOptions
$creadListPrec :: ReadPrec [ViewChecklistOptions]
readListPrec :: ReadPrec [ViewChecklistOptions]
Read, ViewChecklistOptions -> ViewChecklistOptions -> Bool
(ViewChecklistOptions -> ViewChecklistOptions -> Bool)
-> (ViewChecklistOptions -> ViewChecklistOptions -> Bool)
-> Eq ViewChecklistOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ViewChecklistOptions -> ViewChecklistOptions -> Bool
== :: ViewChecklistOptions -> ViewChecklistOptions -> Bool
$c/= :: ViewChecklistOptions -> ViewChecklistOptions -> Bool
/= :: ViewChecklistOptions -> ViewChecklistOptions -> Bool
Eq)

-- | Options for the @region-hotspots@ command.
data RegionHotspotsOptions =
    RegionHotspotsOptions
      { RegionHotspotsOptions -> RegionCode
regionHotspotsRegion :: RegionCode
      , RegionHotspotsOptions -> Maybe Integer
regionHotspotsBack :: Maybe Integer
      , RegionHotspotsOptions -> Maybe CSVOrJSONFormat
regionHotspotsFmt :: Maybe CSVOrJSONFormat
      }
  deriving (Int -> RegionHotspotsOptions -> String -> String
[RegionHotspotsOptions] -> String -> String
RegionHotspotsOptions -> String
(Int -> RegionHotspotsOptions -> String -> String)
-> (RegionHotspotsOptions -> String)
-> ([RegionHotspotsOptions] -> String -> String)
-> Show RegionHotspotsOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RegionHotspotsOptions -> String -> String
showsPrec :: Int -> RegionHotspotsOptions -> String -> String
$cshow :: RegionHotspotsOptions -> String
show :: RegionHotspotsOptions -> String
$cshowList :: [RegionHotspotsOptions] -> String -> String
showList :: [RegionHotspotsOptions] -> String -> String
Show, ReadPrec [RegionHotspotsOptions]
ReadPrec RegionHotspotsOptions
Int -> ReadS RegionHotspotsOptions
ReadS [RegionHotspotsOptions]
(Int -> ReadS RegionHotspotsOptions)
-> ReadS [RegionHotspotsOptions]
-> ReadPrec RegionHotspotsOptions
-> ReadPrec [RegionHotspotsOptions]
-> Read RegionHotspotsOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RegionHotspotsOptions
readsPrec :: Int -> ReadS RegionHotspotsOptions
$creadList :: ReadS [RegionHotspotsOptions]
readList :: ReadS [RegionHotspotsOptions]
$creadPrec :: ReadPrec RegionHotspotsOptions
readPrec :: ReadPrec RegionHotspotsOptions
$creadListPrec :: ReadPrec [RegionHotspotsOptions]
readListPrec :: ReadPrec [RegionHotspotsOptions]
Read, RegionHotspotsOptions -> RegionHotspotsOptions -> Bool
(RegionHotspotsOptions -> RegionHotspotsOptions -> Bool)
-> (RegionHotspotsOptions -> RegionHotspotsOptions -> Bool)
-> Eq RegionHotspotsOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RegionHotspotsOptions -> RegionHotspotsOptions -> Bool
== :: RegionHotspotsOptions -> RegionHotspotsOptions -> Bool
$c/= :: RegionHotspotsOptions -> RegionHotspotsOptions -> Bool
/= :: RegionHotspotsOptions -> RegionHotspotsOptions -> Bool
Eq)

-- | Options for the @nearby-hotspots@ command.
data NearbyHotspotsOptions =
    NearbyHotspotsOptions
      { NearbyHotspotsOptions -> Double
nearbyHotspotsLatitude :: Double
      , NearbyHotspotsOptions -> Double
nearbyHotspotsLongitude :: Double
      , NearbyHotspotsOptions -> Maybe Integer
nearbyHotspotsBack :: Maybe Integer
      , NearbyHotspotsOptions -> Maybe Integer
nearbyHotspotsDist :: Maybe Integer
      , NearbyHotspotsOptions -> Maybe CSVOrJSONFormat
nearbyHotspotsFmt :: Maybe CSVOrJSONFormat
      }
  deriving (Int -> NearbyHotspotsOptions -> String -> String
[NearbyHotspotsOptions] -> String -> String
NearbyHotspotsOptions -> String
(Int -> NearbyHotspotsOptions -> String -> String)
-> (NearbyHotspotsOptions -> String)
-> ([NearbyHotspotsOptions] -> String -> String)
-> Show NearbyHotspotsOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NearbyHotspotsOptions -> String -> String
showsPrec :: Int -> NearbyHotspotsOptions -> String -> String
$cshow :: NearbyHotspotsOptions -> String
show :: NearbyHotspotsOptions -> String
$cshowList :: [NearbyHotspotsOptions] -> String -> String
showList :: [NearbyHotspotsOptions] -> String -> String
Show, ReadPrec [NearbyHotspotsOptions]
ReadPrec NearbyHotspotsOptions
Int -> ReadS NearbyHotspotsOptions
ReadS [NearbyHotspotsOptions]
(Int -> ReadS NearbyHotspotsOptions)
-> ReadS [NearbyHotspotsOptions]
-> ReadPrec NearbyHotspotsOptions
-> ReadPrec [NearbyHotspotsOptions]
-> Read NearbyHotspotsOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NearbyHotspotsOptions
readsPrec :: Int -> ReadS NearbyHotspotsOptions
$creadList :: ReadS [NearbyHotspotsOptions]
readList :: ReadS [NearbyHotspotsOptions]
$creadPrec :: ReadPrec NearbyHotspotsOptions
readPrec :: ReadPrec NearbyHotspotsOptions
$creadListPrec :: ReadPrec [NearbyHotspotsOptions]
readListPrec :: ReadPrec [NearbyHotspotsOptions]
Read, NearbyHotspotsOptions -> NearbyHotspotsOptions -> Bool
(NearbyHotspotsOptions -> NearbyHotspotsOptions -> Bool)
-> (NearbyHotspotsOptions -> NearbyHotspotsOptions -> Bool)
-> Eq NearbyHotspotsOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NearbyHotspotsOptions -> NearbyHotspotsOptions -> Bool
== :: NearbyHotspotsOptions -> NearbyHotspotsOptions -> Bool
$c/= :: NearbyHotspotsOptions -> NearbyHotspotsOptions -> Bool
/= :: NearbyHotspotsOptions -> NearbyHotspotsOptions -> Bool
Eq)

-- | Options for the @hotspot-info@ command.
newtype HotspotInfoOptions =
    HotspotInfoOptions
      { HotspotInfoOptions -> Text
hotspotInfoLocation :: Text
      }
  deriving (Int -> HotspotInfoOptions -> String -> String
[HotspotInfoOptions] -> String -> String
HotspotInfoOptions -> String
(Int -> HotspotInfoOptions -> String -> String)
-> (HotspotInfoOptions -> String)
-> ([HotspotInfoOptions] -> String -> String)
-> Show HotspotInfoOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> HotspotInfoOptions -> String -> String
showsPrec :: Int -> HotspotInfoOptions -> String -> String
$cshow :: HotspotInfoOptions -> String
show :: HotspotInfoOptions -> String
$cshowList :: [HotspotInfoOptions] -> String -> String
showList :: [HotspotInfoOptions] -> String -> String
Show, ReadPrec [HotspotInfoOptions]
ReadPrec HotspotInfoOptions
Int -> ReadS HotspotInfoOptions
ReadS [HotspotInfoOptions]
(Int -> ReadS HotspotInfoOptions)
-> ReadS [HotspotInfoOptions]
-> ReadPrec HotspotInfoOptions
-> ReadPrec [HotspotInfoOptions]
-> Read HotspotInfoOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS HotspotInfoOptions
readsPrec :: Int -> ReadS HotspotInfoOptions
$creadList :: ReadS [HotspotInfoOptions]
readList :: ReadS [HotspotInfoOptions]
$creadPrec :: ReadPrec HotspotInfoOptions
readPrec :: ReadPrec HotspotInfoOptions
$creadListPrec :: ReadPrec [HotspotInfoOptions]
readListPrec :: ReadPrec [HotspotInfoOptions]
Read, HotspotInfoOptions -> HotspotInfoOptions -> Bool
(HotspotInfoOptions -> HotspotInfoOptions -> Bool)
-> (HotspotInfoOptions -> HotspotInfoOptions -> Bool)
-> Eq HotspotInfoOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HotspotInfoOptions -> HotspotInfoOptions -> Bool
== :: HotspotInfoOptions -> HotspotInfoOptions -> Bool
$c/= :: HotspotInfoOptions -> HotspotInfoOptions -> Bool
/= :: HotspotInfoOptions -> HotspotInfoOptions -> Bool
Eq)

-- | Options for the @nearby-hotspots@ command.
data TaxonomyOptions =
    TaxonomyOptions
      { TaxonomyOptions -> Maybe TaxonomyCategories
taxonomyTaxonomyCategories :: Maybe TaxonomyCategories
      , TaxonomyOptions -> Maybe CSVOrJSONFormat
taxonomyFormat :: Maybe CSVOrJSONFormat
      , TaxonomyOptions -> Maybe SPPLocale
taxonomySPPLocale :: Maybe SPPLocale
      , TaxonomyOptions -> Maybe SpeciesCodes
taxonomySpecies :: Maybe SpeciesCodes
      , TaxonomyOptions -> Maybe Text
taxonomyVersion :: Maybe Text
      }
  deriving (Int -> TaxonomyOptions -> String -> String
[TaxonomyOptions] -> String -> String
TaxonomyOptions -> String
(Int -> TaxonomyOptions -> String -> String)
-> (TaxonomyOptions -> String)
-> ([TaxonomyOptions] -> String -> String)
-> Show TaxonomyOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TaxonomyOptions -> String -> String
showsPrec :: Int -> TaxonomyOptions -> String -> String
$cshow :: TaxonomyOptions -> String
show :: TaxonomyOptions -> String
$cshowList :: [TaxonomyOptions] -> String -> String
showList :: [TaxonomyOptions] -> String -> String
Show, ReadPrec [TaxonomyOptions]
ReadPrec TaxonomyOptions
Int -> ReadS TaxonomyOptions
ReadS [TaxonomyOptions]
(Int -> ReadS TaxonomyOptions)
-> ReadS [TaxonomyOptions]
-> ReadPrec TaxonomyOptions
-> ReadPrec [TaxonomyOptions]
-> Read TaxonomyOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TaxonomyOptions
readsPrec :: Int -> ReadS TaxonomyOptions
$creadList :: ReadS [TaxonomyOptions]
readList :: ReadS [TaxonomyOptions]
$creadPrec :: ReadPrec TaxonomyOptions
readPrec :: ReadPrec TaxonomyOptions
$creadListPrec :: ReadPrec [TaxonomyOptions]
readListPrec :: ReadPrec [TaxonomyOptions]
Read, TaxonomyOptions -> TaxonomyOptions -> Bool
(TaxonomyOptions -> TaxonomyOptions -> Bool)
-> (TaxonomyOptions -> TaxonomyOptions -> Bool)
-> Eq TaxonomyOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TaxonomyOptions -> TaxonomyOptions -> Bool
== :: TaxonomyOptions -> TaxonomyOptions -> Bool
$c/= :: TaxonomyOptions -> TaxonomyOptions -> Bool
/= :: TaxonomyOptions -> TaxonomyOptions -> Bool
Eq)

-- | Options for the @taxonomic-forms@ command.
newtype TaxonomicFormsOptions =
    TaxonomicFormsOptions
      { TaxonomicFormsOptions -> SpeciesCode
taxonomicFormsSpecies :: SpeciesCode
      }
  deriving (Int -> TaxonomicFormsOptions -> String -> String
[TaxonomicFormsOptions] -> String -> String
TaxonomicFormsOptions -> String
(Int -> TaxonomicFormsOptions -> String -> String)
-> (TaxonomicFormsOptions -> String)
-> ([TaxonomicFormsOptions] -> String -> String)
-> Show TaxonomicFormsOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TaxonomicFormsOptions -> String -> String
showsPrec :: Int -> TaxonomicFormsOptions -> String -> String
$cshow :: TaxonomicFormsOptions -> String
show :: TaxonomicFormsOptions -> String
$cshowList :: [TaxonomicFormsOptions] -> String -> String
showList :: [TaxonomicFormsOptions] -> String -> String
Show, ReadPrec [TaxonomicFormsOptions]
ReadPrec TaxonomicFormsOptions
Int -> ReadS TaxonomicFormsOptions
ReadS [TaxonomicFormsOptions]
(Int -> ReadS TaxonomicFormsOptions)
-> ReadS [TaxonomicFormsOptions]
-> ReadPrec TaxonomicFormsOptions
-> ReadPrec [TaxonomicFormsOptions]
-> Read TaxonomicFormsOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TaxonomicFormsOptions
readsPrec :: Int -> ReadS TaxonomicFormsOptions
$creadList :: ReadS [TaxonomicFormsOptions]
readList :: ReadS [TaxonomicFormsOptions]
$creadPrec :: ReadPrec TaxonomicFormsOptions
readPrec :: ReadPrec TaxonomicFormsOptions
$creadListPrec :: ReadPrec [TaxonomicFormsOptions]
readListPrec :: ReadPrec [TaxonomicFormsOptions]
Read, TaxonomicFormsOptions -> TaxonomicFormsOptions -> Bool
(TaxonomicFormsOptions -> TaxonomicFormsOptions -> Bool)
-> (TaxonomicFormsOptions -> TaxonomicFormsOptions -> Bool)
-> Eq TaxonomicFormsOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TaxonomicFormsOptions -> TaxonomicFormsOptions -> Bool
== :: TaxonomicFormsOptions -> TaxonomicFormsOptions -> Bool
$c/= :: TaxonomicFormsOptions -> TaxonomicFormsOptions -> Bool
/= :: TaxonomicFormsOptions -> TaxonomicFormsOptions -> Bool
Eq)

-- | Options for the @taxa-locale-codes@ command.
newtype TaxaLocaleCodesOptions =
    TaxaLocaleCodesOptions
      { TaxaLocaleCodesOptions -> Maybe SPPLocale
taxaLocaleCodesAcceptLanguage :: Maybe SPPLocale
      }
  deriving (Int -> TaxaLocaleCodesOptions -> String -> String
[TaxaLocaleCodesOptions] -> String -> String
TaxaLocaleCodesOptions -> String
(Int -> TaxaLocaleCodesOptions -> String -> String)
-> (TaxaLocaleCodesOptions -> String)
-> ([TaxaLocaleCodesOptions] -> String -> String)
-> Show TaxaLocaleCodesOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TaxaLocaleCodesOptions -> String -> String
showsPrec :: Int -> TaxaLocaleCodesOptions -> String -> String
$cshow :: TaxaLocaleCodesOptions -> String
show :: TaxaLocaleCodesOptions -> String
$cshowList :: [TaxaLocaleCodesOptions] -> String -> String
showList :: [TaxaLocaleCodesOptions] -> String -> String
Show, ReadPrec [TaxaLocaleCodesOptions]
ReadPrec TaxaLocaleCodesOptions
Int -> ReadS TaxaLocaleCodesOptions
ReadS [TaxaLocaleCodesOptions]
(Int -> ReadS TaxaLocaleCodesOptions)
-> ReadS [TaxaLocaleCodesOptions]
-> ReadPrec TaxaLocaleCodesOptions
-> ReadPrec [TaxaLocaleCodesOptions]
-> Read TaxaLocaleCodesOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TaxaLocaleCodesOptions
readsPrec :: Int -> ReadS TaxaLocaleCodesOptions
$creadList :: ReadS [TaxaLocaleCodesOptions]
readList :: ReadS [TaxaLocaleCodesOptions]
$creadPrec :: ReadPrec TaxaLocaleCodesOptions
readPrec :: ReadPrec TaxaLocaleCodesOptions
$creadListPrec :: ReadPrec [TaxaLocaleCodesOptions]
readListPrec :: ReadPrec [TaxaLocaleCodesOptions]
Read, TaxaLocaleCodesOptions -> TaxaLocaleCodesOptions -> Bool
(TaxaLocaleCodesOptions -> TaxaLocaleCodesOptions -> Bool)
-> (TaxaLocaleCodesOptions -> TaxaLocaleCodesOptions -> Bool)
-> Eq TaxaLocaleCodesOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TaxaLocaleCodesOptions -> TaxaLocaleCodesOptions -> Bool
== :: TaxaLocaleCodesOptions -> TaxaLocaleCodesOptions -> Bool
$c/= :: TaxaLocaleCodesOptions -> TaxaLocaleCodesOptions -> Bool
/= :: TaxaLocaleCodesOptions -> TaxaLocaleCodesOptions -> Bool
Eq)

-- | Options for the @taxonomic-groups@ command.
data TaxonomicGroupsOptions =
    TaxonomicGroupsOptions
      { TaxonomicGroupsOptions -> SPPGrouping
taxonomicGroupsSPPGrouping :: SPPGrouping
      , TaxonomicGroupsOptions -> Maybe SPPLocale
taxonomicGroupsSPPLocale :: Maybe SPPLocale
      }
  deriving (Int -> TaxonomicGroupsOptions -> String -> String
[TaxonomicGroupsOptions] -> String -> String
TaxonomicGroupsOptions -> String
(Int -> TaxonomicGroupsOptions -> String -> String)
-> (TaxonomicGroupsOptions -> String)
-> ([TaxonomicGroupsOptions] -> String -> String)
-> Show TaxonomicGroupsOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TaxonomicGroupsOptions -> String -> String
showsPrec :: Int -> TaxonomicGroupsOptions -> String -> String
$cshow :: TaxonomicGroupsOptions -> String
show :: TaxonomicGroupsOptions -> String
$cshowList :: [TaxonomicGroupsOptions] -> String -> String
showList :: [TaxonomicGroupsOptions] -> String -> String
Show, ReadPrec [TaxonomicGroupsOptions]
ReadPrec TaxonomicGroupsOptions
Int -> ReadS TaxonomicGroupsOptions
ReadS [TaxonomicGroupsOptions]
(Int -> ReadS TaxonomicGroupsOptions)
-> ReadS [TaxonomicGroupsOptions]
-> ReadPrec TaxonomicGroupsOptions
-> ReadPrec [TaxonomicGroupsOptions]
-> Read TaxonomicGroupsOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TaxonomicGroupsOptions
readsPrec :: Int -> ReadS TaxonomicGroupsOptions
$creadList :: ReadS [TaxonomicGroupsOptions]
readList :: ReadS [TaxonomicGroupsOptions]
$creadPrec :: ReadPrec TaxonomicGroupsOptions
readPrec :: ReadPrec TaxonomicGroupsOptions
$creadListPrec :: ReadPrec [TaxonomicGroupsOptions]
readListPrec :: ReadPrec [TaxonomicGroupsOptions]
Read, TaxonomicGroupsOptions -> TaxonomicGroupsOptions -> Bool
(TaxonomicGroupsOptions -> TaxonomicGroupsOptions -> Bool)
-> (TaxonomicGroupsOptions -> TaxonomicGroupsOptions -> Bool)
-> Eq TaxonomicGroupsOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TaxonomicGroupsOptions -> TaxonomicGroupsOptions -> Bool
== :: TaxonomicGroupsOptions -> TaxonomicGroupsOptions -> Bool
$c/= :: TaxonomicGroupsOptions -> TaxonomicGroupsOptions -> Bool
/= :: TaxonomicGroupsOptions -> TaxonomicGroupsOptions -> Bool
Eq)

-- | Options for the @region-info@ command.
data RegionInfoOptions =
    RegionInfoOptions
      { RegionInfoOptions -> Region
regionInfoRegion :: Region
      , RegionInfoOptions -> Maybe RegionNameFormat
regionInfoRegionNameFormat :: Maybe RegionNameFormat
      }
  deriving (Int -> RegionInfoOptions -> String -> String
[RegionInfoOptions] -> String -> String
RegionInfoOptions -> String
(Int -> RegionInfoOptions -> String -> String)
-> (RegionInfoOptions -> String)
-> ([RegionInfoOptions] -> String -> String)
-> Show RegionInfoOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RegionInfoOptions -> String -> String
showsPrec :: Int -> RegionInfoOptions -> String -> String
$cshow :: RegionInfoOptions -> String
show :: RegionInfoOptions -> String
$cshowList :: [RegionInfoOptions] -> String -> String
showList :: [RegionInfoOptions] -> String -> String
Show, ReadPrec [RegionInfoOptions]
ReadPrec RegionInfoOptions
Int -> ReadS RegionInfoOptions
ReadS [RegionInfoOptions]
(Int -> ReadS RegionInfoOptions)
-> ReadS [RegionInfoOptions]
-> ReadPrec RegionInfoOptions
-> ReadPrec [RegionInfoOptions]
-> Read RegionInfoOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RegionInfoOptions
readsPrec :: Int -> ReadS RegionInfoOptions
$creadList :: ReadS [RegionInfoOptions]
readList :: ReadS [RegionInfoOptions]
$creadPrec :: ReadPrec RegionInfoOptions
readPrec :: ReadPrec RegionInfoOptions
$creadListPrec :: ReadPrec [RegionInfoOptions]
readListPrec :: ReadPrec [RegionInfoOptions]
Read, RegionInfoOptions -> RegionInfoOptions -> Bool
(RegionInfoOptions -> RegionInfoOptions -> Bool)
-> (RegionInfoOptions -> RegionInfoOptions -> Bool)
-> Eq RegionInfoOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RegionInfoOptions -> RegionInfoOptions -> Bool
== :: RegionInfoOptions -> RegionInfoOptions -> Bool
$c/= :: RegionInfoOptions -> RegionInfoOptions -> Bool
/= :: RegionInfoOptions -> RegionInfoOptions -> Bool
Eq)

-- | Options for the @subregions@ command.
data SubregionListOptions =
    SubregionListOptions
      { SubregionListOptions -> RegionCode
subregionListParentRegionCode :: RegionCode
      , SubregionListOptions -> RegionType
subregionListRegionType :: RegionType
      }
  deriving (Int -> SubregionListOptions -> String -> String
[SubregionListOptions] -> String -> String
SubregionListOptions -> String
(Int -> SubregionListOptions -> String -> String)
-> (SubregionListOptions -> String)
-> ([SubregionListOptions] -> String -> String)
-> Show SubregionListOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> SubregionListOptions -> String -> String
showsPrec :: Int -> SubregionListOptions -> String -> String
$cshow :: SubregionListOptions -> String
show :: SubregionListOptions -> String
$cshowList :: [SubregionListOptions] -> String -> String
showList :: [SubregionListOptions] -> String -> String
Show, ReadPrec [SubregionListOptions]
ReadPrec SubregionListOptions
Int -> ReadS SubregionListOptions
ReadS [SubregionListOptions]
(Int -> ReadS SubregionListOptions)
-> ReadS [SubregionListOptions]
-> ReadPrec SubregionListOptions
-> ReadPrec [SubregionListOptions]
-> Read SubregionListOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SubregionListOptions
readsPrec :: Int -> ReadS SubregionListOptions
$creadList :: ReadS [SubregionListOptions]
readList :: ReadS [SubregionListOptions]
$creadPrec :: ReadPrec SubregionListOptions
readPrec :: ReadPrec SubregionListOptions
$creadListPrec :: ReadPrec [SubregionListOptions]
readListPrec :: ReadPrec [SubregionListOptions]
Read, SubregionListOptions -> SubregionListOptions -> Bool
(SubregionListOptions -> SubregionListOptions -> Bool)
-> (SubregionListOptions -> SubregionListOptions -> Bool)
-> Eq SubregionListOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubregionListOptions -> SubregionListOptions -> Bool
== :: SubregionListOptions -> SubregionListOptions -> Bool
$c/= :: SubregionListOptions -> SubregionListOptions -> Bool
/= :: SubregionListOptions -> SubregionListOptions -> Bool
Eq)

-- | Options for the @subregions@ command.
newtype AdjacentRegionsOptions =
    AdjacentRegionsOptions
      { AdjacentRegionsOptions -> Region
adjacentRegionsRegion :: Region
      }
  deriving (Int -> AdjacentRegionsOptions -> String -> String
[AdjacentRegionsOptions] -> String -> String
AdjacentRegionsOptions -> String
(Int -> AdjacentRegionsOptions -> String -> String)
-> (AdjacentRegionsOptions -> String)
-> ([AdjacentRegionsOptions] -> String -> String)
-> Show AdjacentRegionsOptions
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AdjacentRegionsOptions -> String -> String
showsPrec :: Int -> AdjacentRegionsOptions -> String -> String
$cshow :: AdjacentRegionsOptions -> String
show :: AdjacentRegionsOptions -> String
$cshowList :: [AdjacentRegionsOptions] -> String -> String
showList :: [AdjacentRegionsOptions] -> String -> String
Show, ReadPrec [AdjacentRegionsOptions]
ReadPrec AdjacentRegionsOptions
Int -> ReadS AdjacentRegionsOptions
ReadS [AdjacentRegionsOptions]
(Int -> ReadS AdjacentRegionsOptions)
-> ReadS [AdjacentRegionsOptions]
-> ReadPrec AdjacentRegionsOptions
-> ReadPrec [AdjacentRegionsOptions]
-> Read AdjacentRegionsOptions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AdjacentRegionsOptions
readsPrec :: Int -> ReadS AdjacentRegionsOptions
$creadList :: ReadS [AdjacentRegionsOptions]
readList :: ReadS [AdjacentRegionsOptions]
$creadPrec :: ReadPrec AdjacentRegionsOptions
readPrec :: ReadPrec AdjacentRegionsOptions
$creadListPrec :: ReadPrec [AdjacentRegionsOptions]
readListPrec :: ReadPrec [AdjacentRegionsOptions]
Read, AdjacentRegionsOptions -> AdjacentRegionsOptions -> Bool
(AdjacentRegionsOptions -> AdjacentRegionsOptions -> Bool)
-> (AdjacentRegionsOptions -> AdjacentRegionsOptions -> Bool)
-> Eq AdjacentRegionsOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AdjacentRegionsOptions -> AdjacentRegionsOptions -> Bool
== :: AdjacentRegionsOptions -> AdjacentRegionsOptions -> Bool
$c/= :: AdjacentRegionsOptions -> AdjacentRegionsOptions -> Bool
/= :: AdjacentRegionsOptions -> AdjacentRegionsOptions -> Bool
Eq)

-------------------------------------------------------------------------------
-- Command/option/flag parsers
-------------------------------------------------------------------------------

-- | Parse a command provided to the @ebird@ CLI.
eBirdCommand :: Parser (Maybe Text, EBirdCommand)
eBirdCommand :: Parser (Maybe Text, EBirdCommand)
eBirdCommand =
        (,)
    (Maybe Text -> EBirdCommand -> (Maybe Text, EBirdCommand))
-> Parser (Maybe Text)
-> Parser (EBirdCommand -> (Maybe Text, EBirdCommand))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Maybe Text)
optionalAPIKey
    Parser (EBirdCommand -> (Maybe Text, EBirdCommand))
-> Parser EBirdCommand -> Parser (Maybe Text, EBirdCommand)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
      (     Mod CommandFields EBirdCommand -> Parser EBirdCommand
forall a. Mod CommandFields a -> Parser a
subparser
              (    String -> Mod CommandFields EBirdCommand
forall a. String -> Mod CommandFields a
commandGroup String
"Observation commands:"
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"observations" ParserInfo EBirdCommand
recentObservationsInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"notable-observations" ParserInfo EBirdCommand
recentNotableObservationsInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"species-observations" ParserInfo EBirdCommand
recentSpeciesObservationsInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"nearby-observations" ParserInfo EBirdCommand
recentNearbyObservationsInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"nearby-species-observations" ParserInfo EBirdCommand
recentNearbySpeciesObservationsInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"nearest-species-observations" ParserInfo EBirdCommand
recentNearestSpeciesObservationsInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"nearby-notable-observations" ParserInfo EBirdCommand
recentNearbyNotableObservationsInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"historical-observations" ParserInfo EBirdCommand
historicalObservationsInfo
              )
        Parser EBirdCommand -> Parser EBirdCommand -> Parser EBirdCommand
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Mod CommandFields EBirdCommand -> Parser EBirdCommand
forall a. Mod CommandFields a -> Parser a
subparser
              (
                String -> Mod CommandFields EBirdCommand
forall a. String -> Mod CommandFields a
commandGroup String
"Product commands:"
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"recent-checklists" ParserInfo EBirdCommand
recentChecklistsInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"top-100" ParserInfo EBirdCommand
top100Info
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"checklist-feed" ParserInfo EBirdCommand
checklistFeedInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"regional-statistics" ParserInfo EBirdCommand
regionalStatisticsInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"species-list" ParserInfo EBirdCommand
speciesListInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"view-checklist" ParserInfo EBirdCommand
viewChecklistInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> Mod CommandFields EBirdCommand
forall (f :: * -> *) a. Mod f a
hidden
              )
        Parser EBirdCommand -> Parser EBirdCommand -> Parser EBirdCommand
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Mod CommandFields EBirdCommand -> Parser EBirdCommand
forall a. Mod CommandFields a -> Parser a
subparser
              (
                   String -> Mod CommandFields EBirdCommand
forall a. String -> Mod CommandFields a
commandGroup String
"Hotspot commands:"
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"region-hotspots" ParserInfo EBirdCommand
regionHotspotsInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"nearby-hotspots" ParserInfo EBirdCommand
nearbyHotspotsInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"hotspot-info" ParserInfo EBirdCommand
hotspotInfoInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> Mod CommandFields EBirdCommand
forall (f :: * -> *) a. Mod f a
hidden
              )
        Parser EBirdCommand -> Parser EBirdCommand -> Parser EBirdCommand
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Mod CommandFields EBirdCommand -> Parser EBirdCommand
forall a. Mod CommandFields a -> Parser a
subparser
              (
                   String -> Mod CommandFields EBirdCommand
forall a. String -> Mod CommandFields a
commandGroup String
"Taxonomy commands:"
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"taxonomy" ParserInfo EBirdCommand
taxonomyInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"taxonomic-forms" ParserInfo EBirdCommand
taxonomicFormsInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"taxa-locale-codes" ParserInfo EBirdCommand
taxaLocaleCodesInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"taxonomy-versions" ParserInfo EBirdCommand
taxonomyVersionsInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"taxonomic-groups" ParserInfo EBirdCommand
taxonomicGroupsInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> Mod CommandFields EBirdCommand
forall (f :: * -> *) a. Mod f a
hidden
              )
        Parser EBirdCommand -> Parser EBirdCommand -> Parser EBirdCommand
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Mod CommandFields EBirdCommand -> Parser EBirdCommand
forall a. Mod CommandFields a -> Parser a
subparser
              (
                   String -> Mod CommandFields EBirdCommand
forall a. String -> Mod CommandFields a
commandGroup String
"Region commands:"
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"region-info" ParserInfo EBirdCommand
regionInfoInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"subregions" ParserInfo EBirdCommand
subregionsInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> String -> ParserInfo EBirdCommand -> Mod CommandFields EBirdCommand
forall a. String -> ParserInfo a -> Mod CommandFields a
command String
"adjacent-regions" ParserInfo EBirdCommand
adjacentRegionsInfo
                Mod CommandFields EBirdCommand
-> Mod CommandFields EBirdCommand -> Mod CommandFields EBirdCommand
forall a. Semigroup a => a -> a -> a
<> Mod CommandFields EBirdCommand
forall (f :: * -> *) a. Mod f a
hidden
              )
      )
  where
    optionalAPIKey :: Parser (Maybe Text)
    optionalAPIKey :: Parser (Maybe Text)
optionalAPIKey =
      Parser Text -> Parser (Maybe Text)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
        ( Mod OptionFields Text -> Parser Text
forall s. IsString s => Mod OptionFields s -> Parser s
strOption
            (    String -> Mod OptionFields Text
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"api-key"
              Mod OptionFields Text
-> Mod OptionFields Text -> Mod OptionFields Text
forall a. Semigroup a => a -> a -> a
<> Char -> Mod OptionFields Text
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short Char
'k'
              Mod OptionFields Text
-> Mod OptionFields Text -> Mod OptionFields Text
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Text
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"API_KEY"
              Mod OptionFields Text
-> Mod OptionFields Text -> Mod OptionFields Text
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Text
forall (f :: * -> *) a. String -> Mod f a
help String
"Specify an eBird API key"
            )
        )

    recentObservationsInfo :: ParserInfo EBirdCommand
    recentObservationsInfo :: ParserInfo EBirdCommand
recentObservationsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (RecentObservationsOptions -> EBirdCommand
RecentObservationsCommand (RecentObservationsOptions -> EBirdCommand)
-> Parser RecentObservationsOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser RecentObservationsOptions
recentObservationsOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get recent observations within a region")

    recentNotableObservationsInfo :: ParserInfo EBirdCommand
    recentNotableObservationsInfo :: ParserInfo EBirdCommand
recentNotableObservationsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (RecentNotableObservationsOptions -> EBirdCommand
RecentNotableObservationsCommand (RecentNotableObservationsOptions -> EBirdCommand)
-> Parser RecentNotableObservationsOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser RecentNotableObservationsOptions
recentNotableObservationsOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get recent notable observations within a region")

    recentSpeciesObservationsInfo :: ParserInfo EBirdCommand
    recentSpeciesObservationsInfo :: ParserInfo EBirdCommand
recentSpeciesObservationsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (RecentSpeciesObservationsOptions -> EBirdCommand
RecentSpeciesObservationsCommand (RecentSpeciesObservationsOptions -> EBirdCommand)
-> Parser RecentSpeciesObservationsOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser RecentSpeciesObservationsOptions
recentSpeciesObservationsOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get recent observations of a species within a region")

    recentNearbyObservationsInfo :: ParserInfo EBirdCommand
    recentNearbyObservationsInfo :: ParserInfo EBirdCommand
recentNearbyObservationsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (RecentNearbyObservationsOptions -> EBirdCommand
RecentNearbyObservationsCommand (RecentNearbyObservationsOptions -> EBirdCommand)
-> Parser RecentNearbyObservationsOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser RecentNearbyObservationsOptions
recentNearbyObservationsOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get recent observations within some radius of a latitude/longitude")

    recentNearbySpeciesObservationsInfo :: ParserInfo EBirdCommand
    recentNearbySpeciesObservationsInfo :: ParserInfo EBirdCommand
recentNearbySpeciesObservationsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (RecentNearbySpeciesObservationsOptions -> EBirdCommand
RecentNearbySpeciesObservationsCommand (RecentNearbySpeciesObservationsOptions -> EBirdCommand)
-> Parser RecentNearbySpeciesObservationsOptions
-> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser RecentNearbySpeciesObservationsOptions
recentNearbySpeciesObservationsOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get recent observations of a species within some radius of a latitude/longitude")

    recentNearestSpeciesObservationsInfo :: ParserInfo EBirdCommand
    recentNearestSpeciesObservationsInfo :: ParserInfo EBirdCommand
recentNearestSpeciesObservationsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (RecentNearestSpeciesObservationsOptions -> EBirdCommand
RecentNearestSpeciesObservationsCommand (RecentNearestSpeciesObservationsOptions -> EBirdCommand)
-> Parser RecentNearestSpeciesObservationsOptions
-> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser RecentNearestSpeciesObservationsOptions
recentNearestSpeciesObservationsOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get recent observations of a species nearest to a latitude/longitude")

    recentNearbyNotableObservationsInfo :: ParserInfo EBirdCommand
    recentNearbyNotableObservationsInfo :: ParserInfo EBirdCommand
recentNearbyNotableObservationsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (RecentNearbyNotableObservationsOptions -> EBirdCommand
RecentNearbyNotableObservationsCommand (RecentNearbyNotableObservationsOptions -> EBirdCommand)
-> Parser RecentNearbyNotableObservationsOptions
-> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser RecentNearbyNotableObservationsOptions
recentNearbyNotableObservationsOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get recent notable observations within some radius of a latitude/longitude")

    historicalObservationsInfo :: ParserInfo EBirdCommand
    historicalObservationsInfo :: ParserInfo EBirdCommand
historicalObservationsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (HistoricalObservationsOptions -> EBirdCommand
HistoricalObservationsCommand (HistoricalObservationsOptions -> EBirdCommand)
-> Parser HistoricalObservationsOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser HistoricalObservationsOptions
historicalObservationsOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get a list of observations for each species seen in a region on a specific date")

    recentChecklistsInfo :: ParserInfo EBirdCommand
    recentChecklistsInfo :: ParserInfo EBirdCommand
recentChecklistsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (RecentChecklistsOptions -> EBirdCommand
RecentChecklistsCommand (RecentChecklistsOptions -> EBirdCommand)
-> Parser RecentChecklistsOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser RecentChecklistsOptions
recentChecklistsOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get recent checklists within a region")

    top100Info :: ParserInfo EBirdCommand
    top100Info :: ParserInfo EBirdCommand
top100Info =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (Top100Options -> EBirdCommand
Top100Command (Top100Options -> EBirdCommand)
-> Parser Top100Options -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Top100Options
top100Options)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get the top 100 contributors in a region for a given date")

    checklistFeedInfo :: ParserInfo EBirdCommand
    checklistFeedInfo :: ParserInfo EBirdCommand
checklistFeedInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (ChecklistFeedOptions -> EBirdCommand
ChecklistFeedCommand (ChecklistFeedOptions -> EBirdCommand)
-> Parser ChecklistFeedOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ChecklistFeedOptions
checklistFeedOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get the checklist feed in a region for a given date")

    regionalStatisticsInfo :: ParserInfo EBirdCommand
    regionalStatisticsInfo :: ParserInfo EBirdCommand
regionalStatisticsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (RegionalStatisticsOptions -> EBirdCommand
RegionalStatisticsCommand (RegionalStatisticsOptions -> EBirdCommand)
-> Parser RegionalStatisticsOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser RegionalStatisticsOptions
regionalStatisticsOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get the regional statistics for a region on a given date")

    speciesListInfo :: ParserInfo EBirdCommand
    speciesListInfo :: ParserInfo EBirdCommand
speciesListInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (SpeciesListOptions -> EBirdCommand
SpeciesListCommand (SpeciesListOptions -> EBirdCommand)
-> Parser SpeciesListOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SpeciesListOptions
speciesListOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get the list of all species ever observed in a region")

    viewChecklistInfo :: ParserInfo EBirdCommand
    viewChecklistInfo :: ParserInfo EBirdCommand
viewChecklistInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (ViewChecklistOptions -> EBirdCommand
ViewChecklistCommand (ViewChecklistOptions -> EBirdCommand)
-> Parser ViewChecklistOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ViewChecklistOptions
viewChecklistOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get information about a particular checklist")

    regionHotspotsInfo :: ParserInfo EBirdCommand
    regionHotspotsInfo :: ParserInfo EBirdCommand
regionHotspotsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (RegionHotspotsOptions -> EBirdCommand
RegionHotspotsCommand (RegionHotspotsOptions -> EBirdCommand)
-> Parser RegionHotspotsOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser RegionHotspotsOptions
regionHotspotsOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get a list of hotspots in one or more regions")

    nearbyHotspotsInfo :: ParserInfo EBirdCommand
    nearbyHotspotsInfo :: ParserInfo EBirdCommand
nearbyHotspotsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (NearbyHotspotsOptions -> EBirdCommand
NearbyHotspotsCommand (NearbyHotspotsOptions -> EBirdCommand)
-> Parser NearbyHotspotsOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NearbyHotspotsOptions
nearbyHotspotsOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get a list of hotspots within some radius of a latitude/longitude")

    hotspotInfoInfo :: ParserInfo EBirdCommand
    hotspotInfoInfo :: ParserInfo EBirdCommand
hotspotInfoInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (HotspotInfoOptions -> EBirdCommand
HotspotInfoCommand (HotspotInfoOptions -> EBirdCommand)
-> Parser HotspotInfoOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser HotspotInfoOptions
hotspotInfoOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get information about a hotspot")

    taxonomyInfo :: ParserInfo EBirdCommand
    taxonomyInfo :: ParserInfo EBirdCommand
taxonomyInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (TaxonomyOptions -> EBirdCommand
TaxonomyCommand (TaxonomyOptions -> EBirdCommand)
-> Parser TaxonomyOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TaxonomyOptions
taxonomyOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get any version of the eBird taxonomy")

    taxonomicFormsInfo :: ParserInfo EBirdCommand
    taxonomicFormsInfo :: ParserInfo EBirdCommand
taxonomicFormsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (TaxonomicFormsOptions -> EBirdCommand
TaxonomicFormsCommand (TaxonomicFormsOptions -> EBirdCommand)
-> Parser TaxonomicFormsOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TaxonomicFormsOptions
taxonomicFormsOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get the subspecies of a given species recognized by the taxonomy")

    taxaLocaleCodesInfo :: ParserInfo EBirdCommand
    taxaLocaleCodesInfo :: ParserInfo EBirdCommand
taxaLocaleCodesInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (TaxaLocaleCodesOptions -> EBirdCommand
TaxaLocaleCodesCommand (TaxaLocaleCodesOptions -> EBirdCommand)
-> Parser TaxaLocaleCodesOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TaxaLocaleCodesOptions
taxaLocaleCodesOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get the supported locale codes and names for species common names")

    taxonomyVersionsInfo :: ParserInfo EBirdCommand
    taxonomyVersionsInfo :: ParserInfo EBirdCommand
taxonomyVersionsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (EBirdCommand -> Parser EBirdCommand
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure EBirdCommand
TaxonomyVersionsCommand Parser EBirdCommand
-> Parser (EBirdCommand -> EBirdCommand) -> Parser EBirdCommand
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (EBirdCommand -> EBirdCommand)
forall a. Parser (a -> a)
helper)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get the complete list of taxonomy versions, with a flag indicating which is the latest")

    taxonomicGroupsInfo :: ParserInfo EBirdCommand
    taxonomicGroupsInfo :: ParserInfo EBirdCommand
taxonomicGroupsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (TaxonomicGroupsOptions -> EBirdCommand
TaxonomicGroupsCommand (TaxonomicGroupsOptions -> EBirdCommand)
-> Parser TaxonomicGroupsOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TaxonomicGroupsOptions
taxonomicGroupsOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get the list of species groups in either Merlin or eBird grouping")

    regionInfoInfo :: ParserInfo EBirdCommand
    regionInfoInfo :: ParserInfo EBirdCommand
regionInfoInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (RegionInfoOptions -> EBirdCommand
RegionInfoCommand (RegionInfoOptions -> EBirdCommand)
-> Parser RegionInfoOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser RegionInfoOptions
regionInfoOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get information about a region")

    subregionsInfo :: ParserInfo EBirdCommand
    subregionsInfo :: ParserInfo EBirdCommand
subregionsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (SubregionListOptions -> EBirdCommand
SubregionListCommand (SubregionListOptions -> EBirdCommand)
-> Parser SubregionListOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SubregionListOptions
subregionListOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get the list of subregions within a region")

    adjacentRegionsInfo :: ParserInfo EBirdCommand
    adjacentRegionsInfo :: ParserInfo EBirdCommand
adjacentRegionsInfo =
      Parser EBirdCommand
-> InfoMod EBirdCommand -> ParserInfo EBirdCommand
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (AdjacentRegionsOptions -> EBirdCommand
AdjacentRegionsCommand (AdjacentRegionsOptions -> EBirdCommand)
-> Parser AdjacentRegionsOptions -> Parser EBirdCommand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AdjacentRegionsOptions
adjacentRegionsOptions)
        (String -> InfoMod EBirdCommand
forall a. String -> InfoMod a
progDesc String
"Get the list of regions that are adjacent to a region")

-------------------------------------------------------------------------------
-- Parsers for observation command options
-------------------------------------------------------------------------------

-- | Parse the options for the @recent-observations@ command.
recentObservationsOptions :: Parser RecentObservationsOptions
recentObservationsOptions :: Parser RecentObservationsOptions
recentObservationsOptions =
        RegionCode
-> Maybe Integer
-> Maybe TaxonomyCategories
-> Maybe Bool
-> Maybe Bool
-> Maybe Integer
-> Maybe RegionCode
-> Maybe SPPLocale
-> RecentObservationsOptions
RecentObservationsOptions
    (RegionCode
 -> Maybe Integer
 -> Maybe TaxonomyCategories
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Integer
 -> Maybe RegionCode
 -> Maybe SPPLocale
 -> RecentObservationsOptions)
-> Parser RegionCode
-> Parser
     (Maybe Integer
      -> Maybe TaxonomyCategories
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> RecentObservationsOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> Parser RegionCode
regionCodeOpt String
"observations"
    Parser
  (Maybe Integer
   -> Maybe TaxonomyCategories
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> RecentObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe TaxonomyCategories
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> RecentObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> String -> Maybe Integer -> Parser Integer
backOpt String
"observations" String
"submitted" (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
14))
    Parser
  (Maybe TaxonomyCategories
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> RecentObservationsOptions)
-> Parser (Maybe TaxonomyCategories)
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> RecentObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TaxonomyCategories -> Parser (Maybe TaxonomyCategories)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Parser TaxonomyCategories
taxonomyCategoriesOpt String
"observations of")
    Parser
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> RecentObservationsOptions)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Maybe Integer
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> RecentObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Bool
observationOnlyHotspotsOpt
    Parser
  (Maybe Bool
   -> Maybe Integer
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> RecentObservationsOptions)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Integer
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> RecentObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Bool
observationIncludeProvisionalOpt
    Parser
  (Maybe Integer
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> RecentObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe RegionCode -> Maybe SPPLocale -> RecentObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Integer
observationMaxResultsOpt
    Parser
  (Maybe RegionCode -> Maybe SPPLocale -> RecentObservationsOptions)
-> Parser (Maybe RegionCode)
-> Parser (Maybe SPPLocale -> RecentObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser RegionCode -> Parser (Maybe RegionCode)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser RegionCode
extraRegionsOpt
    Parser (Maybe SPPLocale -> RecentObservationsOptions)
-> Parser (Maybe SPPLocale) -> Parser RecentObservationsOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SPPLocale -> Parser (Maybe SPPLocale)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Parser SPPLocale
sppLocaleOpt String
"common")
    Parser RecentObservationsOptions
-> Parser (RecentObservationsOptions -> RecentObservationsOptions)
-> Parser RecentObservationsOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (RecentObservationsOptions -> RecentObservationsOptions)
forall a. Parser (a -> a)
helper

-- | Parse the options for a @recent-notable-observations@ command.
recentNotableObservationsOptions :: Parser RecentNotableObservationsOptions
recentNotableObservationsOptions :: Parser RecentNotableObservationsOptions
recentNotableObservationsOptions =
        RegionCode
-> Maybe Integer
-> Maybe DetailLevel
-> Maybe Bool
-> Maybe Integer
-> Maybe RegionCode
-> Maybe SPPLocale
-> RecentNotableObservationsOptions
RecentNotableObservationsOptions
    (RegionCode
 -> Maybe Integer
 -> Maybe DetailLevel
 -> Maybe Bool
 -> Maybe Integer
 -> Maybe RegionCode
 -> Maybe SPPLocale
 -> RecentNotableObservationsOptions)
-> Parser RegionCode
-> Parser
     (Maybe Integer
      -> Maybe DetailLevel
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> RecentNotableObservationsOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> Parser RegionCode
regionCodeOpt String
"observations"
    Parser
  (Maybe Integer
   -> Maybe DetailLevel
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> RecentNotableObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe DetailLevel
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> RecentNotableObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> String -> Maybe Integer -> Parser Integer
backOpt String
"observations" String
"submitted" (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
14))
    Parser
  (Maybe DetailLevel
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> RecentNotableObservationsOptions)
-> Parser (Maybe DetailLevel)
-> Parser
     (Maybe Bool
      -> Maybe Integer
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> RecentNotableObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser DetailLevel -> Parser (Maybe DetailLevel)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser DetailLevel
observationDetailLevelOpt
    Parser
  (Maybe Bool
   -> Maybe Integer
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> RecentNotableObservationsOptions)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Integer
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> RecentNotableObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Bool
observationOnlyHotspotsOpt
    Parser
  (Maybe Integer
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> RecentNotableObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe RegionCode
      -> Maybe SPPLocale -> RecentNotableObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Integer
observationMaxResultsOpt
    Parser
  (Maybe RegionCode
   -> Maybe SPPLocale -> RecentNotableObservationsOptions)
-> Parser (Maybe RegionCode)
-> Parser (Maybe SPPLocale -> RecentNotableObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser RegionCode -> Parser (Maybe RegionCode)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser RegionCode
extraRegionsOpt
    Parser (Maybe SPPLocale -> RecentNotableObservationsOptions)
-> Parser (Maybe SPPLocale)
-> Parser RecentNotableObservationsOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SPPLocale -> Parser (Maybe SPPLocale)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Parser SPPLocale
sppLocaleOpt String
"common")
    Parser RecentNotableObservationsOptions
-> Parser
     (RecentNotableObservationsOptions
      -> RecentNotableObservationsOptions)
-> Parser RecentNotableObservationsOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser
  (RecentNotableObservationsOptions
   -> RecentNotableObservationsOptions)
forall a. Parser (a -> a)
helper

-- | Parse the options for a @recent-species-observations@ command.
recentSpeciesObservationsOptions :: Parser RecentSpeciesObservationsOptions
recentSpeciesObservationsOptions :: Parser RecentSpeciesObservationsOptions
recentSpeciesObservationsOptions =
        RegionCode
-> SpeciesCode
-> Maybe Integer
-> Maybe Bool
-> Maybe Bool
-> Maybe Integer
-> Maybe RegionCode
-> Maybe SPPLocale
-> RecentSpeciesObservationsOptions
RecentSpeciesObservationsOptions
    (RegionCode
 -> SpeciesCode
 -> Maybe Integer
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Integer
 -> Maybe RegionCode
 -> Maybe SPPLocale
 -> RecentSpeciesObservationsOptions)
-> Parser RegionCode
-> Parser
     (SpeciesCode
      -> Maybe Integer
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> RecentSpeciesObservationsOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> Parser RegionCode
regionCodeOpt String
"observations"
    Parser
  (SpeciesCode
   -> Maybe Integer
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> RecentSpeciesObservationsOptions)
-> Parser SpeciesCode
-> Parser
     (Maybe Integer
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> RecentSpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> String -> Parser SpeciesCode
speciesCodeOpt String
"observations"
    Parser
  (Maybe Integer
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> RecentSpeciesObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> RecentSpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> String -> Maybe Integer -> Parser Integer
backOpt String
"observations" String
"submitted" (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
14))
    Parser
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> RecentSpeciesObservationsOptions)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Maybe Integer
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> RecentSpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Bool
observationOnlyHotspotsOpt
    Parser
  (Maybe Bool
   -> Maybe Integer
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> RecentSpeciesObservationsOptions)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Integer
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> RecentSpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Bool
observationIncludeProvisionalOpt
    Parser
  (Maybe Integer
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> RecentSpeciesObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe RegionCode
      -> Maybe SPPLocale -> RecentSpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Integer
observationMaxResultsOpt
    Parser
  (Maybe RegionCode
   -> Maybe SPPLocale -> RecentSpeciesObservationsOptions)
-> Parser (Maybe RegionCode)
-> Parser (Maybe SPPLocale -> RecentSpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser RegionCode -> Parser (Maybe RegionCode)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser RegionCode
extraRegionsOpt
    Parser (Maybe SPPLocale -> RecentSpeciesObservationsOptions)
-> Parser (Maybe SPPLocale)
-> Parser RecentSpeciesObservationsOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SPPLocale -> Parser (Maybe SPPLocale)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Parser SPPLocale
sppLocaleOpt String
"common")
    Parser RecentSpeciesObservationsOptions
-> Parser
     (RecentSpeciesObservationsOptions
      -> RecentSpeciesObservationsOptions)
-> Parser RecentSpeciesObservationsOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser
  (RecentSpeciesObservationsOptions
   -> RecentSpeciesObservationsOptions)
forall a. Parser (a -> a)
helper

-- | Parse the options for a @recent-nearby-observations@ command.
recentNearbyObservationsOptions :: Parser RecentNearbyObservationsOptions
recentNearbyObservationsOptions :: Parser RecentNearbyObservationsOptions
recentNearbyObservationsOptions =
        Double
-> Double
-> Maybe Integer
-> Maybe Integer
-> Maybe TaxonomyCategories
-> Maybe Bool
-> Maybe Bool
-> Maybe Integer
-> Maybe SortObservationsBy
-> Maybe SPPLocale
-> RecentNearbyObservationsOptions
RecentNearbyObservationsOptions
    (Double
 -> Double
 -> Maybe Integer
 -> Maybe Integer
 -> Maybe TaxonomyCategories
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Integer
 -> Maybe SortObservationsBy
 -> Maybe SPPLocale
 -> RecentNearbyObservationsOptions)
-> Parser Double
-> Parser
     (Double
      -> Maybe Integer
      -> Maybe Integer
      -> Maybe TaxonomyCategories
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SortObservationsBy
      -> Maybe SPPLocale
      -> RecentNearbyObservationsOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> String -> Parser Double
latLngOpt String
"latitude" String
"observations"
    Parser
  (Double
   -> Maybe Integer
   -> Maybe Integer
   -> Maybe TaxonomyCategories
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SortObservationsBy
   -> Maybe SPPLocale
   -> RecentNearbyObservationsOptions)
-> Parser Double
-> Parser
     (Maybe Integer
      -> Maybe Integer
      -> Maybe TaxonomyCategories
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SortObservationsBy
      -> Maybe SPPLocale
      -> RecentNearbyObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> String -> String -> Parser Double
latLngOpt String
"longitude" String
"observations"
    Parser
  (Maybe Integer
   -> Maybe Integer
   -> Maybe TaxonomyCategories
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SortObservationsBy
   -> Maybe SPPLocale
   -> RecentNearbyObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe Integer
      -> Maybe TaxonomyCategories
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SortObservationsBy
      -> Maybe SPPLocale
      -> RecentNearbyObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Integer -> Maybe Integer -> Parser Integer
searchRadiusOpt String
"observations" Integer
50 (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
25))
    Parser
  (Maybe Integer
   -> Maybe TaxonomyCategories
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SortObservationsBy
   -> Maybe SPPLocale
   -> RecentNearbyObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe TaxonomyCategories
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SortObservationsBy
      -> Maybe SPPLocale
      -> RecentNearbyObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> String -> Maybe Integer -> Parser Integer
backOpt String
"observations" String
"submitted" (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
14))
    Parser
  (Maybe TaxonomyCategories
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SortObservationsBy
   -> Maybe SPPLocale
   -> RecentNearbyObservationsOptions)
-> Parser (Maybe TaxonomyCategories)
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SortObservationsBy
      -> Maybe SPPLocale
      -> RecentNearbyObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TaxonomyCategories -> Parser (Maybe TaxonomyCategories)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Parser TaxonomyCategories
taxonomyCategoriesOpt String
"observations of")
    Parser
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SortObservationsBy
   -> Maybe SPPLocale
   -> RecentNearbyObservationsOptions)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Maybe Integer
      -> Maybe SortObservationsBy
      -> Maybe SPPLocale
      -> RecentNearbyObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Bool
observationOnlyHotspotsOpt
    Parser
  (Maybe Bool
   -> Maybe Integer
   -> Maybe SortObservationsBy
   -> Maybe SPPLocale
   -> RecentNearbyObservationsOptions)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Integer
      -> Maybe SortObservationsBy
      -> Maybe SPPLocale
      -> RecentNearbyObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Bool
observationIncludeProvisionalOpt
    Parser
  (Maybe Integer
   -> Maybe SortObservationsBy
   -> Maybe SPPLocale
   -> RecentNearbyObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe SortObservationsBy
      -> Maybe SPPLocale -> RecentNearbyObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Integer
observationMaxResultsOpt
    Parser
  (Maybe SortObservationsBy
   -> Maybe SPPLocale -> RecentNearbyObservationsOptions)
-> Parser (Maybe SortObservationsBy)
-> Parser (Maybe SPPLocale -> RecentNearbyObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SortObservationsBy -> Parser (Maybe SortObservationsBy)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser SortObservationsBy
observationSortByOpt
    Parser (Maybe SPPLocale -> RecentNearbyObservationsOptions)
-> Parser (Maybe SPPLocale)
-> Parser RecentNearbyObservationsOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SPPLocale -> Parser (Maybe SPPLocale)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Parser SPPLocale
sppLocaleOpt String
"common")
    Parser RecentNearbyObservationsOptions
-> Parser
     (RecentNearbyObservationsOptions
      -> RecentNearbyObservationsOptions)
-> Parser RecentNearbyObservationsOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser
  (RecentNearbyObservationsOptions
   -> RecentNearbyObservationsOptions)
forall a. Parser (a -> a)
helper

-- | Parse the options for a @recent-nearby-species-observations@ command.
recentNearbySpeciesObservationsOptions :: Parser RecentNearbySpeciesObservationsOptions
recentNearbySpeciesObservationsOptions :: Parser RecentNearbySpeciesObservationsOptions
recentNearbySpeciesObservationsOptions =
        SpeciesCode
-> Double
-> Double
-> Maybe Integer
-> Maybe Integer
-> Maybe TaxonomyCategories
-> Maybe Bool
-> Maybe Bool
-> Maybe Integer
-> Maybe SortObservationsBy
-> Maybe SPPLocale
-> RecentNearbySpeciesObservationsOptions
RecentNearbySpeciesObservationsOptions
    (SpeciesCode
 -> Double
 -> Double
 -> Maybe Integer
 -> Maybe Integer
 -> Maybe TaxonomyCategories
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Integer
 -> Maybe SortObservationsBy
 -> Maybe SPPLocale
 -> RecentNearbySpeciesObservationsOptions)
-> Parser SpeciesCode
-> Parser
     (Double
      -> Double
      -> Maybe Integer
      -> Maybe Integer
      -> Maybe TaxonomyCategories
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SortObservationsBy
      -> Maybe SPPLocale
      -> RecentNearbySpeciesObservationsOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> Parser SpeciesCode
speciesCodeOpt String
"observations"
    Parser
  (Double
   -> Double
   -> Maybe Integer
   -> Maybe Integer
   -> Maybe TaxonomyCategories
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SortObservationsBy
   -> Maybe SPPLocale
   -> RecentNearbySpeciesObservationsOptions)
-> Parser Double
-> Parser
     (Double
      -> Maybe Integer
      -> Maybe Integer
      -> Maybe TaxonomyCategories
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SortObservationsBy
      -> Maybe SPPLocale
      -> RecentNearbySpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> String -> String -> Parser Double
latLngOpt String
"latitude" String
"observations"
    Parser
  (Double
   -> Maybe Integer
   -> Maybe Integer
   -> Maybe TaxonomyCategories
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SortObservationsBy
   -> Maybe SPPLocale
   -> RecentNearbySpeciesObservationsOptions)
-> Parser Double
-> Parser
     (Maybe Integer
      -> Maybe Integer
      -> Maybe TaxonomyCategories
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SortObservationsBy
      -> Maybe SPPLocale
      -> RecentNearbySpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> String -> String -> Parser Double
latLngOpt String
"longitude" String
"observations"
    Parser
  (Maybe Integer
   -> Maybe Integer
   -> Maybe TaxonomyCategories
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SortObservationsBy
   -> Maybe SPPLocale
   -> RecentNearbySpeciesObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe Integer
      -> Maybe TaxonomyCategories
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SortObservationsBy
      -> Maybe SPPLocale
      -> RecentNearbySpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Integer -> Maybe Integer -> Parser Integer
searchRadiusOpt String
"observations" Integer
50 (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
25))
    Parser
  (Maybe Integer
   -> Maybe TaxonomyCategories
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SortObservationsBy
   -> Maybe SPPLocale
   -> RecentNearbySpeciesObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe TaxonomyCategories
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SortObservationsBy
      -> Maybe SPPLocale
      -> RecentNearbySpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> String -> Maybe Integer -> Parser Integer
backOpt String
"observations" String
"submitted" (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
14))
    Parser
  (Maybe TaxonomyCategories
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SortObservationsBy
   -> Maybe SPPLocale
   -> RecentNearbySpeciesObservationsOptions)
-> Parser (Maybe TaxonomyCategories)
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SortObservationsBy
      -> Maybe SPPLocale
      -> RecentNearbySpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TaxonomyCategories -> Parser (Maybe TaxonomyCategories)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Parser TaxonomyCategories
taxonomyCategoriesOpt String
"observations of")
    Parser
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SortObservationsBy
   -> Maybe SPPLocale
   -> RecentNearbySpeciesObservationsOptions)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Maybe Integer
      -> Maybe SortObservationsBy
      -> Maybe SPPLocale
      -> RecentNearbySpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Bool
observationOnlyHotspotsOpt
    Parser
  (Maybe Bool
   -> Maybe Integer
   -> Maybe SortObservationsBy
   -> Maybe SPPLocale
   -> RecentNearbySpeciesObservationsOptions)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Integer
      -> Maybe SortObservationsBy
      -> Maybe SPPLocale
      -> RecentNearbySpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Bool
observationIncludeProvisionalOpt
    Parser
  (Maybe Integer
   -> Maybe SortObservationsBy
   -> Maybe SPPLocale
   -> RecentNearbySpeciesObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe SortObservationsBy
      -> Maybe SPPLocale -> RecentNearbySpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Integer
observationMaxResultsOpt
    Parser
  (Maybe SortObservationsBy
   -> Maybe SPPLocale -> RecentNearbySpeciesObservationsOptions)
-> Parser (Maybe SortObservationsBy)
-> Parser
     (Maybe SPPLocale -> RecentNearbySpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SortObservationsBy -> Parser (Maybe SortObservationsBy)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser SortObservationsBy
observationSortByOpt
    Parser (Maybe SPPLocale -> RecentNearbySpeciesObservationsOptions)
-> Parser (Maybe SPPLocale)
-> Parser RecentNearbySpeciesObservationsOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SPPLocale -> Parser (Maybe SPPLocale)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Parser SPPLocale
sppLocaleOpt String
"common")
    Parser RecentNearbySpeciesObservationsOptions
-> Parser
     (RecentNearbySpeciesObservationsOptions
      -> RecentNearbySpeciesObservationsOptions)
-> Parser RecentNearbySpeciesObservationsOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser
  (RecentNearbySpeciesObservationsOptions
   -> RecentNearbySpeciesObservationsOptions)
forall a. Parser (a -> a)
helper

-- | Parse the options for a @recent-nearest-species-observations@ command.
recentNearestSpeciesObservationsOptions :: Parser RecentNearestSpeciesObservationsOptions
recentNearestSpeciesObservationsOptions :: Parser RecentNearestSpeciesObservationsOptions
recentNearestSpeciesObservationsOptions =
        SpeciesCode
-> Double
-> Double
-> Maybe Integer
-> Maybe Integer
-> Maybe Bool
-> Maybe Bool
-> Maybe Integer
-> Maybe SPPLocale
-> RecentNearestSpeciesObservationsOptions
RecentNearestSpeciesObservationsOptions
    (SpeciesCode
 -> Double
 -> Double
 -> Maybe Integer
 -> Maybe Integer
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Integer
 -> Maybe SPPLocale
 -> RecentNearestSpeciesObservationsOptions)
-> Parser SpeciesCode
-> Parser
     (Double
      -> Double
      -> Maybe Integer
      -> Maybe Integer
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SPPLocale
      -> RecentNearestSpeciesObservationsOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> Parser SpeciesCode
speciesCodeOpt String
"observations"
    Parser
  (Double
   -> Double
   -> Maybe Integer
   -> Maybe Integer
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SPPLocale
   -> RecentNearestSpeciesObservationsOptions)
-> Parser Double
-> Parser
     (Double
      -> Maybe Integer
      -> Maybe Integer
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SPPLocale
      -> RecentNearestSpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> String -> String -> Parser Double
latLngOpt String
"latitude" String
"observations"
    Parser
  (Double
   -> Maybe Integer
   -> Maybe Integer
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SPPLocale
   -> RecentNearestSpeciesObservationsOptions)
-> Parser Double
-> Parser
     (Maybe Integer
      -> Maybe Integer
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SPPLocale
      -> RecentNearestSpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> String -> String -> Parser Double
latLngOpt String
"longitude" String
"observations"
    Parser
  (Maybe Integer
   -> Maybe Integer
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SPPLocale
   -> RecentNearestSpeciesObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe Integer
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SPPLocale
      -> RecentNearestSpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Integer -> Maybe Integer -> Parser Integer
searchRadiusOpt String
"observations" Integer
50 Maybe Integer
forall a. Maybe a
Nothing)
    Parser
  (Maybe Integer
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SPPLocale
   -> RecentNearestSpeciesObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SPPLocale
      -> RecentNearestSpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> String -> Maybe Integer -> Parser Integer
backOpt String
"observations" String
"submitted" (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
14))
    Parser
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SPPLocale
   -> RecentNearestSpeciesObservationsOptions)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Maybe Integer
      -> Maybe SPPLocale
      -> RecentNearestSpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Bool
observationOnlyHotspotsOpt
    Parser
  (Maybe Bool
   -> Maybe Integer
   -> Maybe SPPLocale
   -> RecentNearestSpeciesObservationsOptions)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Integer
      -> Maybe SPPLocale -> RecentNearestSpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Bool
observationIncludeProvisionalOpt
    Parser
  (Maybe Integer
   -> Maybe SPPLocale -> RecentNearestSpeciesObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe SPPLocale -> RecentNearestSpeciesObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Integer
observationMaxResultsOpt
    Parser (Maybe SPPLocale -> RecentNearestSpeciesObservationsOptions)
-> Parser (Maybe SPPLocale)
-> Parser RecentNearestSpeciesObservationsOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SPPLocale -> Parser (Maybe SPPLocale)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Parser SPPLocale
sppLocaleOpt String
"common")
    Parser RecentNearestSpeciesObservationsOptions
-> Parser
     (RecentNearestSpeciesObservationsOptions
      -> RecentNearestSpeciesObservationsOptions)
-> Parser RecentNearestSpeciesObservationsOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser
  (RecentNearestSpeciesObservationsOptions
   -> RecentNearestSpeciesObservationsOptions)
forall a. Parser (a -> a)
helper

-- | Parse the options for a @recent-nearest-species-observations@ command.
recentNearbyNotableObservationsOptions :: Parser RecentNearbyNotableObservationsOptions
recentNearbyNotableObservationsOptions :: Parser RecentNearbyNotableObservationsOptions
recentNearbyNotableObservationsOptions =
        Double
-> Double
-> Maybe Integer
-> Maybe DetailLevel
-> Maybe Integer
-> Maybe Bool
-> Maybe Integer
-> Maybe SPPLocale
-> RecentNearbyNotableObservationsOptions
RecentNearbyNotableObservationsOptions
    (Double
 -> Double
 -> Maybe Integer
 -> Maybe DetailLevel
 -> Maybe Integer
 -> Maybe Bool
 -> Maybe Integer
 -> Maybe SPPLocale
 -> RecentNearbyNotableObservationsOptions)
-> Parser Double
-> Parser
     (Double
      -> Maybe Integer
      -> Maybe DetailLevel
      -> Maybe Integer
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SPPLocale
      -> RecentNearbyNotableObservationsOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> String -> Parser Double
latLngOpt String
"latitude" String
"observations"
    Parser
  (Double
   -> Maybe Integer
   -> Maybe DetailLevel
   -> Maybe Integer
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SPPLocale
   -> RecentNearbyNotableObservationsOptions)
-> Parser Double
-> Parser
     (Maybe Integer
      -> Maybe DetailLevel
      -> Maybe Integer
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SPPLocale
      -> RecentNearbyNotableObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> String -> String -> Parser Double
latLngOpt String
"longitude" String
"observations"
    Parser
  (Maybe Integer
   -> Maybe DetailLevel
   -> Maybe Integer
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SPPLocale
   -> RecentNearbyNotableObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe DetailLevel
      -> Maybe Integer
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SPPLocale
      -> RecentNearbyNotableObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Integer -> Maybe Integer -> Parser Integer
searchRadiusOpt String
"observations" Integer
50 (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
25))
    Parser
  (Maybe DetailLevel
   -> Maybe Integer
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SPPLocale
   -> RecentNearbyNotableObservationsOptions)
-> Parser (Maybe DetailLevel)
-> Parser
     (Maybe Integer
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SPPLocale
      -> RecentNearbyNotableObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser DetailLevel -> Parser (Maybe DetailLevel)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser DetailLevel
observationDetailLevelOpt
    Parser
  (Maybe Integer
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SPPLocale
   -> RecentNearbyNotableObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe Bool
      -> Maybe Integer
      -> Maybe SPPLocale
      -> RecentNearbyNotableObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> String -> Maybe Integer -> Parser Integer
backOpt String
"observations" String
"submitted" (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
14))
    Parser
  (Maybe Bool
   -> Maybe Integer
   -> Maybe SPPLocale
   -> RecentNearbyNotableObservationsOptions)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Integer
      -> Maybe SPPLocale -> RecentNearbyNotableObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Bool
observationOnlyHotspotsOpt
    Parser
  (Maybe Integer
   -> Maybe SPPLocale -> RecentNearbyNotableObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe SPPLocale -> RecentNearbyNotableObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Integer
observationMaxResultsOpt
    Parser (Maybe SPPLocale -> RecentNearbyNotableObservationsOptions)
-> Parser (Maybe SPPLocale)
-> Parser RecentNearbyNotableObservationsOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SPPLocale -> Parser (Maybe SPPLocale)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Parser SPPLocale
sppLocaleOpt String
"common")
    Parser RecentNearbyNotableObservationsOptions
-> Parser
     (RecentNearbyNotableObservationsOptions
      -> RecentNearbyNotableObservationsOptions)
-> Parser RecentNearbyNotableObservationsOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser
  (RecentNearbyNotableObservationsOptions
   -> RecentNearbyNotableObservationsOptions)
forall a. Parser (a -> a)
helper

-- | Parse the options for a @historical-observations@ command.
historicalObservationsOptions :: Parser HistoricalObservationsOptions
historicalObservationsOptions :: Parser HistoricalObservationsOptions
historicalObservationsOptions =
        RegionCode
-> EBirdDate
-> Maybe TaxonomyCategories
-> Maybe DetailLevel
-> Maybe Bool
-> Maybe Bool
-> Maybe Integer
-> Maybe SelectObservation
-> Maybe RegionCode
-> Maybe SPPLocale
-> HistoricalObservationsOptions
HistoricalObservationsOptions
    (RegionCode
 -> EBirdDate
 -> Maybe TaxonomyCategories
 -> Maybe DetailLevel
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Integer
 -> Maybe SelectObservation
 -> Maybe RegionCode
 -> Maybe SPPLocale
 -> HistoricalObservationsOptions)
-> Parser RegionCode
-> Parser
     (EBirdDate
      -> Maybe TaxonomyCategories
      -> Maybe DetailLevel
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SelectObservation
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> HistoricalObservationsOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> Parser RegionCode
regionCodeOpt String
"observations"
    Parser
  (EBirdDate
   -> Maybe TaxonomyCategories
   -> Maybe DetailLevel
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SelectObservation
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> HistoricalObservationsOptions)
-> Parser EBirdDate
-> Parser
     (Maybe TaxonomyCategories
      -> Maybe DetailLevel
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SelectObservation
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> HistoricalObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser EBirdDate
dateOpt
    Parser
  (Maybe TaxonomyCategories
   -> Maybe DetailLevel
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SelectObservation
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> HistoricalObservationsOptions)
-> Parser (Maybe TaxonomyCategories)
-> Parser
     (Maybe DetailLevel
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SelectObservation
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> HistoricalObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TaxonomyCategories -> Parser (Maybe TaxonomyCategories)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Parser TaxonomyCategories
taxonomyCategoriesOpt String
"observations of")
    Parser
  (Maybe DetailLevel
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SelectObservation
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> HistoricalObservationsOptions)
-> Parser (Maybe DetailLevel)
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Integer
      -> Maybe SelectObservation
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> HistoricalObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser DetailLevel -> Parser (Maybe DetailLevel)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser DetailLevel
observationDetailLevelOpt
    Parser
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Integer
   -> Maybe SelectObservation
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> HistoricalObservationsOptions)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Maybe Integer
      -> Maybe SelectObservation
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> HistoricalObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Bool
observationOnlyHotspotsOpt
    Parser
  (Maybe Bool
   -> Maybe Integer
   -> Maybe SelectObservation
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> HistoricalObservationsOptions)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Integer
      -> Maybe SelectObservation
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> HistoricalObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Bool
observationIncludeProvisionalOpt
    Parser
  (Maybe Integer
   -> Maybe SelectObservation
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> HistoricalObservationsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe SelectObservation
      -> Maybe RegionCode
      -> Maybe SPPLocale
      -> HistoricalObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Integer
observationMaxResultsOpt
    Parser
  (Maybe SelectObservation
   -> Maybe RegionCode
   -> Maybe SPPLocale
   -> HistoricalObservationsOptions)
-> Parser (Maybe SelectObservation)
-> Parser
     (Maybe RegionCode
      -> Maybe SPPLocale -> HistoricalObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SelectObservation -> Parser (Maybe SelectObservation)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser SelectObservation
rankOpt
    Parser
  (Maybe RegionCode
   -> Maybe SPPLocale -> HistoricalObservationsOptions)
-> Parser (Maybe RegionCode)
-> Parser (Maybe SPPLocale -> HistoricalObservationsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser RegionCode -> Parser (Maybe RegionCode)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser RegionCode
extraRegionsOpt
    Parser (Maybe SPPLocale -> HistoricalObservationsOptions)
-> Parser (Maybe SPPLocale) -> Parser HistoricalObservationsOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SPPLocale -> Parser (Maybe SPPLocale)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Parser SPPLocale
sppLocaleOpt String
"common")
    Parser HistoricalObservationsOptions
-> Parser
     (HistoricalObservationsOptions -> HistoricalObservationsOptions)
-> Parser HistoricalObservationsOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser
  (HistoricalObservationsOptions -> HistoricalObservationsOptions)
forall a. Parser (a -> a)
helper
  where
    dateOpt :: Parser EBirdDate
    dateOpt :: Parser EBirdDate
dateOpt =
      ReadM EBirdDate -> Mod OptionFields EBirdDate -> Parser EBirdDate
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser EBirdDate -> ReadM EBirdDate
forall a. Parser a -> ReadM a
attoReadM Parser EBirdDate
parseEBirdDate)
        (    String -> Mod OptionFields EBirdDate
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"date"
          Mod OptionFields EBirdDate
-> Mod OptionFields EBirdDate -> Mod OptionFields EBirdDate
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields EBirdDate
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"YYYY-MM-DD"
          Mod OptionFields EBirdDate
-> Mod OptionFields EBirdDate -> Mod OptionFields EBirdDate
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields EBirdDate
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the date to fetch observations from (year " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"1800 to present)"
                  )
        )

    rankOpt :: Parser SelectObservation
    rankOpt :: Parser SelectObservation
rankOpt =
      ReadM SelectObservation
-> Mod OptionFields SelectObservation -> Parser SelectObservation
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser SelectObservation -> ReadM SelectObservation
forall a. Parser a -> ReadM a
attoReadM Parser SelectObservation
parseSelectObservation)
        (    String -> Mod OptionFields SelectObservation
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"select"
          Mod OptionFields SelectObservation
-> Mod OptionFields SelectObservation
-> Mod OptionFields SelectObservation
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields SelectObservation
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"SELECT"
          Mod OptionFields SelectObservation
-> Mod OptionFields SelectObservation
-> Mod OptionFields SelectObservation
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields SelectObservation
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify whether to select the first or last " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"observation of a species if there are multiple " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"(\"first\" or \"last\") (default: last)"
                  )
        )

-- | Parse a 'GHC.Types.Bool', intended to be used as an option determining whether to
-- include observations from hotspots in the response.
observationOnlyHotspotsOpt :: Parser Bool
observationOnlyHotspotsOpt :: Parser Bool
observationOnlyHotspotsOpt =
    Mod FlagFields Bool -> Parser Bool
switch
      (    String -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"only-hotspots"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Bool
forall (f :: * -> *) a. String -> Mod f a
help String
"Only include observations from hotspots"
      )

-- | Parse a 'GHC.Types.Bool', intended to be used as an option determining whether to
-- include unreviewed observations in the response.
observationIncludeProvisionalOpt :: Parser Bool
observationIncludeProvisionalOpt :: Parser Bool
observationIncludeProvisionalOpt =
    Mod FlagFields Bool -> Parser Bool
switch
      (    String -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"include-provisional"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Bool
forall (f :: * -> *) a. String -> Mod f a
help String
"Include observations which have not yet been reviewed"
      )

-- | Parse a 'Integer' option indicating the number of results to include in the
-- response.
observationMaxResultsOpt :: Parser Integer
observationMaxResultsOpt :: Parser Integer
observationMaxResultsOpt =
    ReadM Integer -> Mod OptionFields Integer -> Parser Integer
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser Integer -> ReadM Integer
forall a. Parser a -> ReadM a
attoReadM Parser Integer
forall a. Integral a => Parser a
A.decimal)
      (    String -> Mod OptionFields Integer
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"max-results"
        Mod OptionFields Integer
-> Mod OptionFields Integer -> Mod OptionFields Integer
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Integer
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"N"
        Mod OptionFields Integer
-> Mod OptionFields Integer -> Mod OptionFields Integer
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Integer
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the max number of observations to include " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                  String
"(1 to 10000, default: all)"
                )
      )

-- | Parse a 'RegionCode' as a generic command option, intended for use with the
-- observation commands.
regionCodeOpt
  :: String
  -- ^ What are we fetching? (e.g. "observations")
  -> Parser RegionCode
regionCodeOpt :: String -> Parser RegionCode
regionCodeOpt String
thing =
    ReadM RegionCode
-> Mod OptionFields RegionCode -> Parser RegionCode
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser RegionCode -> ReadM RegionCode
forall a. Parser a -> ReadM a
attoReadM Parser RegionCode
parseRegionCode)
      (    String -> Mod OptionFields RegionCode
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"region"
        Mod OptionFields RegionCode
-> Mod OptionFields RegionCode -> Mod OptionFields RegionCode
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields RegionCode
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"REGION_CODE"
        Mod OptionFields RegionCode
-> Mod OptionFields RegionCode -> Mod OptionFields RegionCode
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields RegionCode
forall (f :: * -> *) a. String -> Mod f a
help String
helpStr
      )
  where
    helpStr :: String
    helpStr :: String
helpStr =
      String -> String -> String
forall r. PrintfType r => String -> r
printf
        ( String
"Specify the regions to fetch %s from " String -> String -> String
forall a. [a] -> [a] -> [a]
++
          String
"(e.g. \"US-WY,US-CO,US-ID\" or \"US-CA-037\")"
        )
        String
thing

-- | Configurable 'TaxonomyCategories' parser
taxonomyCategoriesOpt
  :: String
  -- ^ String to include after "one or more taxonomy categories to include ..."
  -> Parser TaxonomyCategories
taxonomyCategoriesOpt :: String -> Parser TaxonomyCategories
taxonomyCategoriesOpt String
desc =
    ReadM TaxonomyCategories
-> Mod OptionFields TaxonomyCategories -> Parser TaxonomyCategories
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser TaxonomyCategories -> ReadM TaxonomyCategories
forall a. Parser a -> ReadM a
attoReadM Parser TaxonomyCategories
parseTaxonomyCategories)
      (    String -> Mod OptionFields TaxonomyCategories
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"taxonomy-categories"
        Mod OptionFields TaxonomyCategories
-> Mod OptionFields TaxonomyCategories
-> Mod OptionFields TaxonomyCategories
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields TaxonomyCategories
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"CATEGORIES"
        Mod OptionFields TaxonomyCategories
-> Mod OptionFields TaxonomyCategories
-> Mod OptionFields TaxonomyCategories
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields TaxonomyCategories
forall (f :: * -> *) a. String -> Mod f a
help String
helpStr
      )
  where
    helpStr :: String
    helpStr :: String
helpStr =
      String -> String -> String
forall r. PrintfType r => String -> r
printf
        ( String
"Specify a list of one or more taxonomy categories to include " String -> String -> String
forall a. [a] -> [a] -> [a]
++
          String
"%s (e.g. \"issf\" or \"hybrid\") (default: all categories)"
        )
        String
desc

-- | Parse a 'SortObservationsBy' as an option determining how returned
-- observations will be sorted.
observationSortByOpt :: Parser SortObservationsBy
observationSortByOpt :: Parser SortObservationsBy
observationSortByOpt =
    ReadM SortObservationsBy
-> Mod OptionFields SortObservationsBy -> Parser SortObservationsBy
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser SortObservationsBy -> ReadM SortObservationsBy
forall a. Parser a -> ReadM a
attoReadM Parser SortObservationsBy
parseSortObservationsBy)
      (    String -> Mod OptionFields SortObservationsBy
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"sort-by"
        Mod OptionFields SortObservationsBy
-> Mod OptionFields SortObservationsBy
-> Mod OptionFields SortObservationsBy
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields SortObservationsBy
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"SORT_BY"
        Mod OptionFields SortObservationsBy
-> Mod OptionFields SortObservationsBy
-> Mod OptionFields SortObservationsBy
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields SortObservationsBy
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the ordering to use for the resulting " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                  String
"observations (\"date\" or \"species\") (default: date, " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                  String
"earliest first)"
                )
      )

-- | Parse a 'DetailLevel' as an option determining the detail level of
-- observations in the result.
observationDetailLevelOpt :: Parser DetailLevel
observationDetailLevelOpt :: Parser DetailLevel
observationDetailLevelOpt =
    ReadM DetailLevel
-> Mod OptionFields DetailLevel -> Parser DetailLevel
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser DetailLevel -> ReadM DetailLevel
forall a. Parser a -> ReadM a
attoReadM Parser DetailLevel
parseDetailLevel)
      (    String -> Mod OptionFields DetailLevel
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"detail"
        Mod OptionFields DetailLevel
-> Mod OptionFields DetailLevel -> Mod OptionFields DetailLevel
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields DetailLevel
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"DETAIL_LEVEL"
        Mod OptionFields DetailLevel
-> Mod OptionFields DetailLevel -> Mod OptionFields DetailLevel
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields DetailLevel
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the detail level of the returned observations " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                  String
"(\"simple\" or \"full\") (default: simple)"
                )
      )

-- | Parse a 'RegionCode' as extra regions to fetch observations from
extraRegionsOpt :: Parser RegionCode
extraRegionsOpt :: Parser RegionCode
extraRegionsOpt =
  ReadM RegionCode
-> Mod OptionFields RegionCode -> Parser RegionCode
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser RegionCode -> ReadM RegionCode
forall a. Parser a -> ReadM a
attoReadM Parser RegionCode
parseRegionCode)
    (    String -> Mod OptionFields RegionCode
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"extra-regions"
      Mod OptionFields RegionCode
-> Mod OptionFields RegionCode -> Mod OptionFields RegionCode
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields RegionCode
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"REGION_CODE"
      Mod OptionFields RegionCode
-> Mod OptionFields RegionCode -> Mod OptionFields RegionCode
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields RegionCode
forall (f :: * -> *) a. String -> Mod f a
help String
"Up to 10 extra regions to fetch observations from"
    )

-------------------------------------------------------------------------------
-- Parsers for product command options
-------------------------------------------------------------------------------

-- | Parse the options for a @recent-checklists@ command.
recentChecklistsOptions :: Parser RecentChecklistsOptions
recentChecklistsOptions :: Parser RecentChecklistsOptions
recentChecklistsOptions =
        RegionCode -> Maybe Integer -> RecentChecklistsOptions
RecentChecklistsOptions
    (RegionCode -> Maybe Integer -> RecentChecklistsOptions)
-> Parser RegionCode
-> Parser (Maybe Integer -> RecentChecklistsOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser RegionCode
checklistRegionCodeOpt
    Parser (Maybe Integer -> RecentChecklistsOptions)
-> Parser (Maybe Integer) -> Parser RecentChecklistsOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Integer
checklistMaxResultsOpt
    Parser RecentChecklistsOptions
-> Parser (RecentChecklistsOptions -> RecentChecklistsOptions)
-> Parser RecentChecklistsOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (RecentChecklistsOptions -> RecentChecklistsOptions)
forall a. Parser (a -> a)
helper

-- | Parse the options for a @top-100@ command.
top100Options :: Parser Top100Options
top100Options :: Parser Top100Options
top100Options =
        Region
-> EBirdDate
-> Maybe RankTop100By
-> Maybe Integer
-> Top100Options
Top100Options
    (Region
 -> EBirdDate
 -> Maybe RankTop100By
 -> Maybe Integer
 -> Top100Options)
-> Parser Region
-> Parser
     (EBirdDate -> Maybe RankTop100By -> Maybe Integer -> Top100Options)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Region
regionOpt
    Parser
  (EBirdDate -> Maybe RankTop100By -> Maybe Integer -> Top100Options)
-> Parser EBirdDate
-> Parser (Maybe RankTop100By -> Maybe Integer -> Top100Options)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser EBirdDate
dateOpt
    Parser (Maybe RankTop100By -> Maybe Integer -> Top100Options)
-> Parser (Maybe RankTop100By)
-> Parser (Maybe Integer -> Top100Options)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser RankTop100By -> Parser (Maybe RankTop100By)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser RankTop100By
rankedByOpt
    Parser (Maybe Integer -> Top100Options)
-> Parser (Maybe Integer) -> Parser Top100Options
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Integer
maxResultsOpt
    Parser Top100Options
-> Parser (Top100Options -> Top100Options) -> Parser Top100Options
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (Top100Options -> Top100Options)
forall a. Parser (a -> a)
helper
  where
    regionOpt :: Parser Region
    regionOpt :: Parser Region
regionOpt =
      ReadM Region -> Mod OptionFields Region -> Parser Region
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser Region -> ReadM Region
forall a. Parser a -> ReadM a
attoReadM Parser Region
parseRegion)
        (    String -> Mod OptionFields Region
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"region"
          Mod OptionFields Region
-> Mod OptionFields Region -> Mod OptionFields Region
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Region
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"REGION"
          Mod OptionFields Region
-> Mod OptionFields Region -> Mod OptionFields Region
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Region
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the region to fetch the top 100 contributors " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"for (e.g. \"US-WY\" or \"US-CA-037\")"
                  )
        )

    dateOpt :: Parser EBirdDate
    dateOpt :: Parser EBirdDate
dateOpt =
      ReadM EBirdDate -> Mod OptionFields EBirdDate -> Parser EBirdDate
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser EBirdDate -> ReadM EBirdDate
forall a. Parser a -> ReadM a
attoReadM Parser EBirdDate
parseEBirdDate)
        (    String -> Mod OptionFields EBirdDate
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"date"
          Mod OptionFields EBirdDate
-> Mod OptionFields EBirdDate -> Mod OptionFields EBirdDate
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields EBirdDate
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"YYYY-MM-DD"
          Mod OptionFields EBirdDate
-> Mod OptionFields EBirdDate -> Mod OptionFields EBirdDate
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields EBirdDate
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the date to fetch the top contributors on " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"(year 1800 to present)"
                  )
        )

    rankedByOpt :: Parser RankTop100By
    rankedByOpt :: Parser RankTop100By
rankedByOpt =
      ReadM RankTop100By
-> Mod OptionFields RankTop100By -> Parser RankTop100By
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser RankTop100By -> ReadM RankTop100By
forall a. Parser a -> ReadM a
attoReadM Parser RankTop100By
parseRankTop100By)
        (    String -> Mod OptionFields RankTop100By
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"rank-by"
          Mod OptionFields RankTop100By
-> Mod OptionFields RankTop100By -> Mod OptionFields RankTop100By
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields RankTop100By
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"RANK_BY"
          Mod OptionFields RankTop100By
-> Mod OptionFields RankTop100By -> Mod OptionFields RankTop100By
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields RankTop100By
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify whether to rank contributors by number of " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"species observed (\"spp\") or number of checklists " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"completed (\"cl\") (default: spp)"
                  )
        )

    maxResultsOpt :: Parser Integer
    maxResultsOpt :: Parser Integer
maxResultsOpt =
      ReadM Integer -> Mod OptionFields Integer -> Parser Integer
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser Integer -> ReadM Integer
forall a. Parser a -> ReadM a
attoReadM Parser Integer
forall a. Integral a => Parser a
A.decimal)
        (    String -> Mod OptionFields Integer
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"max-results"
          Mod OptionFields Integer
-> Mod OptionFields Integer -> Mod OptionFields Integer
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Integer
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"N"
          Mod OptionFields Integer
-> Mod OptionFields Integer -> Mod OptionFields Integer
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Integer
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the max number of contributors to include " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"(1 to 100, default: 100)"
                  )
        )

-- | Parse the options for a @top-100@ command.
checklistFeedOptions :: Parser ChecklistFeedOptions
checklistFeedOptions :: Parser ChecklistFeedOptions
checklistFeedOptions =
        Region
-> EBirdDate
-> Maybe SortChecklistsBy
-> Maybe Integer
-> ChecklistFeedOptions
ChecklistFeedOptions
    (Region
 -> EBirdDate
 -> Maybe SortChecklistsBy
 -> Maybe Integer
 -> ChecklistFeedOptions)
-> Parser Region
-> Parser
     (EBirdDate
      -> Maybe SortChecklistsBy -> Maybe Integer -> ChecklistFeedOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Region
regionOpt
    Parser
  (EBirdDate
   -> Maybe SortChecklistsBy -> Maybe Integer -> ChecklistFeedOptions)
-> Parser EBirdDate
-> Parser
     (Maybe SortChecklistsBy -> Maybe Integer -> ChecklistFeedOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser EBirdDate
dateOpt
    Parser
  (Maybe SortChecklistsBy -> Maybe Integer -> ChecklistFeedOptions)
-> Parser (Maybe SortChecklistsBy)
-> Parser (Maybe Integer -> ChecklistFeedOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SortChecklistsBy -> Parser (Maybe SortChecklistsBy)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser SortChecklistsBy
sortByOpt
    Parser (Maybe Integer -> ChecklistFeedOptions)
-> Parser (Maybe Integer) -> Parser ChecklistFeedOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Integer
maxResultsOpt
    Parser ChecklistFeedOptions
-> Parser (ChecklistFeedOptions -> ChecklistFeedOptions)
-> Parser ChecklistFeedOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (ChecklistFeedOptions -> ChecklistFeedOptions)
forall a. Parser (a -> a)
helper
  where
    regionOpt :: Parser Region
    regionOpt :: Parser Region
regionOpt =
      ReadM Region -> Mod OptionFields Region -> Parser Region
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser Region -> ReadM Region
forall a. Parser a -> ReadM a
attoReadM Parser Region
parseRegion)
        (    String -> Mod OptionFields Region
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"region"
          Mod OptionFields Region
-> Mod OptionFields Region -> Mod OptionFields Region
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Region
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"REGION"
          Mod OptionFields Region
-> Mod OptionFields Region -> Mod OptionFields Region
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Region
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the region to fetch the checklist feed " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"for (e.g. \"US-WY\" or \"US-CA-037\")"
                  )
        )

    dateOpt :: Parser EBirdDate
    dateOpt :: Parser EBirdDate
dateOpt =
      ReadM EBirdDate -> Mod OptionFields EBirdDate -> Parser EBirdDate
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser EBirdDate -> ReadM EBirdDate
forall a. Parser a -> ReadM a
attoReadM Parser EBirdDate
parseEBirdDate)
        (    String -> Mod OptionFields EBirdDate
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"date"
          Mod OptionFields EBirdDate
-> Mod OptionFields EBirdDate -> Mod OptionFields EBirdDate
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields EBirdDate
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"YYYY-MM-DD"
          Mod OptionFields EBirdDate
-> Mod OptionFields EBirdDate -> Mod OptionFields EBirdDate
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields EBirdDate
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the date to fetch the checklist feed on " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"(year 1800 to present)"
                  )
        )

    sortByOpt :: Parser SortChecklistsBy
    sortByOpt :: Parser SortChecklistsBy
sortByOpt =
      ReadM SortChecklistsBy
-> Mod OptionFields SortChecklistsBy -> Parser SortChecklistsBy
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser SortChecklistsBy -> ReadM SortChecklistsBy
forall a. Parser a -> ReadM a
attoReadM Parser SortChecklistsBy
parseSortChecklistsBy)
        (    String -> Mod OptionFields SortChecklistsBy
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"sort-by"
          Mod OptionFields SortChecklistsBy
-> Mod OptionFields SortChecklistsBy
-> Mod OptionFields SortChecklistsBy
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields SortChecklistsBy
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"SORT_BY"
          Mod OptionFields SortChecklistsBy
-> Mod OptionFields SortChecklistsBy
-> Mod OptionFields SortChecklistsBy
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields SortChecklistsBy
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify whether to sort the checklist fee by date of " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"creation (\"obs_dt\") or date of submission " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"(\"creation_dt\") (default: obs_dt)"
                  )
        )

    maxResultsOpt :: Parser Integer
    maxResultsOpt :: Parser Integer
maxResultsOpt =
      ReadM Integer -> Mod OptionFields Integer -> Parser Integer
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser Integer -> ReadM Integer
forall a. Parser a -> ReadM a
attoReadM Parser Integer
forall a. Integral a => Parser a
A.decimal)
        (    String -> Mod OptionFields Integer
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"max-results"
          Mod OptionFields Integer
-> Mod OptionFields Integer -> Mod OptionFields Integer
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Integer
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"N"
          Mod OptionFields Integer
-> Mod OptionFields Integer -> Mod OptionFields Integer
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Integer
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the max number of checklists to include " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"(1 to 200, default: 10)"
                  )
        )

-- | Parse the options for a @regional-statistics@ command.
regionalStatisticsOptions :: Parser RegionalStatisticsOptions
regionalStatisticsOptions :: Parser RegionalStatisticsOptions
regionalStatisticsOptions =
        Region -> EBirdDate -> RegionalStatisticsOptions
RegionalStatisticsOptions
    (Region -> EBirdDate -> RegionalStatisticsOptions)
-> Parser Region -> Parser (EBirdDate -> RegionalStatisticsOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Region
regionOpt
    Parser (EBirdDate -> RegionalStatisticsOptions)
-> Parser EBirdDate -> Parser RegionalStatisticsOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser EBirdDate
dateOpt
    Parser RegionalStatisticsOptions
-> Parser (RegionalStatisticsOptions -> RegionalStatisticsOptions)
-> Parser RegionalStatisticsOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (RegionalStatisticsOptions -> RegionalStatisticsOptions)
forall a. Parser (a -> a)
helper
  where
    regionOpt :: Parser Region
    regionOpt :: Parser Region
regionOpt =
      ReadM Region -> Mod OptionFields Region -> Parser Region
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser Region -> ReadM Region
forall a. Parser a -> ReadM a
attoReadM Parser Region
parseRegion)
        (    String -> Mod OptionFields Region
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"region"
          Mod OptionFields Region
-> Mod OptionFields Region -> Mod OptionFields Region
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Region
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"REGION"
          Mod OptionFields Region
-> Mod OptionFields Region -> Mod OptionFields Region
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Region
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the region to fetch the statistics for " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"(e.g. \"US-WY\" or \"US-CA-037\")"
                  )
        )

    dateOpt :: Parser EBirdDate
    dateOpt :: Parser EBirdDate
dateOpt =
      ReadM EBirdDate -> Mod OptionFields EBirdDate -> Parser EBirdDate
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser EBirdDate -> ReadM EBirdDate
forall a. Parser a -> ReadM a
attoReadM Parser EBirdDate
parseEBirdDate)
        (    String -> Mod OptionFields EBirdDate
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"date"
          Mod OptionFields EBirdDate
-> Mod OptionFields EBirdDate -> Mod OptionFields EBirdDate
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields EBirdDate
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"YYYY-MM-DD"
          Mod OptionFields EBirdDate
-> Mod OptionFields EBirdDate -> Mod OptionFields EBirdDate
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields EBirdDate
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the date to fetch the statistics on (year " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"1800 to present)"
                  )
        )

-- | Parse the options for a @regional-statistics@ command.
speciesListOptions :: Parser SpeciesListOptions
speciesListOptions :: Parser SpeciesListOptions
speciesListOptions =
        Region -> SpeciesListOptions
SpeciesListOptions
    (Region -> SpeciesListOptions)
-> Parser Region -> Parser SpeciesListOptions
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Region
regionOpt
    Parser SpeciesListOptions
-> Parser (SpeciesListOptions -> SpeciesListOptions)
-> Parser SpeciesListOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (SpeciesListOptions -> SpeciesListOptions)
forall a. Parser (a -> a)
helper
  where
    regionOpt :: Parser Region
    regionOpt :: Parser Region
regionOpt =
      ReadM Region -> Mod OptionFields Region -> Parser Region
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser Region -> ReadM Region
forall a. Parser a -> ReadM a
attoReadM Parser Region
parseRegion)
        (    String -> Mod OptionFields Region
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"region"
          Mod OptionFields Region
-> Mod OptionFields Region -> Mod OptionFields Region
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Region
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"REGION"
          Mod OptionFields Region
-> Mod OptionFields Region -> Mod OptionFields Region
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Region
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the region to fetch the species list for " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"(e.g. \"US-WY\" or \"US-CA-037\")"
                  )
        )

-- | Parse the options for a @regional-statistics@ command.
viewChecklistOptions :: Parser ViewChecklistOptions
viewChecklistOptions :: Parser ViewChecklistOptions
viewChecklistOptions =
        Text -> ViewChecklistOptions
ViewChecklistOptions
    (Text -> ViewChecklistOptions)
-> Parser Text -> Parser ViewChecklistOptions
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
subIdOpt
    Parser ViewChecklistOptions
-> Parser (ViewChecklistOptions -> ViewChecklistOptions)
-> Parser ViewChecklistOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (ViewChecklistOptions -> ViewChecklistOptions)
forall a. Parser (a -> a)
helper
  where
    subIdOpt :: Parser Text
    subIdOpt :: Parser Text
subIdOpt =
      ReadM Text -> Mod OptionFields Text -> Parser Text
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser Text -> ReadM Text
forall a. Parser a -> ReadM a
attoReadM Parser Text
A.takeText)
        (    String -> Mod OptionFields Text
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"submission-id"
          Mod OptionFields Text
-> Mod OptionFields Text -> Mod OptionFields Text
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Text
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"SUBMISSION_ID"
          Mod OptionFields Text
-> Mod OptionFields Text -> Mod OptionFields Text
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Text
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the submission ID of the checklist to view " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"(e.g. \"S144646447\")"
                  )
        )

-- | Parse a 'RegionCode' as a generic command option, intended for use with the
-- checklists commands.
checklistRegionCodeOpt :: Parser RegionCode
checklistRegionCodeOpt :: Parser RegionCode
checklistRegionCodeOpt =
    ReadM RegionCode
-> Mod OptionFields RegionCode -> Parser RegionCode
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser RegionCode -> ReadM RegionCode
forall a. Parser a -> ReadM a
attoReadM Parser RegionCode
parseRegionCode)
      (    String -> Mod OptionFields RegionCode
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"region"
        Mod OptionFields RegionCode
-> Mod OptionFields RegionCode -> Mod OptionFields RegionCode
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields RegionCode
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"REGION_CODE"
        Mod OptionFields RegionCode
-> Mod OptionFields RegionCode -> Mod OptionFields RegionCode
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields RegionCode
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the regions to fetch checklists from " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                  String
"(e.g. \"US-WY,US-CO\" or \"US-CA-037\")"
                )
      )

-- | Parse a 'Integer' as a generic command option, intended for use with the
-- checklists commands for determining max results to include.
checklistMaxResultsOpt :: Parser Integer
checklistMaxResultsOpt :: Parser Integer
checklistMaxResultsOpt =
    ReadM Integer -> Mod OptionFields Integer -> Parser Integer
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser Integer -> ReadM Integer
forall a. Parser a -> ReadM a
attoReadM Parser Integer
forall a. Integral a => Parser a
A.decimal)
      (    String -> Mod OptionFields Integer
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"max-results"
        Mod OptionFields Integer
-> Mod OptionFields Integer -> Mod OptionFields Integer
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Integer
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"N"
        Mod OptionFields Integer
-> Mod OptionFields Integer -> Mod OptionFields Integer
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Integer
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the max number of checklists to include " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                  String
"(1 to 200, default: 10)"
                )
      )

-------------------------------------------------------------------------------
-- Parsers for hotspot command options
-------------------------------------------------------------------------------

-- | Parse the options for a @region-hotspots@ command.
regionHotspotsOptions :: Parser RegionHotspotsOptions
regionHotspotsOptions :: Parser RegionHotspotsOptions
regionHotspotsOptions =
        RegionCode
-> Maybe Integer -> Maybe CSVOrJSONFormat -> RegionHotspotsOptions
RegionHotspotsOptions
    (RegionCode
 -> Maybe Integer -> Maybe CSVOrJSONFormat -> RegionHotspotsOptions)
-> Parser RegionCode
-> Parser
     (Maybe Integer -> Maybe CSVOrJSONFormat -> RegionHotspotsOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> Parser RegionCode
regionCodeOpt String
"hotspots"
    Parser
  (Maybe Integer -> Maybe CSVOrJSONFormat -> RegionHotspotsOptions)
-> Parser (Maybe Integer)
-> Parser (Maybe CSVOrJSONFormat -> RegionHotspotsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> String -> Maybe Integer -> Parser Integer
backOpt String
"hotspots" String
"visited" Maybe Integer
forall a. Maybe a
Nothing)
    Parser (Maybe CSVOrJSONFormat -> RegionHotspotsOptions)
-> Parser (Maybe CSVOrJSONFormat) -> Parser RegionHotspotsOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe CSVOrJSONFormat -> Parser (Maybe CSVOrJSONFormat)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CSVOrJSONFormat -> Maybe CSVOrJSONFormat
forall a. a -> Maybe a
Just CSVOrJSONFormat
JSONFormat)
    Parser RegionHotspotsOptions
-> Parser (RegionHotspotsOptions -> RegionHotspotsOptions)
-> Parser RegionHotspotsOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (RegionHotspotsOptions -> RegionHotspotsOptions)
forall a. Parser (a -> a)
helper

-- | Parse the options for a @nearby-hotspots@ command.
nearbyHotspotsOptions :: Parser NearbyHotspotsOptions
nearbyHotspotsOptions :: Parser NearbyHotspotsOptions
nearbyHotspotsOptions =
        Double
-> Double
-> Maybe Integer
-> Maybe Integer
-> Maybe CSVOrJSONFormat
-> NearbyHotspotsOptions
NearbyHotspotsOptions
    (Double
 -> Double
 -> Maybe Integer
 -> Maybe Integer
 -> Maybe CSVOrJSONFormat
 -> NearbyHotspotsOptions)
-> Parser Double
-> Parser
     (Double
      -> Maybe Integer
      -> Maybe Integer
      -> Maybe CSVOrJSONFormat
      -> NearbyHotspotsOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> String -> Parser Double
latLngOpt String
"latitude" String
"hotspots"
    Parser
  (Double
   -> Maybe Integer
   -> Maybe Integer
   -> Maybe CSVOrJSONFormat
   -> NearbyHotspotsOptions)
-> Parser Double
-> Parser
     (Maybe Integer
      -> Maybe Integer -> Maybe CSVOrJSONFormat -> NearbyHotspotsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> String -> String -> Parser Double
latLngOpt String
"longitude" String
"hotspots"
    Parser
  (Maybe Integer
   -> Maybe Integer -> Maybe CSVOrJSONFormat -> NearbyHotspotsOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe Integer -> Maybe CSVOrJSONFormat -> NearbyHotspotsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> String -> Maybe Integer -> Parser Integer
backOpt String
"hotspots" String
"visited" Maybe Integer
forall a. Maybe a
Nothing)
    Parser
  (Maybe Integer -> Maybe CSVOrJSONFormat -> NearbyHotspotsOptions)
-> Parser (Maybe Integer)
-> Parser (Maybe CSVOrJSONFormat -> NearbyHotspotsOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Integer -> Parser (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Integer -> Maybe Integer -> Parser Integer
searchRadiusOpt String
"hotspots" Integer
50 (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
25))
    Parser (Maybe CSVOrJSONFormat -> NearbyHotspotsOptions)
-> Parser (Maybe CSVOrJSONFormat) -> Parser NearbyHotspotsOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe CSVOrJSONFormat -> Parser (Maybe CSVOrJSONFormat)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CSVOrJSONFormat -> Maybe CSVOrJSONFormat
forall a. a -> Maybe a
Just CSVOrJSONFormat
JSONFormat)
    Parser NearbyHotspotsOptions
-> Parser (NearbyHotspotsOptions -> NearbyHotspotsOptions)
-> Parser NearbyHotspotsOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (NearbyHotspotsOptions -> NearbyHotspotsOptions)
forall a. Parser (a -> a)
helper

-- | Parse the options for a @hotspot-info@ command.
hotspotInfoOptions :: Parser HotspotInfoOptions
hotspotInfoOptions :: Parser HotspotInfoOptions
hotspotInfoOptions =
        Text -> HotspotInfoOptions
HotspotInfoOptions
    (Text -> HotspotInfoOptions)
-> Parser Text -> Parser HotspotInfoOptions
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
locationCodeOpt
    Parser HotspotInfoOptions
-> Parser (HotspotInfoOptions -> HotspotInfoOptions)
-> Parser HotspotInfoOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (HotspotInfoOptions -> HotspotInfoOptions)
forall a. Parser (a -> a)
helper
  where
    locationCodeOpt :: Parser Text
    locationCodeOpt :: Parser Text
locationCodeOpt =
      ReadM Text -> Mod OptionFields Text -> Parser Text
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser Text -> ReadM Text
forall a. Parser a -> ReadM a
attoReadM Parser Text
A.takeText)
        (    String -> Mod OptionFields Text
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"location"
          Mod OptionFields Text
-> Mod OptionFields Text -> Mod OptionFields Text
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Text
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"LOCATION"
          Mod OptionFields Text
-> Mod OptionFields Text -> Mod OptionFields Text
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Text
forall (f :: * -> *) a. String -> Mod f a
help String
"Location code of the hotspot (e.g. \"L5044136\")"
        )
-------------------------------------------------------------------------------
-- Parsers for taxonomy command options
-------------------------------------------------------------------------------

-- | Parse the options for a @nearby-hotspots@ command.
taxonomyOptions :: Parser TaxonomyOptions
taxonomyOptions :: Parser TaxonomyOptions
taxonomyOptions =
        Maybe TaxonomyCategories
-> Maybe CSVOrJSONFormat
-> Maybe SPPLocale
-> Maybe SpeciesCodes
-> Maybe Text
-> TaxonomyOptions
TaxonomyOptions
    (Maybe TaxonomyCategories
 -> Maybe CSVOrJSONFormat
 -> Maybe SPPLocale
 -> Maybe SpeciesCodes
 -> Maybe Text
 -> TaxonomyOptions)
-> Parser (Maybe TaxonomyCategories)
-> Parser
     (Maybe CSVOrJSONFormat
      -> Maybe SPPLocale
      -> Maybe SpeciesCodes
      -> Maybe Text
      -> TaxonomyOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TaxonomyCategories -> Parser (Maybe TaxonomyCategories)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Parser TaxonomyCategories
taxonomyCategoriesOpt String
"in the taxonomy")
    Parser
  (Maybe CSVOrJSONFormat
   -> Maybe SPPLocale
   -> Maybe SpeciesCodes
   -> Maybe Text
   -> TaxonomyOptions)
-> Parser (Maybe CSVOrJSONFormat)
-> Parser
     (Maybe SPPLocale
      -> Maybe SpeciesCodes -> Maybe Text -> TaxonomyOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe CSVOrJSONFormat -> Parser (Maybe CSVOrJSONFormat)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CSVOrJSONFormat -> Maybe CSVOrJSONFormat
forall a. a -> Maybe a
Just CSVOrJSONFormat
JSONFormat)
    Parser
  (Maybe SPPLocale
   -> Maybe SpeciesCodes -> Maybe Text -> TaxonomyOptions)
-> Parser (Maybe SPPLocale)
-> Parser (Maybe SpeciesCodes -> Maybe Text -> TaxonomyOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SPPLocale -> Parser (Maybe SPPLocale)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Parser SPPLocale
sppLocaleOpt String
"common")
    Parser (Maybe SpeciesCodes -> Maybe Text -> TaxonomyOptions)
-> Parser (Maybe SpeciesCodes)
-> Parser (Maybe Text -> TaxonomyOptions)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SpeciesCodes -> Parser (Maybe SpeciesCodes)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser SpeciesCodes
speciesCodesOpt
    Parser (Maybe Text -> TaxonomyOptions)
-> Parser (Maybe Text) -> Parser TaxonomyOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Text -> Parser (Maybe Text)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Text
taxonomyVersionOpt
    Parser TaxonomyOptions
-> Parser (TaxonomyOptions -> TaxonomyOptions)
-> Parser TaxonomyOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (TaxonomyOptions -> TaxonomyOptions)
forall a. Parser (a -> a)
helper
  where
    speciesCodesOpt :: Parser SpeciesCodes
    speciesCodesOpt :: Parser SpeciesCodes
speciesCodesOpt =
      ReadM SpeciesCodes
-> Mod OptionFields SpeciesCodes -> Parser SpeciesCodes
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser SpeciesCodes -> ReadM SpeciesCodes
forall a. Parser a -> ReadM a
attoReadM Parser SpeciesCodes
parseSpeciesCodes)
        (    String -> Mod OptionFields SpeciesCodes
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"species"
          Mod OptionFields SpeciesCodes
-> Mod OptionFields SpeciesCodes -> Mod OptionFields SpeciesCodes
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields SpeciesCodes
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"SPECIES_CODES"
          Mod OptionFields SpeciesCodes
-> Mod OptionFields SpeciesCodes -> Mod OptionFields SpeciesCodes
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields SpeciesCodes
forall (f :: * -> *) a. String -> Mod f a
help String
"Only include entries for these species (default: all)"
        )

    taxonomyVersionOpt :: Parser Text
    taxonomyVersionOpt :: Parser Text
taxonomyVersionOpt =
      ReadM Text -> Mod OptionFields Text -> Parser Text
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser Text -> ReadM Text
forall a. Parser a -> ReadM a
attoReadM Parser Text
A.takeText)
        (    String -> Mod OptionFields Text
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"version"
          Mod OptionFields Text
-> Mod OptionFields Text -> Mod OptionFields Text
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Text
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"VERSION"
          Mod OptionFields Text
-> Mod OptionFields Text -> Mod OptionFields Text
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Text
forall (f :: * -> *) a. String -> Mod f a
help String
"Taxonomy version to fetch (default: latest)"
        )

-- | Parse the options for a @taxonomic-forms@ command.
taxonomicFormsOptions :: Parser TaxonomicFormsOptions
taxonomicFormsOptions :: Parser TaxonomicFormsOptions
taxonomicFormsOptions =
        SpeciesCode -> TaxonomicFormsOptions
TaxonomicFormsOptions
    (SpeciesCode -> TaxonomicFormsOptions)
-> Parser SpeciesCode -> Parser TaxonomicFormsOptions
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> Parser SpeciesCode
speciesCodeOpt String
"subspecies"
    Parser TaxonomicFormsOptions
-> Parser (TaxonomicFormsOptions -> TaxonomicFormsOptions)
-> Parser TaxonomicFormsOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (TaxonomicFormsOptions -> TaxonomicFormsOptions)
forall a. Parser (a -> a)
helper

-- | Parse the options for a @taxa-locale-codes@ command.
taxaLocaleCodesOptions :: Parser TaxaLocaleCodesOptions
taxaLocaleCodesOptions :: Parser TaxaLocaleCodesOptions
taxaLocaleCodesOptions =
        Maybe SPPLocale -> TaxaLocaleCodesOptions
TaxaLocaleCodesOptions
    (Maybe SPPLocale -> TaxaLocaleCodesOptions)
-> Parser (Maybe SPPLocale) -> Parser TaxaLocaleCodesOptions
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SPPLocale -> Parser (Maybe SPPLocale)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser SPPLocale
acceptLanguageOpt
    Parser TaxaLocaleCodesOptions
-> Parser (TaxaLocaleCodesOptions -> TaxaLocaleCodesOptions)
-> Parser TaxaLocaleCodesOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (TaxaLocaleCodesOptions -> TaxaLocaleCodesOptions)
forall a. Parser (a -> a)
helper
  where
    acceptLanguageOpt :: Parser SPPLocale
    acceptLanguageOpt :: Parser SPPLocale
acceptLanguageOpt =
      ReadM SPPLocale -> Mod OptionFields SPPLocale -> Parser SPPLocale
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser SPPLocale -> ReadM SPPLocale
forall a. Parser a -> ReadM a
attoReadM Parser SPPLocale
parseSPPLocale)
        (    String -> Mod OptionFields SPPLocale
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"accept-language"
          Mod OptionFields SPPLocale
-> Mod OptionFields SPPLocale -> Mod OptionFields SPPLocale
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields SPPLocale
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"LOCALE"
          Mod OptionFields SPPLocale
-> Mod OptionFields SPPLocale -> Mod OptionFields SPPLocale
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields SPPLocale
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Get language names translated to this locale, when " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"available (default: en)"
                  )
        )

-- | Parse the options for a @taxa-locale-codes@ command.
taxonomicGroupsOptions :: Parser TaxonomicGroupsOptions
taxonomicGroupsOptions :: Parser TaxonomicGroupsOptions
taxonomicGroupsOptions =
        SPPGrouping -> Maybe SPPLocale -> TaxonomicGroupsOptions
TaxonomicGroupsOptions
    (SPPGrouping -> Maybe SPPLocale -> TaxonomicGroupsOptions)
-> Parser SPPGrouping
-> Parser (Maybe SPPLocale -> TaxonomicGroupsOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SPPGrouping
sppGroupingOpt
    Parser (Maybe SPPLocale -> TaxonomicGroupsOptions)
-> Parser (Maybe SPPLocale) -> Parser TaxonomicGroupsOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SPPLocale -> Parser (Maybe SPPLocale)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (String -> Parser SPPLocale
sppLocaleOpt String
"group")
    Parser TaxonomicGroupsOptions
-> Parser (TaxonomicGroupsOptions -> TaxonomicGroupsOptions)
-> Parser TaxonomicGroupsOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (TaxonomicGroupsOptions -> TaxonomicGroupsOptions)
forall a. Parser (a -> a)
helper
  where
    sppGroupingOpt :: Parser SPPGrouping
    sppGroupingOpt :: Parser SPPGrouping
sppGroupingOpt =
      ReadM SPPGrouping
-> Mod OptionFields SPPGrouping -> Parser SPPGrouping
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser SPPGrouping -> ReadM SPPGrouping
forall a. Parser a -> ReadM a
attoReadM Parser SPPGrouping
parseSPPGrouping)
        (    String -> Mod OptionFields SPPGrouping
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"spp-grouping"
          Mod OptionFields SPPGrouping
-> Mod OptionFields SPPGrouping -> Mod OptionFields SPPGrouping
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields SPPGrouping
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"GROUPING"
          Mod OptionFields SPPGrouping
-> Mod OptionFields SPPGrouping -> Mod OptionFields SPPGrouping
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields SPPGrouping
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Group species using Merlin or eBird grouping " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"(\"merlin\" or \"ebird\")"
                  )
        )

-------------------------------------------------------------------------------
-- Parsers for region command options
-------------------------------------------------------------------------------

-- | Parse the options for the @region-info@ command.
regionInfoOptions :: Parser RegionInfoOptions
regionInfoOptions :: Parser RegionInfoOptions
regionInfoOptions =
        Region -> Maybe RegionNameFormat -> RegionInfoOptions
RegionInfoOptions
    (Region -> Maybe RegionNameFormat -> RegionInfoOptions)
-> Parser Region
-> Parser (Maybe RegionNameFormat -> RegionInfoOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Region
region
    Parser (Maybe RegionNameFormat -> RegionInfoOptions)
-> Parser (Maybe RegionNameFormat) -> Parser RegionInfoOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser RegionNameFormat -> Parser (Maybe RegionNameFormat)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser RegionNameFormat
regionNameFormat
    Parser RegionInfoOptions
-> Parser (RegionInfoOptions -> RegionInfoOptions)
-> Parser RegionInfoOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (RegionInfoOptions -> RegionInfoOptions)
forall a. Parser (a -> a)
helper

-- | Parse the options for the @subregions@ command.
subregionListOptions :: Parser SubregionListOptions
subregionListOptions :: Parser SubregionListOptions
subregionListOptions =
        RegionCode -> RegionType -> SubregionListOptions
SubregionListOptions
    (RegionCode -> RegionType -> SubregionListOptions)
-> Parser RegionCode -> Parser (RegionType -> SubregionListOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser RegionCode
regionCode
    Parser (RegionType -> SubregionListOptions)
-> Parser RegionType -> Parser SubregionListOptions
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser RegionType
regionType
    Parser SubregionListOptions
-> Parser (SubregionListOptions -> SubregionListOptions)
-> Parser SubregionListOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (SubregionListOptions -> SubregionListOptions)
forall a. Parser (a -> a)
helper

-- | Parse the options for the @subregions@ command.
adjacentRegionsOptions :: Parser AdjacentRegionsOptions
adjacentRegionsOptions :: Parser AdjacentRegionsOptions
adjacentRegionsOptions =
        Region -> AdjacentRegionsOptions
AdjacentRegionsOptions
    (Region -> AdjacentRegionsOptions)
-> Parser Region -> Parser AdjacentRegionsOptions
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Region
regionOpt
    Parser AdjacentRegionsOptions
-> Parser (AdjacentRegionsOptions -> AdjacentRegionsOptions)
-> Parser AdjacentRegionsOptions
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (AdjacentRegionsOptions -> AdjacentRegionsOptions)
forall a. Parser (a -> a)
helper
  where
    regionOpt :: Parser Region
    regionOpt :: Parser Region
regionOpt =
      ReadM Region -> Mod OptionFields Region -> Parser Region
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser Region -> ReadM Region
forall a. Parser a -> ReadM a
attoReadM Parser Region
parseRegion)
        (    String -> Mod OptionFields Region
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"region"
          Mod OptionFields Region
-> Mod OptionFields Region -> Mod OptionFields Region
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Region
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"REGION"
          Mod OptionFields Region
-> Mod OptionFields Region -> Mod OptionFields Region
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Region
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify the region to get adjacent regions of " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                    String
"(e.g. \"US-WY\")"
                  )
        )

-------------------------------------------------------------------------------
-- Generic single option parsers
-------------------------------------------------------------------------------

-- | Parse a 'SPPLocale' as a generic command option.
sppLocaleOpt :: String -> Parser SPPLocale
sppLocaleOpt :: String -> Parser SPPLocale
sppLocaleOpt String
nameType =
  ReadM SPPLocale -> Mod OptionFields SPPLocale -> Parser SPPLocale
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser SPPLocale -> ReadM SPPLocale
forall a. Parser a -> ReadM a
attoReadM Parser SPPLocale
parseSPPLocale)
    (    String -> Mod OptionFields SPPLocale
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"spp-locale"
      Mod OptionFields SPPLocale
-> Mod OptionFields SPPLocale -> Mod OptionFields SPPLocale
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields SPPLocale
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"LOCALE"
      Mod OptionFields SPPLocale
-> Mod OptionFields SPPLocale -> Mod OptionFields SPPLocale
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields SPPLocale
forall (f :: * -> *) a. String -> Mod f a
help String
helpStr
    )
  where
    helpStr :: String
    helpStr :: String
helpStr =
      String -> String -> String
forall r. PrintfType r => String -> r
printf
        String
"Specify a locale to use for %s names"
        String
nameType

-- | Parse a 'Region' as a generic command option.
region :: Parser Region
region :: Parser Region
region = ReadM Region -> Mod OptionFields Region -> Parser Region
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser Region -> ReadM Region
forall a. Parser a -> ReadM a
attoReadM Parser Region
parseRegion)
    (    String -> Mod OptionFields Region
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"region"
      Mod OptionFields Region
-> Mod OptionFields Region -> Mod OptionFields Region
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Region
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"REGION"
      Mod OptionFields Region
-> Mod OptionFields Region -> Mod OptionFields Region
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Region
forall (f :: * -> *) a. String -> Mod f a
help String
"Specify a region (e.g. \"world\" or \"US-WY\")"
    )

-- | Parse a 'RegionCode' as a generic command option.
regionCode :: Parser RegionCode
regionCode :: Parser RegionCode
regionCode = ReadM RegionCode
-> Mod OptionFields RegionCode -> Parser RegionCode
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser RegionCode -> ReadM RegionCode
forall a. Parser a -> ReadM a
attoReadM Parser RegionCode
parseRegionCode)
    (    String -> Mod OptionFields RegionCode
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"region"
      Mod OptionFields RegionCode
-> Mod OptionFields RegionCode -> Mod OptionFields RegionCode
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields RegionCode
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"REGION_CODE"
      Mod OptionFields RegionCode
-> Mod OptionFields RegionCode -> Mod OptionFields RegionCode
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields RegionCode
forall (f :: * -> *) a. String -> Mod f a
help String
"Specify a region code (e.g. \"world\" or \"US-MT,US-WY\")"
    )

-- | Parse a 'RegionNameFormat' as a generic command option.
regionNameFormat :: Parser RegionNameFormat
regionNameFormat :: Parser RegionNameFormat
regionNameFormat = ReadM RegionNameFormat
-> Mod OptionFields RegionNameFormat -> Parser RegionNameFormat
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser RegionNameFormat -> ReadM RegionNameFormat
forall a. Parser a -> ReadM a
attoReadM Parser RegionNameFormat
parseRegionNameFormat)
    (    String -> Mod OptionFields RegionNameFormat
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"region-name-format"
      Mod OptionFields RegionNameFormat
-> Mod OptionFields RegionNameFormat
-> Mod OptionFields RegionNameFormat
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields RegionNameFormat
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"REGION_NAME_FORMAT"
      Mod OptionFields RegionNameFormat
-> Mod OptionFields RegionNameFormat
-> Mod OptionFields RegionNameFormat
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields RegionNameFormat
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify a region name format for the result. Must be one " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                String
"of \"detailed\", \"detailednoqual\", \"full\", " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                String
"\"namequal\", \"nameonly\", or \"revdetailed\" " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                String
"(default: full)"
              )
    )

-- | Parse a 'RegionType' as a generic command option.
regionType :: Parser RegionType
regionType :: Parser RegionType
regionType = ReadM RegionType
-> Mod OptionFields RegionType -> Parser RegionType
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser RegionType -> ReadM RegionType
forall a. Parser a -> ReadM a
attoReadM Parser RegionType
parseRegionType)
    (    String -> Mod OptionFields RegionType
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"region-type"
      Mod OptionFields RegionType
-> Mod OptionFields RegionType -> Mod OptionFields RegionType
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields RegionType
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"REGION_TYPE"
      Mod OptionFields RegionType
-> Mod OptionFields RegionType -> Mod OptionFields RegionType
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields RegionType
forall (f :: * -> *) a. String -> Mod f a
help ( String
"Specify a region type (\"country\", \"subnational1\", " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                String
"\"subnational2\")"
              )
    )

-------------------------------------------------------------------------------
-- Utility functions
-------------------------------------------------------------------------------

-- | Configurable 'SpeciesCode' option
speciesCodeOpt :: String -> Parser SpeciesCode
speciesCodeOpt :: String -> Parser SpeciesCode
speciesCodeOpt String
thing =
  ReadM SpeciesCode
-> Mod OptionFields SpeciesCode -> Parser SpeciesCode
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser SpeciesCode -> ReadM SpeciesCode
forall a. Parser a -> ReadM a
attoReadM Parser SpeciesCode
parseSpeciesCode)
    (    String -> Mod OptionFields SpeciesCode
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"species-code"
      Mod OptionFields SpeciesCode
-> Mod OptionFields SpeciesCode -> Mod OptionFields SpeciesCode
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields SpeciesCode
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"SPECIES_CODE"
      Mod OptionFields SpeciesCode
-> Mod OptionFields SpeciesCode -> Mod OptionFields SpeciesCode
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields SpeciesCode
forall (f :: * -> *) a. String -> Mod f a
help String
helpStr
    )
  where
    helpStr :: String
    helpStr :: String
helpStr =
      String -> String -> String
forall r. PrintfType r => String -> r
printf
        ( String
"Specify a species code to fetch %s for (e.g. \"barswa\" for Barn " String -> String -> String
forall a. [a] -> [a] -> [a]
++
          String
"Swallow)"
        )
        String
thing

-- | Configurable "search radius" option
searchRadiusOpt
  :: String
  -- ^ What are we searching for (e.g. "observations")
  -> Integer
  -- ^ Maximum allowed value by the API
  -> Maybe Integer
  -- ^ Default value of the API ('Nothing' for "no limit")
  -> Parser Integer
searchRadiusOpt :: String -> Integer -> Maybe Integer -> Parser Integer
searchRadiusOpt String
thing Integer
maxRadius Maybe Integer
mDefaultRadius =
    ReadM Integer -> Mod OptionFields Integer -> Parser Integer
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser Integer -> ReadM Integer
forall a. Parser a -> ReadM a
attoReadM Parser Integer
forall a. Integral a => Parser a
A.decimal)
      (    String -> Mod OptionFields Integer
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"radius"
        Mod OptionFields Integer
-> Mod OptionFields Integer -> Mod OptionFields Integer
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Integer
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"KILOMETERS"
        Mod OptionFields Integer
-> Mod OptionFields Integer -> Mod OptionFields Integer
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Integer
forall (f :: * -> *) a. String -> Mod f a
help String
helpStr
      )
  where
    helpStr :: String
    helpStr :: String
helpStr =
      String -> String -> Integer -> String -> String
forall r. PrintfType r => String -> r
printf
        String
"Specify the search radius to fetch %s within (0 to %d, default: %s)"
        String
thing
        Integer
maxRadius
        String
defStr

    defStr :: String
defStr = String -> (Integer -> String) -> Maybe Integer -> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe String
"no limit" Integer -> String
forall a. Show a => a -> String
show Maybe Integer
mDefaultRadius

-- | Configurable "back" option
backOpt
  :: String
  -- ^ What are we fetching (e.g. "hotspots")
  -> String
  -- ^ Verb we are filtering on (e.g. "submitted", or "visited")
  -> Maybe Integer
  -- ^ Default value ('Nothing' for "no limit")
  -> Parser Integer
backOpt :: String -> String -> Maybe Integer -> Parser Integer
backOpt String
thing String
verb Maybe Integer
mmax =
    ReadM Integer -> Mod OptionFields Integer -> Parser Integer
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser Integer -> ReadM Integer
forall a. Parser a -> ReadM a
attoReadM Parser Integer
forall a. Integral a => Parser a
A.decimal)
      (    String -> Mod OptionFields Integer
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"back"
        Mod OptionFields Integer
-> Mod OptionFields Integer -> Mod OptionFields Integer
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Integer
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"N"
        Mod OptionFields Integer
-> Mod OptionFields Integer -> Mod OptionFields Integer
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Integer
forall (f :: * -> *) a. String -> Mod f a
help String
helpStr
      )
  where
    helpStr :: String
    helpStr :: String
helpStr =
      String -> String -> String -> String -> String
forall r. PrintfType r => String -> r
printf
        String
"Only fetch %s %s within the last N days (1 - 30, default: %s)"
        String
thing
        String
verb
        String
defStr

    defStr :: String
defStr = String -> (Integer -> String) -> Maybe Integer -> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe String
"no limit" Integer -> String
forall a. Show a => a -> String
show Maybe Integer
mmax

-- | Configurable lat/lng option
latLngOpt
  :: String
  -- ^ "latitude" or "longitude"
  -> String
  -- ^ What are we looking for
  -> Parser Double
latLngOpt :: String -> String -> Parser Double
latLngOpt String
latLng String
thing =
    ReadM Double -> Mod OptionFields Double -> Parser Double
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Parser Double -> ReadM Double
forall a. Parser a -> ReadM a
attoReadM Parser Double
A.double)
      (    String -> Mod OptionFields Double
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
latLng
        Mod OptionFields Double
-> Mod OptionFields Double -> Mod OptionFields Double
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Double
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar ((Char -> Char) -> String -> String
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toUpper String
latLng)
        Mod OptionFields Double
-> Mod OptionFields Double -> Mod OptionFields Double
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Double
forall (f :: * -> *) a. String -> Mod f a
help String
helpStr
      )
  where
    helpStr :: String
    helpStr :: String
helpStr =
      String -> String -> String -> String
forall r. PrintfType r => String -> r
printf
        String
"Specify the %s of the location to fetch %s near"
        String
latLng
        String
thing

-- Attoparsec utilities

-- | Convert an attoparsec parser into an optparse-applicative parser.
attoReadM :: A.Parser a -> ReadM a
attoReadM :: forall a. Parser a -> ReadM a
attoReadM Parser a
p = (String -> Either String a) -> ReadM a
forall a. (String -> Either String a) -> ReadM a
eitherReader (Parser a -> Text -> Either String a
forall a. Parser a -> Text -> Either String a
A.parseOnly Parser a
p (Text -> Either String a)
-> (String -> Text) -> String -> Either String a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
Text.pack)