{-# OPTIONS_GHC -Wall #-}
{-# language DeriveFunctor, DerivingStrategies, DeriveDataTypeable, DeriveGeneric #-}

module Stripe.Concepts
  (
  -- * Modes
    Mode (..), BothModes (..), applyMode
  -- ** Conversion with Bool
  , isLiveMode, isTestMode, isLiveMode', isTestMode'

  -- * Keys
  -- $keys
  -- ** Publishable API key
  , PublishableApiKey (..)
  -- ** Secret API key
  , ApiSecretKey (..), textToApiSecretKey
  -- ** Webhook secret
  , WebhookSecretKey (..), textToWebhookSecretKey

  -- * Identifiers
  , TokenId (..), CustomerId (..), ProductId (..)
  , PlanId (..), SubscriptionId (..), InvoiceId (..)
  , CouponId (..)

  -- * API Versioning
  , ApiVersion (..), RequestApiVersion (..)

  ) where

-- base
import Data.Data (Data)
import GHC.Generics (Generic)

-- bytestring
import qualified Data.ByteString

-- text
import qualified Data.Text
import qualified Data.Text.Encoding

------------------------------------------------------------

{- | "To make the API as explorable as possible, accounts have test mode and
live mode API keys. There is no 'switch' for changing between modes, just use
the appropriate key to perform a live or test transaction. Requests made with
test mode credentials never hit the banking networks and incur no cost." -
<https://stripe.com/docs/api Stripe>

This library provides functions to convert back and forth between 'Mode' and
'Bool':

- 'isLiveMode' (and its inverse, 'isLiveMode'')
- 'isTestMode' (and its inverse, 'isTestMode'') -}

data Mode = LiveMode | TestMode
  deriving stock (Mode -> Mode -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Mode -> Mode -> Bool
$c/= :: Mode -> Mode -> Bool
== :: Mode -> Mode -> Bool
$c== :: Mode -> Mode -> Bool
Eq, Eq Mode
Mode -> Mode -> Bool
Mode -> Mode -> Ordering
Mode -> Mode -> Mode
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Mode -> Mode -> Mode
$cmin :: Mode -> Mode -> Mode
max :: Mode -> Mode -> Mode
$cmax :: Mode -> Mode -> Mode
>= :: Mode -> Mode -> Bool
$c>= :: Mode -> Mode -> Bool
> :: Mode -> Mode -> Bool
$c> :: Mode -> Mode -> Bool
<= :: Mode -> Mode -> Bool
$c<= :: Mode -> Mode -> Bool
< :: Mode -> Mode -> Bool
$c< :: Mode -> Mode -> Bool
compare :: Mode -> Mode -> Ordering
$ccompare :: Mode -> Mode -> Ordering
Ord, Int -> Mode -> ShowS
[Mode] -> ShowS
Mode -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Mode] -> ShowS
$cshowList :: [Mode] -> ShowS
show :: Mode -> String
$cshow :: Mode -> String
showsPrec :: Int -> Mode -> ShowS
$cshowsPrec :: Int -> Mode -> ShowS
Show, Int -> Mode
Mode -> Int
Mode -> [Mode]
Mode -> Mode
Mode -> Mode -> [Mode]
Mode -> Mode -> Mode -> [Mode]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Mode -> Mode -> Mode -> [Mode]
$cenumFromThenTo :: Mode -> Mode -> Mode -> [Mode]
enumFromTo :: Mode -> Mode -> [Mode]
$cenumFromTo :: Mode -> Mode -> [Mode]
enumFromThen :: Mode -> Mode -> [Mode]
$cenumFromThen :: Mode -> Mode -> [Mode]
enumFrom :: Mode -> [Mode]
$cenumFrom :: Mode -> [Mode]
fromEnum :: Mode -> Int
$cfromEnum :: Mode -> Int
toEnum :: Int -> Mode
$ctoEnum :: Int -> Mode
pred :: Mode -> Mode
$cpred :: Mode -> Mode
succ :: Mode -> Mode
$csucc :: Mode -> Mode
Enum, Mode
forall a. a -> a -> Bounded a
maxBound :: Mode
$cmaxBound :: Mode
minBound :: Mode
$cminBound :: Mode
Bounded, Typeable Mode
Mode -> DataType
Mode -> Constr
(forall b. Data b => b -> b) -> Mode -> Mode
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Mode -> u
forall u. (forall d. Data d => d -> u) -> Mode -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mode -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mode -> m Mode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mode -> m Mode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mode -> c Mode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Mode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mode)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mode -> m Mode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mode -> m Mode
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mode -> m Mode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mode -> m Mode
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mode -> m Mode
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mode -> m Mode
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Mode -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Mode -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Mode -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Mode -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mode -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mode -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mode -> r
gmapT :: (forall b. Data b => b -> b) -> Mode -> Mode
$cgmapT :: (forall b. Data b => b -> b) -> Mode -> Mode
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mode)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Mode)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Mode)
dataTypeOf :: Mode -> DataType
$cdataTypeOf :: Mode -> DataType
toConstr :: Mode -> Constr
$ctoConstr :: Mode -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mode
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mode -> c Mode
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mode -> c Mode
Data, forall x. Rep Mode x -> Mode
forall x. Mode -> Rep Mode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Mode x -> Mode
$cfrom :: forall x. Mode -> Rep Mode x
Generic)

-- | LiveMode → True; TestMode → False
isLiveMode :: Mode -> Bool
isLiveMode :: Mode -> Bool
isLiveMode Mode
LiveMode = Bool
True
isLiveMode Mode
TestMode = Bool
False

-- | True → LiveMode; False → TestMode
isLiveMode' :: Bool -> Mode
isLiveMode' :: Bool -> Mode
isLiveMode' Bool
True  = Mode
LiveMode
isLiveMode' Bool
False = Mode
TestMode

-- | LiveMode → False; TestMode → True
isTestMode :: Mode -> Bool
isTestMode :: Mode -> Bool
isTestMode Mode
LiveMode = Bool
False
isTestMode Mode
TestMode = Bool
True

-- | True → TestMode; False → LiveMode
isTestMode' :: Bool -> Mode
isTestMode' :: Bool -> Mode
isTestMode' Bool
True  = Mode
TestMode
isTestMode' Bool
False = Mode
LiveMode

{- | A pair of values of the same type, one for live mode and one for test mode.

For example, you may wish to use a value of type @'BothModes'
'PublishableApiKey'@ to represent your publishable API keys for both live mode
and test mode. -}

data BothModes a = BothModes { forall a. BothModes a -> a
liveMode :: a, forall a. BothModes a -> a
testMode :: a }
  deriving stock (BothModes a -> BothModes a -> Bool
forall a. Eq a => BothModes a -> BothModes a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BothModes a -> BothModes a -> Bool
$c/= :: forall a. Eq a => BothModes a -> BothModes a -> Bool
== :: BothModes a -> BothModes a -> Bool
$c== :: forall a. Eq a => BothModes a -> BothModes a -> Bool
Eq, Int -> BothModes a -> ShowS
forall a. Show a => Int -> BothModes a -> ShowS
forall a. Show a => [BothModes a] -> ShowS
forall a. Show a => BothModes a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BothModes a] -> ShowS
$cshowList :: forall a. Show a => [BothModes a] -> ShowS
show :: BothModes a -> String
$cshow :: forall a. Show a => BothModes a -> String
showsPrec :: Int -> BothModes a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> BothModes a -> ShowS
Show, BothModes a -> DataType
BothModes a -> Constr
forall {a}. Data a => Typeable (BothModes a)
forall a. Data a => BothModes a -> DataType
forall a. Data a => BothModes a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> BothModes a -> BothModes a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> BothModes a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> BothModes a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BothModes a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BothModes a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> BothModes a -> m (BothModes a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> BothModes a -> m (BothModes a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BothModes a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BothModes a -> c (BothModes a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (BothModes a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BothModes a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BothModes a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BothModes a -> c (BothModes a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (BothModes a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BothModes a -> m (BothModes a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> BothModes a -> m (BothModes a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BothModes a -> m (BothModes a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> BothModes a -> m (BothModes a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BothModes a -> m (BothModes a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> BothModes a -> m (BothModes a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BothModes a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> BothModes a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> BothModes a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> BothModes a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BothModes a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BothModes a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BothModes a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BothModes a -> r
gmapT :: (forall b. Data b => b -> b) -> BothModes a -> BothModes a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> BothModes a -> BothModes a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BothModes a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BothModes a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (BothModes a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (BothModes a))
dataTypeOf :: BothModes a -> DataType
$cdataTypeOf :: forall a. Data a => BothModes a -> DataType
toConstr :: BothModes a -> Constr
$ctoConstr :: forall a. Data a => BothModes a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BothModes a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BothModes a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BothModes a -> c (BothModes a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BothModes a -> c (BothModes a)
Data, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (BothModes a) x -> BothModes a
forall a x. BothModes a -> Rep (BothModes a) x
$cto :: forall a x. Rep (BothModes a) x -> BothModes a
$cfrom :: forall a x. BothModes a -> Rep (BothModes a) x
Generic, forall a b. a -> BothModes b -> BothModes a
forall a b. (a -> b) -> BothModes a -> BothModes b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> BothModes b -> BothModes a
$c<$ :: forall a b. a -> BothModes b -> BothModes a
fmap :: forall a b. (a -> b) -> BothModes a -> BothModes b
$cfmap :: forall a b. (a -> b) -> BothModes a -> BothModes b
Functor)

applyMode :: Mode -> BothModes a -> a
applyMode :: forall a. Mode -> BothModes a -> a
applyMode Mode
LiveMode = forall a. BothModes a -> a
liveMode
applyMode Mode
TestMode = forall a. BothModes a -> a
testMode

------------------------------------------------------------

{- $keys

Each Stripe account has a pair of API keys involved in making requests to the
Stripe API:

  * The publishable key ('PublishableApiKey')
  * The secret key ('ApiSecretKey')

Each webhook endpoint you set up has a "signing secret" ('WebhookSecretKey')
that you use to verify the authenticity of the webhook events you receive *from*
Stripe. -}

{- | API secret keys are used to make requests to Stripe.

"Authenticate your account when using the API by including your secret API key
in the request. You can manage your API keys in the Dashboard. Your API keys
carry many privileges, so be sure to keep them secret!" -
<https://stripe.com/docs/api#authentication Stripe>

The key is represented here as a 'Data.ByteString.ByteString', but you are
likely have the data as a 'Data.Text.Text' value. You can use
'textToApiSecretKey' to do this conversion. -}

newtype ApiSecretKey = ApiSecretKey Data.ByteString.ByteString
  deriving stock (ApiSecretKey -> ApiSecretKey -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ApiSecretKey -> ApiSecretKey -> Bool
$c/= :: ApiSecretKey -> ApiSecretKey -> Bool
== :: ApiSecretKey -> ApiSecretKey -> Bool
$c== :: ApiSecretKey -> ApiSecretKey -> Bool
Eq, Eq ApiSecretKey
ApiSecretKey -> ApiSecretKey -> Bool
ApiSecretKey -> ApiSecretKey -> Ordering
ApiSecretKey -> ApiSecretKey -> ApiSecretKey
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ApiSecretKey -> ApiSecretKey -> ApiSecretKey
$cmin :: ApiSecretKey -> ApiSecretKey -> ApiSecretKey
max :: ApiSecretKey -> ApiSecretKey -> ApiSecretKey
$cmax :: ApiSecretKey -> ApiSecretKey -> ApiSecretKey
>= :: ApiSecretKey -> ApiSecretKey -> Bool
$c>= :: ApiSecretKey -> ApiSecretKey -> Bool
> :: ApiSecretKey -> ApiSecretKey -> Bool
$c> :: ApiSecretKey -> ApiSecretKey -> Bool
<= :: ApiSecretKey -> ApiSecretKey -> Bool
$c<= :: ApiSecretKey -> ApiSecretKey -> Bool
< :: ApiSecretKey -> ApiSecretKey -> Bool
$c< :: ApiSecretKey -> ApiSecretKey -> Bool
compare :: ApiSecretKey -> ApiSecretKey -> Ordering
$ccompare :: ApiSecretKey -> ApiSecretKey -> Ordering
Ord)

{- | Publishable API keys are used in client-side code.

"Publishable API keys are meant solely to identify your account with Stripe,
they aren’t secret. In other words, they can safely be published in places like
your Stripe.js JavaScript code, or in an Android or iPhone app. Publishable keys
only have the power to create tokens." - <https://stripe.com/docs/keys Stripe>
-}

newtype PublishableApiKey = PublishableApiKey Data.Text.Text
  deriving stock (PublishableApiKey -> PublishableApiKey -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PublishableApiKey -> PublishableApiKey -> Bool
$c/= :: PublishableApiKey -> PublishableApiKey -> Bool
== :: PublishableApiKey -> PublishableApiKey -> Bool
$c== :: PublishableApiKey -> PublishableApiKey -> Bool
Eq, Eq PublishableApiKey
PublishableApiKey -> PublishableApiKey -> Bool
PublishableApiKey -> PublishableApiKey -> Ordering
PublishableApiKey -> PublishableApiKey -> PublishableApiKey
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PublishableApiKey -> PublishableApiKey -> PublishableApiKey
$cmin :: PublishableApiKey -> PublishableApiKey -> PublishableApiKey
max :: PublishableApiKey -> PublishableApiKey -> PublishableApiKey
$cmax :: PublishableApiKey -> PublishableApiKey -> PublishableApiKey
>= :: PublishableApiKey -> PublishableApiKey -> Bool
$c>= :: PublishableApiKey -> PublishableApiKey -> Bool
> :: PublishableApiKey -> PublishableApiKey -> Bool
$c> :: PublishableApiKey -> PublishableApiKey -> Bool
<= :: PublishableApiKey -> PublishableApiKey -> Bool
$c<= :: PublishableApiKey -> PublishableApiKey -> Bool
< :: PublishableApiKey -> PublishableApiKey -> Bool
$c< :: PublishableApiKey -> PublishableApiKey -> Bool
compare :: PublishableApiKey -> PublishableApiKey -> Ordering
$ccompare :: PublishableApiKey -> PublishableApiKey -> Ordering
Ord, Int -> PublishableApiKey -> ShowS
[PublishableApiKey] -> ShowS
PublishableApiKey -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PublishableApiKey] -> ShowS
$cshowList :: [PublishableApiKey] -> ShowS
show :: PublishableApiKey -> String
$cshow :: PublishableApiKey -> String
showsPrec :: Int -> PublishableApiKey -> ShowS
$cshowsPrec :: Int -> PublishableApiKey -> ShowS
Show, Typeable PublishableApiKey
PublishableApiKey -> DataType
PublishableApiKey -> Constr
(forall b. Data b => b -> b)
-> PublishableApiKey -> PublishableApiKey
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> PublishableApiKey -> u
forall u. (forall d. Data d => d -> u) -> PublishableApiKey -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PublishableApiKey -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PublishableApiKey -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PublishableApiKey -> m PublishableApiKey
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PublishableApiKey -> m PublishableApiKey
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PublishableApiKey
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PublishableApiKey -> c PublishableApiKey
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PublishableApiKey)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PublishableApiKey)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PublishableApiKey -> m PublishableApiKey
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PublishableApiKey -> m PublishableApiKey
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PublishableApiKey -> m PublishableApiKey
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PublishableApiKey -> m PublishableApiKey
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PublishableApiKey -> m PublishableApiKey
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PublishableApiKey -> m PublishableApiKey
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PublishableApiKey -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PublishableApiKey -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> PublishableApiKey -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PublishableApiKey -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PublishableApiKey -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PublishableApiKey -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PublishableApiKey -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PublishableApiKey -> r
gmapT :: (forall b. Data b => b -> b)
-> PublishableApiKey -> PublishableApiKey
$cgmapT :: (forall b. Data b => b -> b)
-> PublishableApiKey -> PublishableApiKey
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PublishableApiKey)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PublishableApiKey)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PublishableApiKey)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PublishableApiKey)
dataTypeOf :: PublishableApiKey -> DataType
$cdataTypeOf :: PublishableApiKey -> DataType
toConstr :: PublishableApiKey -> Constr
$ctoConstr :: PublishableApiKey -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PublishableApiKey
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PublishableApiKey
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PublishableApiKey -> c PublishableApiKey
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PublishableApiKey -> c PublishableApiKey
Data, forall x. Rep PublishableApiKey x -> PublishableApiKey
forall x. PublishableApiKey -> Rep PublishableApiKey x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PublishableApiKey x -> PublishableApiKey
$cfrom :: forall x. PublishableApiKey -> Rep PublishableApiKey x
Generic)

{- | Webhook secrets are used to verify the authenticity of webhook events that
you receive from Stripe.

"Stripe can optionally sign the webhook events it sends to your endpoints. We do
so by including a signature in each event’s Stripe-Signature header. This allows
you to validate that the events were sent by Stripe, not by a third party. [...]
Before you can verify signatures, you need to retrieve your endpoint’s secret
from your Dashboard’s Webhooks settings. -
<https://stripe.com/docs/webhooks/signatures Stripe>

The key is represented here as a 'Data.ByteString.ByteString', but you are
likely have the data as a 'Data.Text.Text' value. You can use
'textToWebhookSecretKey' to do this conversion. -}

newtype WebhookSecretKey = WebhookSecretKey Data.ByteString.ByteString
  deriving stock (WebhookSecretKey -> WebhookSecretKey -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WebhookSecretKey -> WebhookSecretKey -> Bool
$c/= :: WebhookSecretKey -> WebhookSecretKey -> Bool
== :: WebhookSecretKey -> WebhookSecretKey -> Bool
$c== :: WebhookSecretKey -> WebhookSecretKey -> Bool
Eq, Eq WebhookSecretKey
WebhookSecretKey -> WebhookSecretKey -> Bool
WebhookSecretKey -> WebhookSecretKey -> Ordering
WebhookSecretKey -> WebhookSecretKey -> WebhookSecretKey
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: WebhookSecretKey -> WebhookSecretKey -> WebhookSecretKey
$cmin :: WebhookSecretKey -> WebhookSecretKey -> WebhookSecretKey
max :: WebhookSecretKey -> WebhookSecretKey -> WebhookSecretKey
$cmax :: WebhookSecretKey -> WebhookSecretKey -> WebhookSecretKey
>= :: WebhookSecretKey -> WebhookSecretKey -> Bool
$c>= :: WebhookSecretKey -> WebhookSecretKey -> Bool
> :: WebhookSecretKey -> WebhookSecretKey -> Bool
$c> :: WebhookSecretKey -> WebhookSecretKey -> Bool
<= :: WebhookSecretKey -> WebhookSecretKey -> Bool
$c<= :: WebhookSecretKey -> WebhookSecretKey -> Bool
< :: WebhookSecretKey -> WebhookSecretKey -> Bool
$c< :: WebhookSecretKey -> WebhookSecretKey -> Bool
compare :: WebhookSecretKey -> WebhookSecretKey -> Ordering
$ccompare :: WebhookSecretKey -> WebhookSecretKey -> Ordering
Ord)

{- | Convert a 'Data.Text.Text' representation of a Stripe API key (that looks
something like @"sk_test_BQokikJOvBiI2HlWgH4olfQ2"@) to an 'ApiSecretKey'. -}

textToApiSecretKey :: Data.Text.Text -> ApiSecretKey
textToApiSecretKey :: Text -> ApiSecretKey
textToApiSecretKey = ByteString -> ApiSecretKey
ApiSecretKey forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
Data.Text.Encoding.encodeUtf8

{- | Convert a 'Data.Text.Text' representation of a Stripe webhook secret (that
looks something like @"whsec_ojm5cmJMGMTw3w7ngjI7mgkRsFGLRtCt"@) to a
'WebhookSecretKey'. -}

textToWebhookSecretKey :: Data.Text.Text -> WebhookSecretKey
textToWebhookSecretKey :: Text -> WebhookSecretKey
textToWebhookSecretKey = ByteString -> WebhookSecretKey
WebhookSecretKey forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
Data.Text.Encoding.encodeUtf8

------------------------------------------------------------

{- | Identifier of a Stripe "token", which represents a payment source that was
submitted by a user to Stripe.

"This ensures that no sensitive card data touches your server, and allows your
integration to operate in a PCI-compliant way." -
<https://stripe.com/docs/api/tokens Stripe> -}

newtype TokenId = TokenId Data.Text.Text
  deriving stock (TokenId -> TokenId -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TokenId -> TokenId -> Bool
$c/= :: TokenId -> TokenId -> Bool
== :: TokenId -> TokenId -> Bool
$c== :: TokenId -> TokenId -> Bool
Eq, Eq TokenId
TokenId -> TokenId -> Bool
TokenId -> TokenId -> Ordering
TokenId -> TokenId -> TokenId
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TokenId -> TokenId -> TokenId
$cmin :: TokenId -> TokenId -> TokenId
max :: TokenId -> TokenId -> TokenId
$cmax :: TokenId -> TokenId -> TokenId
>= :: TokenId -> TokenId -> Bool
$c>= :: TokenId -> TokenId -> Bool
> :: TokenId -> TokenId -> Bool
$c> :: TokenId -> TokenId -> Bool
<= :: TokenId -> TokenId -> Bool
$c<= :: TokenId -> TokenId -> Bool
< :: TokenId -> TokenId -> Bool
$c< :: TokenId -> TokenId -> Bool
compare :: TokenId -> TokenId -> Ordering
$ccompare :: TokenId -> TokenId -> Ordering
Ord, Int -> TokenId -> ShowS
[TokenId] -> ShowS
TokenId -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TokenId] -> ShowS
$cshowList :: [TokenId] -> ShowS
show :: TokenId -> String
$cshow :: TokenId -> String
showsPrec :: Int -> TokenId -> ShowS
$cshowsPrec :: Int -> TokenId -> ShowS
Show, Typeable TokenId
TokenId -> DataType
TokenId -> Constr
(forall b. Data b => b -> b) -> TokenId -> TokenId
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TokenId -> u
forall u. (forall d. Data d => d -> u) -> TokenId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TokenId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TokenId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TokenId -> m TokenId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TokenId -> m TokenId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TokenId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TokenId -> c TokenId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TokenId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TokenId)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TokenId -> m TokenId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TokenId -> m TokenId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TokenId -> m TokenId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TokenId -> m TokenId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TokenId -> m TokenId
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TokenId -> m TokenId
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TokenId -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TokenId -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> TokenId -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TokenId -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TokenId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TokenId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TokenId -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TokenId -> r
gmapT :: (forall b. Data b => b -> b) -> TokenId -> TokenId
$cgmapT :: (forall b. Data b => b -> b) -> TokenId -> TokenId
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TokenId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TokenId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TokenId)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TokenId)
dataTypeOf :: TokenId -> DataType
$cdataTypeOf :: TokenId -> DataType
toConstr :: TokenId -> Constr
$ctoConstr :: TokenId -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TokenId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TokenId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TokenId -> c TokenId
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TokenId -> c TokenId
Data, forall x. Rep TokenId x -> TokenId
forall x. TokenId -> Rep TokenId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TokenId x -> TokenId
$cfrom :: forall x. TokenId -> Rep TokenId x
Generic)

{- | A customer identifier assigned by Stripe.

"Customer objects allow you to perform recurring charges, and to track multiple
charges, that are associated with the same customer." -
<https://stripe.com/docs/api/customers Stripe> -}

newtype CustomerId = CustomerId Data.Text.Text
  deriving stock (CustomerId -> CustomerId -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CustomerId -> CustomerId -> Bool
$c/= :: CustomerId -> CustomerId -> Bool
== :: CustomerId -> CustomerId -> Bool
$c== :: CustomerId -> CustomerId -> Bool
Eq, Eq CustomerId
CustomerId -> CustomerId -> Bool
CustomerId -> CustomerId -> Ordering
CustomerId -> CustomerId -> CustomerId
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CustomerId -> CustomerId -> CustomerId
$cmin :: CustomerId -> CustomerId -> CustomerId
max :: CustomerId -> CustomerId -> CustomerId
$cmax :: CustomerId -> CustomerId -> CustomerId
>= :: CustomerId -> CustomerId -> Bool
$c>= :: CustomerId -> CustomerId -> Bool
> :: CustomerId -> CustomerId -> Bool
$c> :: CustomerId -> CustomerId -> Bool
<= :: CustomerId -> CustomerId -> Bool
$c<= :: CustomerId -> CustomerId -> Bool
< :: CustomerId -> CustomerId -> Bool
$c< :: CustomerId -> CustomerId -> Bool
compare :: CustomerId -> CustomerId -> Ordering
$ccompare :: CustomerId -> CustomerId -> Ordering
Ord, Int -> CustomerId -> ShowS
[CustomerId] -> ShowS
CustomerId -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CustomerId] -> ShowS
$cshowList :: [CustomerId] -> ShowS
show :: CustomerId -> String
$cshow :: CustomerId -> String
showsPrec :: Int -> CustomerId -> ShowS
$cshowsPrec :: Int -> CustomerId -> ShowS
Show, Typeable CustomerId
CustomerId -> DataType
CustomerId -> Constr
(forall b. Data b => b -> b) -> CustomerId -> CustomerId
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CustomerId -> u
forall u. (forall d. Data d => d -> u) -> CustomerId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CustomerId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CustomerId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CustomerId -> m CustomerId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CustomerId -> m CustomerId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CustomerId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CustomerId -> c CustomerId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CustomerId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CustomerId)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CustomerId -> m CustomerId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CustomerId -> m CustomerId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CustomerId -> m CustomerId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CustomerId -> m CustomerId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CustomerId -> m CustomerId
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CustomerId -> m CustomerId
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CustomerId -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CustomerId -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CustomerId -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CustomerId -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CustomerId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CustomerId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CustomerId -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CustomerId -> r
gmapT :: (forall b. Data b => b -> b) -> CustomerId -> CustomerId
$cgmapT :: (forall b. Data b => b -> b) -> CustomerId -> CustomerId
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CustomerId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CustomerId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CustomerId)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CustomerId)
dataTypeOf :: CustomerId -> DataType
$cdataTypeOf :: CustomerId -> DataType
toConstr :: CustomerId -> Constr
$ctoConstr :: CustomerId -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CustomerId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CustomerId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CustomerId -> c CustomerId
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CustomerId -> c CustomerId
Data, forall x. Rep CustomerId x -> CustomerId
forall x. CustomerId -> Rep CustomerId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CustomerId x -> CustomerId
$cfrom :: forall x. CustomerId -> Rep CustomerId x
Generic)

{- | The ID of a Stripe product.

"Product objects describe items that your customers can subscribe to with a
Subscription. An associated Plan determines the product pricing." -
<https://stripe.com/docs/api/service_products Stripe> -}

newtype ProductId = ProductId Data.Text.Text
  deriving stock (ProductId -> ProductId -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProductId -> ProductId -> Bool
$c/= :: ProductId -> ProductId -> Bool
== :: ProductId -> ProductId -> Bool
$c== :: ProductId -> ProductId -> Bool
Eq, Eq ProductId
ProductId -> ProductId -> Bool
ProductId -> ProductId -> Ordering
ProductId -> ProductId -> ProductId
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ProductId -> ProductId -> ProductId
$cmin :: ProductId -> ProductId -> ProductId
max :: ProductId -> ProductId -> ProductId
$cmax :: ProductId -> ProductId -> ProductId
>= :: ProductId -> ProductId -> Bool
$c>= :: ProductId -> ProductId -> Bool
> :: ProductId -> ProductId -> Bool
$c> :: ProductId -> ProductId -> Bool
<= :: ProductId -> ProductId -> Bool
$c<= :: ProductId -> ProductId -> Bool
< :: ProductId -> ProductId -> Bool
$c< :: ProductId -> ProductId -> Bool
compare :: ProductId -> ProductId -> Ordering
$ccompare :: ProductId -> ProductId -> Ordering
Ord, Int -> ProductId -> ShowS
[ProductId] -> ShowS
ProductId -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProductId] -> ShowS
$cshowList :: [ProductId] -> ShowS
show :: ProductId -> String
$cshow :: ProductId -> String
showsPrec :: Int -> ProductId -> ShowS
$cshowsPrec :: Int -> ProductId -> ShowS
Show, Typeable ProductId
ProductId -> DataType
ProductId -> Constr
(forall b. Data b => b -> b) -> ProductId -> ProductId
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ProductId -> u
forall u. (forall d. Data d => d -> u) -> ProductId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProductId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProductId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ProductId -> m ProductId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProductId -> m ProductId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ProductId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProductId -> c ProductId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ProductId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProductId)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProductId -> m ProductId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProductId -> m ProductId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProductId -> m ProductId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProductId -> m ProductId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ProductId -> m ProductId
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ProductId -> m ProductId
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ProductId -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ProductId -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ProductId -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ProductId -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProductId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProductId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProductId -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProductId -> r
gmapT :: (forall b. Data b => b -> b) -> ProductId -> ProductId
$cgmapT :: (forall b. Data b => b -> b) -> ProductId -> ProductId
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProductId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProductId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ProductId)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ProductId)
dataTypeOf :: ProductId -> DataType
$cdataTypeOf :: ProductId -> DataType
toConstr :: ProductId -> Constr
$ctoConstr :: ProductId -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ProductId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ProductId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProductId -> c ProductId
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProductId -> c ProductId
Data, forall x. Rep ProductId x -> ProductId
forall x. ProductId -> Rep ProductId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProductId x -> ProductId
$cfrom :: forall x. ProductId -> Rep ProductId x
Generic)

{- | The ID of a Stripe subscription plan.

"Plans define the base price, currency, and billing cycle for subscriptions. For
example, you might have a $5/month plan that provides limited access to your
products, and a $15/month plan that allows full access." -
<https://stripe.com/docs/api/plans Stripe> -}

newtype PlanId = PlanId Data.Text.Text
  deriving stock (PlanId -> PlanId -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PlanId -> PlanId -> Bool
$c/= :: PlanId -> PlanId -> Bool
== :: PlanId -> PlanId -> Bool
$c== :: PlanId -> PlanId -> Bool
Eq, Eq PlanId
PlanId -> PlanId -> Bool
PlanId -> PlanId -> Ordering
PlanId -> PlanId -> PlanId
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PlanId -> PlanId -> PlanId
$cmin :: PlanId -> PlanId -> PlanId
max :: PlanId -> PlanId -> PlanId
$cmax :: PlanId -> PlanId -> PlanId
>= :: PlanId -> PlanId -> Bool
$c>= :: PlanId -> PlanId -> Bool
> :: PlanId -> PlanId -> Bool
$c> :: PlanId -> PlanId -> Bool
<= :: PlanId -> PlanId -> Bool
$c<= :: PlanId -> PlanId -> Bool
< :: PlanId -> PlanId -> Bool
$c< :: PlanId -> PlanId -> Bool
compare :: PlanId -> PlanId -> Ordering
$ccompare :: PlanId -> PlanId -> Ordering
Ord, Int -> PlanId -> ShowS
[PlanId] -> ShowS
PlanId -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PlanId] -> ShowS
$cshowList :: [PlanId] -> ShowS
show :: PlanId -> String
$cshow :: PlanId -> String
showsPrec :: Int -> PlanId -> ShowS
$cshowsPrec :: Int -> PlanId -> ShowS
Show, Typeable PlanId
PlanId -> DataType
PlanId -> Constr
(forall b. Data b => b -> b) -> PlanId -> PlanId
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PlanId -> u
forall u. (forall d. Data d => d -> u) -> PlanId -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PlanId -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PlanId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PlanId -> m PlanId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PlanId -> m PlanId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PlanId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PlanId -> c PlanId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PlanId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PlanId)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PlanId -> m PlanId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PlanId -> m PlanId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PlanId -> m PlanId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PlanId -> m PlanId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PlanId -> m PlanId
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PlanId -> m PlanId
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PlanId -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PlanId -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> PlanId -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PlanId -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PlanId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PlanId -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PlanId -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PlanId -> r
gmapT :: (forall b. Data b => b -> b) -> PlanId -> PlanId
$cgmapT :: (forall b. Data b => b -> b) -> PlanId -> PlanId
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PlanId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PlanId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PlanId)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PlanId)
dataTypeOf :: PlanId -> DataType
$cdataTypeOf :: PlanId -> DataType
toConstr :: PlanId -> Constr
$ctoConstr :: PlanId -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PlanId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PlanId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PlanId -> c PlanId
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PlanId -> c PlanId
Data, forall x. Rep PlanId x -> PlanId
forall x. PlanId -> Rep PlanId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PlanId x -> PlanId
$cfrom :: forall x. PlanId -> Rep PlanId x
Generic)

{- | Identifier for a customer's subscription to a product.

"Subscriptions allow you to charge a customer on a recurring basis. A
subscription ties a customer to a particular plan you've created." -
<https://stripe.com/docs/api/subscriptions Stripe> -}

newtype SubscriptionId = SubscriptionId Data.Text.Text
  deriving stock (SubscriptionId -> SubscriptionId -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubscriptionId -> SubscriptionId -> Bool
$c/= :: SubscriptionId -> SubscriptionId -> Bool
== :: SubscriptionId -> SubscriptionId -> Bool
$c== :: SubscriptionId -> SubscriptionId -> Bool
Eq, Eq SubscriptionId
SubscriptionId -> SubscriptionId -> Bool
SubscriptionId -> SubscriptionId -> Ordering
SubscriptionId -> SubscriptionId -> SubscriptionId
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SubscriptionId -> SubscriptionId -> SubscriptionId
$cmin :: SubscriptionId -> SubscriptionId -> SubscriptionId
max :: SubscriptionId -> SubscriptionId -> SubscriptionId
$cmax :: SubscriptionId -> SubscriptionId -> SubscriptionId
>= :: SubscriptionId -> SubscriptionId -> Bool
$c>= :: SubscriptionId -> SubscriptionId -> Bool
> :: SubscriptionId -> SubscriptionId -> Bool
$c> :: SubscriptionId -> SubscriptionId -> Bool
<= :: SubscriptionId -> SubscriptionId -> Bool
$c<= :: SubscriptionId -> SubscriptionId -> Bool
< :: SubscriptionId -> SubscriptionId -> Bool
$c< :: SubscriptionId -> SubscriptionId -> Bool
compare :: SubscriptionId -> SubscriptionId -> Ordering
$ccompare :: SubscriptionId -> SubscriptionId -> Ordering
Ord, Int -> SubscriptionId -> ShowS
[SubscriptionId] -> ShowS
SubscriptionId -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SubscriptionId] -> ShowS
$cshowList :: [SubscriptionId] -> ShowS
show :: SubscriptionId -> String
$cshow :: SubscriptionId -> String
showsPrec :: Int -> SubscriptionId -> ShowS
$cshowsPrec :: Int -> SubscriptionId -> ShowS
Show, Typeable SubscriptionId
SubscriptionId -> DataType
SubscriptionId -> Constr
(forall b. Data b => b -> b) -> SubscriptionId -> SubscriptionId
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> SubscriptionId -> u
forall u. (forall d. Data d => d -> u) -> SubscriptionId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubscriptionId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SubscriptionId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SubscriptionId -> m SubscriptionId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SubscriptionId -> m SubscriptionId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubscriptionId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubscriptionId -> c SubscriptionId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubscriptionId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SubscriptionId)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SubscriptionId -> m SubscriptionId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SubscriptionId -> m SubscriptionId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SubscriptionId -> m SubscriptionId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SubscriptionId -> m SubscriptionId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SubscriptionId -> m SubscriptionId
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SubscriptionId -> m SubscriptionId
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SubscriptionId -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SubscriptionId -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> SubscriptionId -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SubscriptionId -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SubscriptionId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SubscriptionId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubscriptionId -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubscriptionId -> r
gmapT :: (forall b. Data b => b -> b) -> SubscriptionId -> SubscriptionId
$cgmapT :: (forall b. Data b => b -> b) -> SubscriptionId -> SubscriptionId
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SubscriptionId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SubscriptionId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubscriptionId)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubscriptionId)
dataTypeOf :: SubscriptionId -> DataType
$cdataTypeOf :: SubscriptionId -> DataType
toConstr :: SubscriptionId -> Constr
$ctoConstr :: SubscriptionId -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubscriptionId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubscriptionId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubscriptionId -> c SubscriptionId
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubscriptionId -> c SubscriptionId
Data, forall x. Rep SubscriptionId x -> SubscriptionId
forall x. SubscriptionId -> Rep SubscriptionId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SubscriptionId x -> SubscriptionId
$cfrom :: forall x. SubscriptionId -> Rep SubscriptionId x
Generic)

{- | The ID of a Stripe invoice.

"Invoices are statements of amounts owed by a customer, and are either generated
one-off, or generated periodically from a subscription." -
<https://stripe.com/docs/api/invoices Stripe> -}

newtype InvoiceId = InvoiceId Data.Text.Text
  deriving stock (InvoiceId -> InvoiceId -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InvoiceId -> InvoiceId -> Bool
$c/= :: InvoiceId -> InvoiceId -> Bool
== :: InvoiceId -> InvoiceId -> Bool
$c== :: InvoiceId -> InvoiceId -> Bool
Eq, Eq InvoiceId
InvoiceId -> InvoiceId -> Bool
InvoiceId -> InvoiceId -> Ordering
InvoiceId -> InvoiceId -> InvoiceId
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: InvoiceId -> InvoiceId -> InvoiceId
$cmin :: InvoiceId -> InvoiceId -> InvoiceId
max :: InvoiceId -> InvoiceId -> InvoiceId
$cmax :: InvoiceId -> InvoiceId -> InvoiceId
>= :: InvoiceId -> InvoiceId -> Bool
$c>= :: InvoiceId -> InvoiceId -> Bool
> :: InvoiceId -> InvoiceId -> Bool
$c> :: InvoiceId -> InvoiceId -> Bool
<= :: InvoiceId -> InvoiceId -> Bool
$c<= :: InvoiceId -> InvoiceId -> Bool
< :: InvoiceId -> InvoiceId -> Bool
$c< :: InvoiceId -> InvoiceId -> Bool
compare :: InvoiceId -> InvoiceId -> Ordering
$ccompare :: InvoiceId -> InvoiceId -> Ordering
Ord, Int -> InvoiceId -> ShowS
[InvoiceId] -> ShowS
InvoiceId -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InvoiceId] -> ShowS
$cshowList :: [InvoiceId] -> ShowS
show :: InvoiceId -> String
$cshow :: InvoiceId -> String
showsPrec :: Int -> InvoiceId -> ShowS
$cshowsPrec :: Int -> InvoiceId -> ShowS
Show, Typeable InvoiceId
InvoiceId -> DataType
InvoiceId -> Constr
(forall b. Data b => b -> b) -> InvoiceId -> InvoiceId
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> InvoiceId -> u
forall u. (forall d. Data d => d -> u) -> InvoiceId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InvoiceId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InvoiceId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InvoiceId -> m InvoiceId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InvoiceId -> m InvoiceId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InvoiceId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InvoiceId -> c InvoiceId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InvoiceId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InvoiceId)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InvoiceId -> m InvoiceId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InvoiceId -> m InvoiceId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InvoiceId -> m InvoiceId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InvoiceId -> m InvoiceId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InvoiceId -> m InvoiceId
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InvoiceId -> m InvoiceId
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InvoiceId -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InvoiceId -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> InvoiceId -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> InvoiceId -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InvoiceId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InvoiceId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InvoiceId -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InvoiceId -> r
gmapT :: (forall b. Data b => b -> b) -> InvoiceId -> InvoiceId
$cgmapT :: (forall b. Data b => b -> b) -> InvoiceId -> InvoiceId
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InvoiceId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InvoiceId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InvoiceId)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InvoiceId)
dataTypeOf :: InvoiceId -> DataType
$cdataTypeOf :: InvoiceId -> DataType
toConstr :: InvoiceId -> Constr
$ctoConstr :: InvoiceId -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InvoiceId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InvoiceId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InvoiceId -> c InvoiceId
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InvoiceId -> c InvoiceId
Data, forall x. Rep InvoiceId x -> InvoiceId
forall x. InvoiceId -> Rep InvoiceId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep InvoiceId x -> InvoiceId
$cfrom :: forall x. InvoiceId -> Rep InvoiceId x
Generic)

{- | The ID of a Stripe coupon.

"A coupon contains information about a percent-off or amount-off discount you
might want to apply to a customer. Coupons may be applied to invoices or
orders." -
<https://stripe.com/docs/api/coupons Stripe> -}

newtype CouponId = CouponId Data.Text.Text
  deriving stock (CouponId -> CouponId -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CouponId -> CouponId -> Bool
$c/= :: CouponId -> CouponId -> Bool
== :: CouponId -> CouponId -> Bool
$c== :: CouponId -> CouponId -> Bool
Eq, Eq CouponId
CouponId -> CouponId -> Bool
CouponId -> CouponId -> Ordering
CouponId -> CouponId -> CouponId
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CouponId -> CouponId -> CouponId
$cmin :: CouponId -> CouponId -> CouponId
max :: CouponId -> CouponId -> CouponId
$cmax :: CouponId -> CouponId -> CouponId
>= :: CouponId -> CouponId -> Bool
$c>= :: CouponId -> CouponId -> Bool
> :: CouponId -> CouponId -> Bool
$c> :: CouponId -> CouponId -> Bool
<= :: CouponId -> CouponId -> Bool
$c<= :: CouponId -> CouponId -> Bool
< :: CouponId -> CouponId -> Bool
$c< :: CouponId -> CouponId -> Bool
compare :: CouponId -> CouponId -> Ordering
$ccompare :: CouponId -> CouponId -> Ordering
Ord, Int -> CouponId -> ShowS
[CouponId] -> ShowS
CouponId -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CouponId] -> ShowS
$cshowList :: [CouponId] -> ShowS
show :: CouponId -> String
$cshow :: CouponId -> String
showsPrec :: Int -> CouponId -> ShowS
$cshowsPrec :: Int -> CouponId -> ShowS
Show, Typeable CouponId
CouponId -> DataType
CouponId -> Constr
(forall b. Data b => b -> b) -> CouponId -> CouponId
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CouponId -> u
forall u. (forall d. Data d => d -> u) -> CouponId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CouponId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CouponId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CouponId -> m CouponId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CouponId -> m CouponId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CouponId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CouponId -> c CouponId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CouponId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CouponId)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CouponId -> m CouponId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CouponId -> m CouponId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CouponId -> m CouponId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CouponId -> m CouponId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CouponId -> m CouponId
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CouponId -> m CouponId
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CouponId -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CouponId -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CouponId -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CouponId -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CouponId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CouponId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CouponId -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CouponId -> r
gmapT :: (forall b. Data b => b -> b) -> CouponId -> CouponId
$cgmapT :: (forall b. Data b => b -> b) -> CouponId -> CouponId
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CouponId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CouponId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CouponId)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CouponId)
dataTypeOf :: CouponId -> DataType
$cdataTypeOf :: CouponId -> DataType
toConstr :: CouponId -> Constr
$ctoConstr :: CouponId -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CouponId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CouponId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CouponId -> c CouponId
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CouponId -> c CouponId
Data, forall x. Rep CouponId x -> CouponId
forall x. CouponId -> Rep CouponId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CouponId x -> CouponId
$cfrom :: forall x. CouponId -> Rep CouponId x
Generic)

------------------------------------------------------------

{- | When Stripe makes a backwards-incompatible change to the API, they release
a new API version. The versions are named by the date of their release (e.g.
"2019-09-09"). -}

newtype ApiVersion = ApiVersion Data.Text.Text
  deriving stock (ApiVersion -> ApiVersion -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ApiVersion -> ApiVersion -> Bool
$c/= :: ApiVersion -> ApiVersion -> Bool
== :: ApiVersion -> ApiVersion -> Bool
$c== :: ApiVersion -> ApiVersion -> Bool
Eq, Eq ApiVersion
ApiVersion -> ApiVersion -> Bool
ApiVersion -> ApiVersion -> Ordering
ApiVersion -> ApiVersion -> ApiVersion
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ApiVersion -> ApiVersion -> ApiVersion
$cmin :: ApiVersion -> ApiVersion -> ApiVersion
max :: ApiVersion -> ApiVersion -> ApiVersion
$cmax :: ApiVersion -> ApiVersion -> ApiVersion
>= :: ApiVersion -> ApiVersion -> Bool
$c>= :: ApiVersion -> ApiVersion -> Bool
> :: ApiVersion -> ApiVersion -> Bool
$c> :: ApiVersion -> ApiVersion -> Bool
<= :: ApiVersion -> ApiVersion -> Bool
$c<= :: ApiVersion -> ApiVersion -> Bool
< :: ApiVersion -> ApiVersion -> Bool
$c< :: ApiVersion -> ApiVersion -> Bool
compare :: ApiVersion -> ApiVersion -> Ordering
$ccompare :: ApiVersion -> ApiVersion -> Ordering
Ord, Int -> ApiVersion -> ShowS
[ApiVersion] -> ShowS
ApiVersion -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ApiVersion] -> ShowS
$cshowList :: [ApiVersion] -> ShowS
show :: ApiVersion -> String
$cshow :: ApiVersion -> String
showsPrec :: Int -> ApiVersion -> ShowS
$cshowsPrec :: Int -> ApiVersion -> ShowS
Show, Typeable ApiVersion
ApiVersion -> DataType
ApiVersion -> Constr
(forall b. Data b => b -> b) -> ApiVersion -> ApiVersion
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ApiVersion -> u
forall u. (forall d. Data d => d -> u) -> ApiVersion -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ApiVersion -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ApiVersion -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ApiVersion -> m ApiVersion
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ApiVersion -> m ApiVersion
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ApiVersion
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ApiVersion -> c ApiVersion
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ApiVersion)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ApiVersion)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ApiVersion -> m ApiVersion
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ApiVersion -> m ApiVersion
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ApiVersion -> m ApiVersion
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ApiVersion -> m ApiVersion
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ApiVersion -> m ApiVersion
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ApiVersion -> m ApiVersion
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ApiVersion -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ApiVersion -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ApiVersion -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ApiVersion -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ApiVersion -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ApiVersion -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ApiVersion -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ApiVersion -> r
gmapT :: (forall b. Data b => b -> b) -> ApiVersion -> ApiVersion
$cgmapT :: (forall b. Data b => b -> b) -> ApiVersion -> ApiVersion
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ApiVersion)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ApiVersion)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ApiVersion)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ApiVersion)
dataTypeOf :: ApiVersion -> DataType
$cdataTypeOf :: ApiVersion -> DataType
toConstr :: ApiVersion -> Constr
$ctoConstr :: ApiVersion -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ApiVersion
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ApiVersion
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ApiVersion -> c ApiVersion
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ApiVersion -> c ApiVersion
Data, forall x. Rep ApiVersion x -> ApiVersion
forall x. ApiVersion -> Rep ApiVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ApiVersion x -> ApiVersion
$cfrom :: forall x. ApiVersion -> Rep ApiVersion x
Generic)

{- |  Your account API settings specify:

  - Which API version is used by default for requests;
  - Which API version is used for webhook events.

However, you can override the API version for specific requests. "To set the API
version on a specific request, send a @Stripe-Version@ header." -
<https://stripe.com/docs/api/versioning Stripe> -}

data RequestApiVersion =
    DefaultApiVersion
      -- ^ Use the default API version specified by your account settings.
  | OverrideApiVersion ApiVersion
      {- ^ Use a specific API version for this request. (Please note however
           that any webhook events generated as a result of this request will
           still use your account's default API version.) -}
    deriving stock (RequestApiVersion -> RequestApiVersion -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RequestApiVersion -> RequestApiVersion -> Bool
$c/= :: RequestApiVersion -> RequestApiVersion -> Bool
== :: RequestApiVersion -> RequestApiVersion -> Bool
$c== :: RequestApiVersion -> RequestApiVersion -> Bool
Eq, Eq RequestApiVersion
RequestApiVersion -> RequestApiVersion -> Bool
RequestApiVersion -> RequestApiVersion -> Ordering
RequestApiVersion -> RequestApiVersion -> RequestApiVersion
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RequestApiVersion -> RequestApiVersion -> RequestApiVersion
$cmin :: RequestApiVersion -> RequestApiVersion -> RequestApiVersion
max :: RequestApiVersion -> RequestApiVersion -> RequestApiVersion
$cmax :: RequestApiVersion -> RequestApiVersion -> RequestApiVersion
>= :: RequestApiVersion -> RequestApiVersion -> Bool
$c>= :: RequestApiVersion -> RequestApiVersion -> Bool
> :: RequestApiVersion -> RequestApiVersion -> Bool
$c> :: RequestApiVersion -> RequestApiVersion -> Bool
<= :: RequestApiVersion -> RequestApiVersion -> Bool
$c<= :: RequestApiVersion -> RequestApiVersion -> Bool
< :: RequestApiVersion -> RequestApiVersion -> Bool
$c< :: RequestApiVersion -> RequestApiVersion -> Bool
compare :: RequestApiVersion -> RequestApiVersion -> Ordering
$ccompare :: RequestApiVersion -> RequestApiVersion -> Ordering
Ord, Int -> RequestApiVersion -> ShowS
[RequestApiVersion] -> ShowS
RequestApiVersion -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RequestApiVersion] -> ShowS
$cshowList :: [RequestApiVersion] -> ShowS
show :: RequestApiVersion -> String
$cshow :: RequestApiVersion -> String
showsPrec :: Int -> RequestApiVersion -> ShowS
$cshowsPrec :: Int -> RequestApiVersion -> ShowS
Show, Typeable RequestApiVersion
RequestApiVersion -> DataType
RequestApiVersion -> Constr
(forall b. Data b => b -> b)
-> RequestApiVersion -> RequestApiVersion
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> RequestApiVersion -> u
forall u. (forall d. Data d => d -> u) -> RequestApiVersion -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RequestApiVersion -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RequestApiVersion -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RequestApiVersion -> m RequestApiVersion
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RequestApiVersion -> m RequestApiVersion
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RequestApiVersion
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RequestApiVersion -> c RequestApiVersion
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RequestApiVersion)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RequestApiVersion)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RequestApiVersion -> m RequestApiVersion
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RequestApiVersion -> m RequestApiVersion
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RequestApiVersion -> m RequestApiVersion
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RequestApiVersion -> m RequestApiVersion
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RequestApiVersion -> m RequestApiVersion
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RequestApiVersion -> m RequestApiVersion
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> RequestApiVersion -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> RequestApiVersion -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> RequestApiVersion -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RequestApiVersion -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RequestApiVersion -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RequestApiVersion -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RequestApiVersion -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RequestApiVersion -> r
gmapT :: (forall b. Data b => b -> b)
-> RequestApiVersion -> RequestApiVersion
$cgmapT :: (forall b. Data b => b -> b)
-> RequestApiVersion -> RequestApiVersion
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RequestApiVersion)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RequestApiVersion)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RequestApiVersion)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RequestApiVersion)
dataTypeOf :: RequestApiVersion -> DataType
$cdataTypeOf :: RequestApiVersion -> DataType
toConstr :: RequestApiVersion -> Constr
$ctoConstr :: RequestApiVersion -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RequestApiVersion
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RequestApiVersion
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RequestApiVersion -> c RequestApiVersion
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RequestApiVersion -> c RequestApiVersion
Data, forall x. Rep RequestApiVersion x -> RequestApiVersion
forall x. RequestApiVersion -> Rep RequestApiVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RequestApiVersion x -> RequestApiVersion
$cfrom :: forall x. RequestApiVersion -> Rep RequestApiVersion x
Generic)