{-# LANGUAGE CPP                #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE OverloadedStrings  #-}
-- | ICalendar types, based on RFC5545.
module Text.ICalendar.Types
    ( module Text.ICalendar.Types
    ) where

import           Codec.MIME.Type            (MIMEType)
import           Data.ByteString.Lazy.Char8 (ByteString)
import           Data.CaseInsensitive       (CI)
import           Data.Default
import           Data.Map                   (Map)
import qualified Data.Map                   as M
import           Data.Set                   (Set)
import           Data.Semigroup             as Sem
import           Data.Text.Lazy             (Text, pack)
import           Data.Time
import           Data.Typeable              (Typeable)
import           Data.Version               (Version (..), showVersion)
import           Network.URI                (URI)

import Paths_iCalendar (version)

-- | Language.
newtype Language = Language (CI Text) -- TODO: RFC5646 types and parser.
                   deriving (Language -> Language -> Bool
(Language -> Language -> Bool)
-> (Language -> Language -> Bool) -> Eq Language
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Language -> Language -> Bool
== :: Language -> Language -> Bool
$c/= :: Language -> Language -> Bool
/= :: Language -> Language -> Bool
Eq, Int -> Language -> ShowS
[Language] -> ShowS
Language -> String
(Int -> Language -> ShowS)
-> (Language -> String) -> ([Language] -> ShowS) -> Show Language
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Language -> ShowS
showsPrec :: Int -> Language -> ShowS
$cshow :: Language -> String
show :: Language -> String
$cshowList :: [Language] -> ShowS
showList :: [Language] -> ShowS
Show, Eq Language
Eq Language =>
(Language -> Language -> Ordering)
-> (Language -> Language -> Bool)
-> (Language -> Language -> Bool)
-> (Language -> Language -> Bool)
-> (Language -> Language -> Bool)
-> (Language -> Language -> Language)
-> (Language -> Language -> Language)
-> Ord Language
Language -> Language -> Bool
Language -> Language -> Ordering
Language -> Language -> Language
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
$ccompare :: Language -> Language -> Ordering
compare :: Language -> Language -> Ordering
$c< :: Language -> Language -> Bool
< :: Language -> Language -> Bool
$c<= :: Language -> Language -> Bool
<= :: Language -> Language -> Bool
$c> :: Language -> Language -> Bool
> :: Language -> Language -> Bool
$c>= :: Language -> Language -> Bool
>= :: Language -> Language -> Bool
$cmax :: Language -> Language -> Language
max :: Language -> Language -> Language
$cmin :: Language -> Language -> Language
min :: Language -> Language -> Language
Ord, Typeable)

type CalAddress = URI

-- | One other parameter, either x-param or iana-param.
data OtherParam = OtherParam (CI Text) [Text]
                  deriving (Int -> OtherParam -> ShowS
[OtherParam] -> ShowS
OtherParam -> String
(Int -> OtherParam -> ShowS)
-> (OtherParam -> String)
-> ([OtherParam] -> ShowS)
-> Show OtherParam
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OtherParam -> ShowS
showsPrec :: Int -> OtherParam -> ShowS
$cshow :: OtherParam -> String
show :: OtherParam -> String
$cshowList :: [OtherParam] -> ShowS
showList :: [OtherParam] -> ShowS
Show, OtherParam -> OtherParam -> Bool
(OtherParam -> OtherParam -> Bool)
-> (OtherParam -> OtherParam -> Bool) -> Eq OtherParam
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OtherParam -> OtherParam -> Bool
== :: OtherParam -> OtherParam -> Bool
$c/= :: OtherParam -> OtherParam -> Bool
/= :: OtherParam -> OtherParam -> Bool
Eq, Eq OtherParam
Eq OtherParam =>
(OtherParam -> OtherParam -> Ordering)
-> (OtherParam -> OtherParam -> Bool)
-> (OtherParam -> OtherParam -> Bool)
-> (OtherParam -> OtherParam -> Bool)
-> (OtherParam -> OtherParam -> Bool)
-> (OtherParam -> OtherParam -> OtherParam)
-> (OtherParam -> OtherParam -> OtherParam)
-> Ord OtherParam
OtherParam -> OtherParam -> Bool
OtherParam -> OtherParam -> Ordering
OtherParam -> OtherParam -> OtherParam
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
$ccompare :: OtherParam -> OtherParam -> Ordering
compare :: OtherParam -> OtherParam -> Ordering
$c< :: OtherParam -> OtherParam -> Bool
< :: OtherParam -> OtherParam -> Bool
$c<= :: OtherParam -> OtherParam -> Bool
<= :: OtherParam -> OtherParam -> Bool
$c> :: OtherParam -> OtherParam -> Bool
> :: OtherParam -> OtherParam -> Bool
$c>= :: OtherParam -> OtherParam -> Bool
>= :: OtherParam -> OtherParam -> Bool
$cmax :: OtherParam -> OtherParam -> OtherParam
max :: OtherParam -> OtherParam -> OtherParam
$cmin :: OtherParam -> OtherParam -> OtherParam
min :: OtherParam -> OtherParam -> OtherParam
Ord, Typeable)

-- | Other parameters, either x-param or other iana-param.
data OtherParams = OtherParams (Set OtherParam)
                   deriving (Int -> OtherParams -> ShowS
[OtherParams] -> ShowS
OtherParams -> String
(Int -> OtherParams -> ShowS)
-> (OtherParams -> String)
-> ([OtherParams] -> ShowS)
-> Show OtherParams
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OtherParams -> ShowS
showsPrec :: Int -> OtherParams -> ShowS
$cshow :: OtherParams -> String
show :: OtherParams -> String
$cshowList :: [OtherParams] -> ShowS
showList :: [OtherParams] -> ShowS
Show, OtherParams -> OtherParams -> Bool
(OtherParams -> OtherParams -> Bool)
-> (OtherParams -> OtherParams -> Bool) -> Eq OtherParams
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OtherParams -> OtherParams -> Bool
== :: OtherParams -> OtherParams -> Bool
$c/= :: OtherParams -> OtherParams -> Bool
/= :: OtherParams -> OtherParams -> Bool
Eq, Eq OtherParams
Eq OtherParams =>
(OtherParams -> OtherParams -> Ordering)
-> (OtherParams -> OtherParams -> Bool)
-> (OtherParams -> OtherParams -> Bool)
-> (OtherParams -> OtherParams -> Bool)
-> (OtherParams -> OtherParams -> Bool)
-> (OtherParams -> OtherParams -> OtherParams)
-> (OtherParams -> OtherParams -> OtherParams)
-> Ord OtherParams
OtherParams -> OtherParams -> Bool
OtherParams -> OtherParams -> Ordering
OtherParams -> OtherParams -> OtherParams
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
$ccompare :: OtherParams -> OtherParams -> Ordering
compare :: OtherParams -> OtherParams -> Ordering
$c< :: OtherParams -> OtherParams -> Bool
< :: OtherParams -> OtherParams -> Bool
$c<= :: OtherParams -> OtherParams -> Bool
<= :: OtherParams -> OtherParams -> Bool
$c> :: OtherParams -> OtherParams -> Bool
> :: OtherParams -> OtherParams -> Bool
$c>= :: OtherParams -> OtherParams -> Bool
>= :: OtherParams -> OtherParams -> Bool
$cmax :: OtherParams -> OtherParams -> OtherParams
max :: OtherParams -> OtherParams -> OtherParams
$cmin :: OtherParams -> OtherParams -> OtherParams
min :: OtherParams -> OtherParams -> OtherParams
Ord, Typeable)

instance Default OtherParams where
    def :: OtherParams
def = Set OtherParam -> OtherParams
OtherParams Set OtherParam
forall a. Default a => a
def

-- | VCalendar component. 3.4.
data VCalendar = VCalendar
    { VCalendar -> ProdId
vcProdId     :: ProdId
    , VCalendar -> ICalVersion
vcVersion    :: ICalVersion
    , VCalendar -> Scale
vcScale      :: Scale
    , VCalendar -> Maybe Method
vcMethod     :: Maybe Method
    , VCalendar -> Set OtherProperty
vcOther      :: Set OtherProperty
    , VCalendar -> Map Text VTimeZone
vcTimeZones  :: Map Text VTimeZone
    -- ^ Map TZID-value VTimeZone
    , VCalendar -> Map (Text, Maybe (Either Date DateTime)) VEvent
vcEvents     :: Map (Text, Maybe (Either Date DateTime)) VEvent
    -- ^ Map (UID-value, Maybe RecurrenceID-value) VEvent
    , VCalendar -> Map (Text, Maybe (Either Date DateTime)) VTodo
vcTodos      :: Map (Text, Maybe (Either Date DateTime)) VTodo
    -- ^ Map (UID-value, Maybe RecurrenceID-value) VTodo
    , VCalendar -> Map (Text, Maybe (Either Date DateTime)) VJournal
vcJournals   :: Map (Text, Maybe (Either Date DateTime)) VJournal
    -- ^ Map (UID-value, Maybe RecurrenceID-value) VJournal
    , VCalendar -> Map Text VFreeBusy
vcFreeBusys  :: Map Text VFreeBusy
    -- ^ Map UID-value VFreeBusy
    , VCalendar -> Set VOther
vcOtherComps :: Set VOther
    } deriving (Int -> VCalendar -> ShowS
[VCalendar] -> ShowS
VCalendar -> String
(Int -> VCalendar -> ShowS)
-> (VCalendar -> String)
-> ([VCalendar] -> ShowS)
-> Show VCalendar
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VCalendar -> ShowS
showsPrec :: Int -> VCalendar -> ShowS
$cshow :: VCalendar -> String
show :: VCalendar -> String
$cshowList :: [VCalendar] -> ShowS
showList :: [VCalendar] -> ShowS
Show, VCalendar -> VCalendar -> Bool
(VCalendar -> VCalendar -> Bool)
-> (VCalendar -> VCalendar -> Bool) -> Eq VCalendar
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VCalendar -> VCalendar -> Bool
== :: VCalendar -> VCalendar -> Bool
$c/= :: VCalendar -> VCalendar -> Bool
/= :: VCalendar -> VCalendar -> Bool
Eq, Eq VCalendar
Eq VCalendar =>
(VCalendar -> VCalendar -> Ordering)
-> (VCalendar -> VCalendar -> Bool)
-> (VCalendar -> VCalendar -> Bool)
-> (VCalendar -> VCalendar -> Bool)
-> (VCalendar -> VCalendar -> Bool)
-> (VCalendar -> VCalendar -> VCalendar)
-> (VCalendar -> VCalendar -> VCalendar)
-> Ord VCalendar
VCalendar -> VCalendar -> Bool
VCalendar -> VCalendar -> Ordering
VCalendar -> VCalendar -> VCalendar
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
$ccompare :: VCalendar -> VCalendar -> Ordering
compare :: VCalendar -> VCalendar -> Ordering
$c< :: VCalendar -> VCalendar -> Bool
< :: VCalendar -> VCalendar -> Bool
$c<= :: VCalendar -> VCalendar -> Bool
<= :: VCalendar -> VCalendar -> Bool
$c> :: VCalendar -> VCalendar -> Bool
> :: VCalendar -> VCalendar -> Bool
$c>= :: VCalendar -> VCalendar -> Bool
>= :: VCalendar -> VCalendar -> Bool
$cmax :: VCalendar -> VCalendar -> VCalendar
max :: VCalendar -> VCalendar -> VCalendar
$cmin :: VCalendar -> VCalendar -> VCalendar
min :: VCalendar -> VCalendar -> VCalendar
Ord, Typeable)

instance Default VCalendar where
    def :: VCalendar
def = ProdId
-> ICalVersion
-> Scale
-> Maybe Method
-> Set OtherProperty
-> Map Text VTimeZone
-> Map (Text, Maybe (Either Date DateTime)) VEvent
-> Map (Text, Maybe (Either Date DateTime)) VTodo
-> Map (Text, Maybe (Either Date DateTime)) VJournal
-> Map Text VFreeBusy
-> Set VOther
-> VCalendar
VCalendar (Text -> OtherParams -> ProdId
ProdId (Text
"-//haskell.org/NONSGML iCalendar-" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
                             String -> Text
pack (Version -> String
showVersion Version
version) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"//EN") OtherParams
forall a. Default a => a
def)
                    (Version -> OtherParams -> ICalVersion
MaxICalVersion ([Int] -> [String] -> Version
Version [Int
2,Int
0] []) OtherParams
forall a. Default a => a
def)
                    Scale
forall a. Default a => a
def Maybe Method
forall a. Maybe a
Nothing Set OtherProperty
forall a. Default a => a
def Map Text VTimeZone
forall a. Default a => a
def Map (Text, Maybe (Either Date DateTime)) VEvent
forall a. Default a => a
def Map (Text, Maybe (Either Date DateTime)) VTodo
forall a. Default a => a
def Map (Text, Maybe (Either Date DateTime)) VJournal
forall a. Default a => a
def Map Text VFreeBusy
forall a. Default a => a
def Set VOther
forall a. Default a => a
def

-- | 'vcMethod' is ignored at the moment.
--
-- Picks the left in most cases.
--
-- On UID/RecurrenceId/TZID clash, picks the 'VEvent's, 'VTodo's and
-- 'VJournal's with the highest ('Sequence', 'DTStamp'), the 'VTimeZone's
-- with the highest 'LastModified', and 'VFreeBusy' with the highest 'DTStamp'.
--
-- If the Sequence, DTStamp or LastModified is the same, picks the left.
instance Sem.Semigroup VCalendar where
    VCalendar
a <> :: VCalendar -> VCalendar -> VCalendar
<> VCalendar
b = VCalendar { vcProdId :: ProdId
vcProdId     = VCalendar -> ProdId
vcProdId VCalendar
a
                       , vcVersion :: ICalVersion
vcVersion    = VCalendar -> ICalVersion
vcVersion VCalendar
a
                       , vcScale :: Scale
vcScale      = VCalendar -> Scale
vcScale VCalendar
a
                       , vcMethod :: Maybe Method
vcMethod     = VCalendar -> Maybe Method
vcMethod VCalendar
a
                       , vcOther :: Set OtherProperty
vcOther      = VCalendar -> Set OtherProperty
vcOther VCalendar
a Set OtherProperty -> Set OtherProperty -> Set OtherProperty
forall a. Semigroup a => a -> a -> a
<> VCalendar -> Set OtherProperty
vcOther VCalendar
b
                       , vcTimeZones :: Map Text VTimeZone
vcTimeZones  = (VTimeZone -> VTimeZone -> VTimeZone)
-> Map Text VTimeZone -> Map Text VTimeZone -> Map Text VTimeZone
forall {k} {c}.
Ord k =>
(c -> c -> c) -> Map k c -> Map k c -> Map k c
merge VTimeZone -> VTimeZone -> VTimeZone
tz (VCalendar -> Map Text VTimeZone
vcTimeZones VCalendar
a)
                                                 (VCalendar -> Map Text VTimeZone
vcTimeZones VCalendar
b)
                       , vcEvents :: Map (Text, Maybe (Either Date DateTime)) VEvent
vcEvents     = (VEvent -> VEvent -> VEvent)
-> Map (Text, Maybe (Either Date DateTime)) VEvent
-> Map (Text, Maybe (Either Date DateTime)) VEvent
-> Map (Text, Maybe (Either Date DateTime)) VEvent
forall {k} {c}.
Ord k =>
(c -> c -> c) -> Map k c -> Map k c -> Map k c
merge VEvent -> VEvent -> VEvent
ev (VCalendar -> Map (Text, Maybe (Either Date DateTime)) VEvent
vcEvents VCalendar
a) (VCalendar -> Map (Text, Maybe (Either Date DateTime)) VEvent
vcEvents VCalendar
b)
                       , vcTodos :: Map (Text, Maybe (Either Date DateTime)) VTodo
vcTodos      = (VTodo -> VTodo -> VTodo)
-> Map (Text, Maybe (Either Date DateTime)) VTodo
-> Map (Text, Maybe (Either Date DateTime)) VTodo
-> Map (Text, Maybe (Either Date DateTime)) VTodo
forall {k} {c}.
Ord k =>
(c -> c -> c) -> Map k c -> Map k c -> Map k c
merge VTodo -> VTodo -> VTodo
td (VCalendar -> Map (Text, Maybe (Either Date DateTime)) VTodo
vcTodos VCalendar
a) (VCalendar -> Map (Text, Maybe (Either Date DateTime)) VTodo
vcTodos VCalendar
b)
                       , vcJournals :: Map (Text, Maybe (Either Date DateTime)) VJournal
vcJournals   = (VJournal -> VJournal -> VJournal)
-> Map (Text, Maybe (Either Date DateTime)) VJournal
-> Map (Text, Maybe (Either Date DateTime)) VJournal
-> Map (Text, Maybe (Either Date DateTime)) VJournal
forall {k} {c}.
Ord k =>
(c -> c -> c) -> Map k c -> Map k c -> Map k c
merge VJournal -> VJournal -> VJournal
jo (VCalendar -> Map (Text, Maybe (Either Date DateTime)) VJournal
vcJournals VCalendar
a)
                                                 (VCalendar -> Map (Text, Maybe (Either Date DateTime)) VJournal
vcJournals VCalendar
b)
                       , vcFreeBusys :: Map Text VFreeBusy
vcFreeBusys  = (VFreeBusy -> VFreeBusy -> VFreeBusy)
-> Map Text VFreeBusy -> Map Text VFreeBusy -> Map Text VFreeBusy
forall {k} {c}.
Ord k =>
(c -> c -> c) -> Map k c -> Map k c -> Map k c
merge VFreeBusy -> VFreeBusy -> VFreeBusy
fb (VCalendar -> Map Text VFreeBusy
vcFreeBusys VCalendar
a)
                                                 (VCalendar -> Map Text VFreeBusy
vcFreeBusys VCalendar
b)
                       , vcOtherComps :: Set VOther
vcOtherComps = VCalendar -> Set VOther
vcOtherComps VCalendar
a Set VOther -> Set VOther -> Set VOther
forall a. Semigroup a => a -> a -> a
<> VCalendar -> Set VOther
vcOtherComps VCalendar
b
                       }
      where merge :: (c -> c -> c) -> Map k c -> Map k c -> Map k c
merge c -> c -> c
f = (k -> c -> c -> Maybe c)
-> (Map k c -> Map k c)
-> (Map k c -> Map k c)
-> Map k c
-> Map k c
-> Map k c
forall k a b c.
Ord k =>
(k -> a -> b -> Maybe c)
-> (Map k a -> Map k c)
-> (Map k b -> Map k c)
-> Map k a
-> Map k b
-> Map k c
M.mergeWithKey (((c -> Maybe c
forall a. a -> Maybe a
Just (c -> Maybe c) -> (c -> c) -> c -> Maybe c
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((c -> c) -> c -> Maybe c) -> (c -> c -> c) -> c -> c -> Maybe c
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((c -> c -> c) -> c -> c -> Maybe c)
-> (k -> c -> c -> c) -> k -> c -> c -> Maybe c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c -> c -> c) -> k -> c -> c -> c
forall a b. a -> b -> a
const c -> c -> c
f) Map k c -> Map k c
forall a. a -> a
id Map k c -> Map k c
forall a. a -> a
id
            tz :: VTimeZone -> VTimeZone -> VTimeZone
tz VTimeZone
c VTimeZone
d = if VTimeZone -> Maybe LastModified
vtzLastMod VTimeZone
c Maybe LastModified -> Maybe LastModified -> Bool
forall a. Ord a => a -> a -> Bool
>= VTimeZone -> Maybe LastModified
vtzLastMod VTimeZone
d then VTimeZone
c else VTimeZone
d
            ev :: VEvent -> VEvent -> VEvent
ev VEvent
c VEvent
d = if (VEvent -> Sequence
veSeq VEvent
c, VEvent -> DTStamp
veDTStamp VEvent
c) (Sequence, DTStamp) -> (Sequence, DTStamp) -> Bool
forall a. Ord a => a -> a -> Bool
>= (VEvent -> Sequence
veSeq VEvent
d, VEvent -> DTStamp
veDTStamp VEvent
d)
                        then VEvent
c else VEvent
d
            td :: VTodo -> VTodo -> VTodo
td VTodo
c VTodo
d = if (VTodo -> Sequence
vtSeq VTodo
c, VTodo -> DTStamp
vtDTStamp VTodo
c) (Sequence, DTStamp) -> (Sequence, DTStamp) -> Bool
forall a. Ord a => a -> a -> Bool
>= (VTodo -> Sequence
vtSeq VTodo
d, VTodo -> DTStamp
vtDTStamp VTodo
d)
                        then VTodo
c else VTodo
d
            jo :: VJournal -> VJournal -> VJournal
jo VJournal
c VJournal
d = if (VJournal -> Sequence
vjSeq VJournal
c, VJournal -> DTStamp
vjDTStamp VJournal
c) (Sequence, DTStamp) -> (Sequence, DTStamp) -> Bool
forall a. Ord a => a -> a -> Bool
>= (VJournal -> Sequence
vjSeq VJournal
d, VJournal -> DTStamp
vjDTStamp VJournal
d)
                        then VJournal
c else VJournal
d
            fb :: VFreeBusy -> VFreeBusy -> VFreeBusy
fb VFreeBusy
c VFreeBusy
d = if VFreeBusy -> DTStamp
vfbDTStamp VFreeBusy
c DTStamp -> DTStamp -> Bool
forall a. Ord a => a -> a -> Bool
>= VFreeBusy -> DTStamp
vfbDTStamp VFreeBusy
d then VFreeBusy
c else VFreeBusy
d


instance Monoid VCalendar where
    mempty :: VCalendar
mempty = VCalendar
forall a. Default a => a
def
#if !(MIN_VERSION_base(4,11,0))
    mappend = (<>)
#endif

-- | Product Identifier. 3.7.3.
data ProdId = ProdId
    { ProdId -> Text
prodIdValue :: Text
    , ProdId -> OtherParams
prodIdOther :: OtherParams
    } deriving (Int -> ProdId -> ShowS
[ProdId] -> ShowS
ProdId -> String
(Int -> ProdId -> ShowS)
-> (ProdId -> String) -> ([ProdId] -> ShowS) -> Show ProdId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProdId -> ShowS
showsPrec :: Int -> ProdId -> ShowS
$cshow :: ProdId -> String
show :: ProdId -> String
$cshowList :: [ProdId] -> ShowS
showList :: [ProdId] -> ShowS
Show, ProdId -> ProdId -> Bool
(ProdId -> ProdId -> Bool)
-> (ProdId -> ProdId -> Bool) -> Eq ProdId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProdId -> ProdId -> Bool
== :: ProdId -> ProdId -> Bool
$c/= :: ProdId -> ProdId -> Bool
/= :: ProdId -> ProdId -> Bool
Eq, Eq ProdId
Eq ProdId =>
(ProdId -> ProdId -> Ordering)
-> (ProdId -> ProdId -> Bool)
-> (ProdId -> ProdId -> Bool)
-> (ProdId -> ProdId -> Bool)
-> (ProdId -> ProdId -> Bool)
-> (ProdId -> ProdId -> ProdId)
-> (ProdId -> ProdId -> ProdId)
-> Ord ProdId
ProdId -> ProdId -> Bool
ProdId -> ProdId -> Ordering
ProdId -> ProdId -> ProdId
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
$ccompare :: ProdId -> ProdId -> Ordering
compare :: ProdId -> ProdId -> Ordering
$c< :: ProdId -> ProdId -> Bool
< :: ProdId -> ProdId -> Bool
$c<= :: ProdId -> ProdId -> Bool
<= :: ProdId -> ProdId -> Bool
$c> :: ProdId -> ProdId -> Bool
> :: ProdId -> ProdId -> Bool
$c>= :: ProdId -> ProdId -> Bool
>= :: ProdId -> ProdId -> Bool
$cmax :: ProdId -> ProdId -> ProdId
max :: ProdId -> ProdId -> ProdId
$cmin :: ProdId -> ProdId -> ProdId
min :: ProdId -> ProdId -> ProdId
Ord, Typeable)

-- | Version. 3.7.4.
data ICalVersion
    = MaxICalVersion
    { ICalVersion -> Version
versionMax   :: Version
    , ICalVersion -> OtherParams
versionOther :: OtherParams
    }
    | MinMaxICalVersion
    { versionMax   :: Version
    , ICalVersion -> Version
versionMin   :: Version
    , versionOther :: OtherParams
    } deriving (Int -> ICalVersion -> ShowS
[ICalVersion] -> ShowS
ICalVersion -> String
(Int -> ICalVersion -> ShowS)
-> (ICalVersion -> String)
-> ([ICalVersion] -> ShowS)
-> Show ICalVersion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ICalVersion -> ShowS
showsPrec :: Int -> ICalVersion -> ShowS
$cshow :: ICalVersion -> String
show :: ICalVersion -> String
$cshowList :: [ICalVersion] -> ShowS
showList :: [ICalVersion] -> ShowS
Show, ICalVersion -> ICalVersion -> Bool
(ICalVersion -> ICalVersion -> Bool)
-> (ICalVersion -> ICalVersion -> Bool) -> Eq ICalVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ICalVersion -> ICalVersion -> Bool
== :: ICalVersion -> ICalVersion -> Bool
$c/= :: ICalVersion -> ICalVersion -> Bool
/= :: ICalVersion -> ICalVersion -> Bool
Eq, Eq ICalVersion
Eq ICalVersion =>
(ICalVersion -> ICalVersion -> Ordering)
-> (ICalVersion -> ICalVersion -> Bool)
-> (ICalVersion -> ICalVersion -> Bool)
-> (ICalVersion -> ICalVersion -> Bool)
-> (ICalVersion -> ICalVersion -> Bool)
-> (ICalVersion -> ICalVersion -> ICalVersion)
-> (ICalVersion -> ICalVersion -> ICalVersion)
-> Ord ICalVersion
ICalVersion -> ICalVersion -> Bool
ICalVersion -> ICalVersion -> Ordering
ICalVersion -> ICalVersion -> ICalVersion
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
$ccompare :: ICalVersion -> ICalVersion -> Ordering
compare :: ICalVersion -> ICalVersion -> Ordering
$c< :: ICalVersion -> ICalVersion -> Bool
< :: ICalVersion -> ICalVersion -> Bool
$c<= :: ICalVersion -> ICalVersion -> Bool
<= :: ICalVersion -> ICalVersion -> Bool
$c> :: ICalVersion -> ICalVersion -> Bool
> :: ICalVersion -> ICalVersion -> Bool
$c>= :: ICalVersion -> ICalVersion -> Bool
>= :: ICalVersion -> ICalVersion -> Bool
$cmax :: ICalVersion -> ICalVersion -> ICalVersion
max :: ICalVersion -> ICalVersion -> ICalVersion
$cmin :: ICalVersion -> ICalVersion -> ICalVersion
min :: ICalVersion -> ICalVersion -> ICalVersion
Ord, Typeable)

-- | Calendar Scale. 3.7.1.
data Scale = Scale
    { Scale -> CI Text
scaleValue :: CI Text
    , Scale -> OtherParams
scaleOther :: OtherParams
    } deriving (Int -> Scale -> ShowS
[Scale] -> ShowS
Scale -> String
(Int -> Scale -> ShowS)
-> (Scale -> String) -> ([Scale] -> ShowS) -> Show Scale
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Scale -> ShowS
showsPrec :: Int -> Scale -> ShowS
$cshow :: Scale -> String
show :: Scale -> String
$cshowList :: [Scale] -> ShowS
showList :: [Scale] -> ShowS
Show, Scale -> Scale -> Bool
(Scale -> Scale -> Bool) -> (Scale -> Scale -> Bool) -> Eq Scale
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Scale -> Scale -> Bool
== :: Scale -> Scale -> Bool
$c/= :: Scale -> Scale -> Bool
/= :: Scale -> Scale -> Bool
Eq, Eq Scale
Eq Scale =>
(Scale -> Scale -> Ordering)
-> (Scale -> Scale -> Bool)
-> (Scale -> Scale -> Bool)
-> (Scale -> Scale -> Bool)
-> (Scale -> Scale -> Bool)
-> (Scale -> Scale -> Scale)
-> (Scale -> Scale -> Scale)
-> Ord Scale
Scale -> Scale -> Bool
Scale -> Scale -> Ordering
Scale -> Scale -> Scale
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
$ccompare :: Scale -> Scale -> Ordering
compare :: Scale -> Scale -> Ordering
$c< :: Scale -> Scale -> Bool
< :: Scale -> Scale -> Bool
$c<= :: Scale -> Scale -> Bool
<= :: Scale -> Scale -> Bool
$c> :: Scale -> Scale -> Bool
> :: Scale -> Scale -> Bool
$c>= :: Scale -> Scale -> Bool
>= :: Scale -> Scale -> Bool
$cmax :: Scale -> Scale -> Scale
max :: Scale -> Scale -> Scale
$cmin :: Scale -> Scale -> Scale
min :: Scale -> Scale -> Scale
Ord, Typeable)

instance Default Scale where
    def :: Scale
def = CI Text -> OtherParams -> Scale
Scale CI Text
"GREGORIAN" OtherParams
forall a. Default a => a
def

-- | Method. 3.7.2.
data Method = Method
    { Method -> CI Text
methodValue :: CI Text -- TODO: iTIP, RFC5546
    , Method -> OtherParams
methodOther :: OtherParams
    } deriving (Int -> Method -> ShowS
[Method] -> ShowS
Method -> String
(Int -> Method -> ShowS)
-> (Method -> String) -> ([Method] -> ShowS) -> Show Method
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Method -> ShowS
showsPrec :: Int -> Method -> ShowS
$cshow :: Method -> String
show :: Method -> String
$cshowList :: [Method] -> ShowS
showList :: [Method] -> ShowS
Show, Method -> Method -> Bool
(Method -> Method -> Bool)
-> (Method -> Method -> Bool) -> Eq Method
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Method -> Method -> Bool
== :: Method -> Method -> Bool
$c/= :: Method -> Method -> Bool
/= :: Method -> Method -> Bool
Eq, Eq Method
Eq Method =>
(Method -> Method -> Ordering)
-> (Method -> Method -> Bool)
-> (Method -> Method -> Bool)
-> (Method -> Method -> Bool)
-> (Method -> Method -> Bool)
-> (Method -> Method -> Method)
-> (Method -> Method -> Method)
-> Ord Method
Method -> Method -> Bool
Method -> Method -> Ordering
Method -> Method -> Method
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
$ccompare :: Method -> Method -> Ordering
compare :: Method -> Method -> Ordering
$c< :: Method -> Method -> Bool
< :: Method -> Method -> Bool
$c<= :: Method -> Method -> Bool
<= :: Method -> Method -> Bool
$c> :: Method -> Method -> Bool
> :: Method -> Method -> Bool
$c>= :: Method -> Method -> Bool
>= :: Method -> Method -> Bool
$cmax :: Method -> Method -> Method
max :: Method -> Method -> Method
$cmin :: Method -> Method -> Method
min :: Method -> Method -> Method
Ord, Typeable)

-- | Event Component. 3.6.1.
data VEvent = VEvent
    { VEvent -> DTStamp
veDTStamp       :: DTStamp
    , VEvent -> UID
veUID           :: UID
    , VEvent -> Class
veClass         :: Class -- ^ 'def' = 'Public'
    , VEvent -> Maybe DTStart
veDTStart       :: Maybe DTStart
    , VEvent -> Maybe Created
veCreated       :: Maybe Created
    , VEvent -> Maybe Description
veDescription   :: Maybe Description
    , VEvent -> Maybe Geo
veGeo           :: Maybe Geo
    , VEvent -> Maybe LastModified
veLastMod       :: Maybe LastModified
    , VEvent -> Maybe Location
veLocation      :: Maybe Location
    , VEvent -> Maybe Organizer
veOrganizer     :: Maybe Organizer
    , VEvent -> Priority
vePriority      :: Priority -- ^ 'def' = 0
    , VEvent -> Sequence
veSeq           :: Sequence -- ^ 'def' = 0
    , VEvent -> Maybe EventStatus
veStatus        :: Maybe EventStatus
    , VEvent -> Maybe Summary
veSummary       :: Maybe Summary
    , VEvent -> TimeTransparency
veTransp        :: TimeTransparency -- ^ 'def' = 'Opaque'
    , VEvent -> Maybe URL
veUrl           :: Maybe URL
    , VEvent -> Maybe RecurrenceId
veRecurId       :: Maybe RecurrenceId
    , VEvent -> Set RRule
veRRule         :: Set RRule
    , VEvent -> Maybe (Either DTEnd DurationProp)
veDTEndDuration :: Maybe (Either DTEnd DurationProp)
    , VEvent -> Set Attachment
veAttach        :: Set Attachment
    , VEvent -> Set Attendee
veAttendee      :: Set Attendee
    , VEvent -> Set Categories
veCategories    :: Set Categories
    , VEvent -> Set Comment
veComment       :: Set Comment
    , VEvent -> Set Contact
veContact       :: Set Contact
    , VEvent -> Set ExDate
veExDate        :: Set ExDate
    , VEvent -> Set RequestStatus
veRStatus       :: Set RequestStatus
    , VEvent -> Set RelatedTo
veRelated       :: Set RelatedTo
    , VEvent -> Set Resources
veResources     :: Set Resources
    , VEvent -> Set RDate
veRDate         :: Set RDate
    , VEvent -> Set VAlarm
veAlarms        :: Set VAlarm
    , VEvent -> Set OtherProperty
veOther         :: Set OtherProperty
    } deriving (Int -> VEvent -> ShowS
[VEvent] -> ShowS
VEvent -> String
(Int -> VEvent -> ShowS)
-> (VEvent -> String) -> ([VEvent] -> ShowS) -> Show VEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VEvent -> ShowS
showsPrec :: Int -> VEvent -> ShowS
$cshow :: VEvent -> String
show :: VEvent -> String
$cshowList :: [VEvent] -> ShowS
showList :: [VEvent] -> ShowS
Show, VEvent -> VEvent -> Bool
(VEvent -> VEvent -> Bool)
-> (VEvent -> VEvent -> Bool) -> Eq VEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VEvent -> VEvent -> Bool
== :: VEvent -> VEvent -> Bool
$c/= :: VEvent -> VEvent -> Bool
/= :: VEvent -> VEvent -> Bool
Eq, Eq VEvent
Eq VEvent =>
(VEvent -> VEvent -> Ordering)
-> (VEvent -> VEvent -> Bool)
-> (VEvent -> VEvent -> Bool)
-> (VEvent -> VEvent -> Bool)
-> (VEvent -> VEvent -> Bool)
-> (VEvent -> VEvent -> VEvent)
-> (VEvent -> VEvent -> VEvent)
-> Ord VEvent
VEvent -> VEvent -> Bool
VEvent -> VEvent -> Ordering
VEvent -> VEvent -> VEvent
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
$ccompare :: VEvent -> VEvent -> Ordering
compare :: VEvent -> VEvent -> Ordering
$c< :: VEvent -> VEvent -> Bool
< :: VEvent -> VEvent -> Bool
$c<= :: VEvent -> VEvent -> Bool
<= :: VEvent -> VEvent -> Bool
$c> :: VEvent -> VEvent -> Bool
> :: VEvent -> VEvent -> Bool
$c>= :: VEvent -> VEvent -> Bool
>= :: VEvent -> VEvent -> Bool
$cmax :: VEvent -> VEvent -> VEvent
max :: VEvent -> VEvent -> VEvent
$cmin :: VEvent -> VEvent -> VEvent
min :: VEvent -> VEvent -> VEvent
Ord, Typeable)

-- | To-Do Component. 3.6.2
data VTodo = VTodo
    { VTodo -> DTStamp
vtDTStamp     :: DTStamp
    , VTodo -> UID
vtUID         :: UID
    , VTodo -> Class
vtClass       :: Class -- ^ 'def' = 'Public'
    , VTodo -> Maybe Completed
vtCompleted   :: Maybe Completed
    , VTodo -> Maybe Created
vtCreated     :: Maybe Created
    , VTodo -> Maybe Description
vtDescription :: Maybe Description
    , VTodo -> Maybe DTStart
vtDTStart     :: Maybe DTStart
    , VTodo -> Maybe Geo
vtGeo         :: Maybe Geo
    , VTodo -> Maybe LastModified
vtLastMod     :: Maybe LastModified
    , VTodo -> Maybe Location
vtLocation    :: Maybe Location
    , VTodo -> Maybe Organizer
vtOrganizer   :: Maybe Organizer
    , VTodo -> Maybe PercentComplete
vtPercent     :: Maybe PercentComplete
    , VTodo -> Priority
vtPriority    :: Priority -- ^ 'def' = 0
    , VTodo -> Maybe RecurrenceId
vtRecurId     :: Maybe RecurrenceId
    , VTodo -> Sequence
vtSeq         :: Sequence -- ^ 'def' = 0
    , VTodo -> Maybe TodoStatus
vtStatus      :: Maybe TodoStatus
    , VTodo -> Maybe Summary
vtSummary     :: Maybe Summary
    , VTodo -> Maybe URL
vtUrl         :: Maybe URL
    , VTodo -> Set RRule
vtRRule       :: Set RRule
    , VTodo -> Maybe (Either Due DurationProp)
vtDueDuration :: Maybe (Either Due DurationProp)
    , VTodo -> Set Attachment
vtAttach      :: Set Attachment
    , VTodo -> Set Attendee
vtAttendee    :: Set Attendee
    , VTodo -> Set Categories
vtCategories  :: Set Categories
    , VTodo -> Set Comment
vtComment     :: Set Comment
    , VTodo -> Set Contact
vtContact     :: Set Contact
    , VTodo -> Set ExDate
vtExDate      :: Set ExDate
    , VTodo -> Set RequestStatus
vtRStatus     :: Set RequestStatus
    , VTodo -> Set RelatedTo
vtRelated     :: Set RelatedTo
    , VTodo -> Set Resources
vtResources   :: Set Resources
    , VTodo -> Set RDate
vtRDate       :: Set RDate
    , VTodo -> Set VAlarm
vtAlarms      :: Set VAlarm
    , VTodo -> Set OtherProperty
vtOther       :: Set OtherProperty
    } deriving (Int -> VTodo -> ShowS
[VTodo] -> ShowS
VTodo -> String
(Int -> VTodo -> ShowS)
-> (VTodo -> String) -> ([VTodo] -> ShowS) -> Show VTodo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VTodo -> ShowS
showsPrec :: Int -> VTodo -> ShowS
$cshow :: VTodo -> String
show :: VTodo -> String
$cshowList :: [VTodo] -> ShowS
showList :: [VTodo] -> ShowS
Show, VTodo -> VTodo -> Bool
(VTodo -> VTodo -> Bool) -> (VTodo -> VTodo -> Bool) -> Eq VTodo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VTodo -> VTodo -> Bool
== :: VTodo -> VTodo -> Bool
$c/= :: VTodo -> VTodo -> Bool
/= :: VTodo -> VTodo -> Bool
Eq, Eq VTodo
Eq VTodo =>
(VTodo -> VTodo -> Ordering)
-> (VTodo -> VTodo -> Bool)
-> (VTodo -> VTodo -> Bool)
-> (VTodo -> VTodo -> Bool)
-> (VTodo -> VTodo -> Bool)
-> (VTodo -> VTodo -> VTodo)
-> (VTodo -> VTodo -> VTodo)
-> Ord VTodo
VTodo -> VTodo -> Bool
VTodo -> VTodo -> Ordering
VTodo -> VTodo -> VTodo
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
$ccompare :: VTodo -> VTodo -> Ordering
compare :: VTodo -> VTodo -> Ordering
$c< :: VTodo -> VTodo -> Bool
< :: VTodo -> VTodo -> Bool
$c<= :: VTodo -> VTodo -> Bool
<= :: VTodo -> VTodo -> Bool
$c> :: VTodo -> VTodo -> Bool
> :: VTodo -> VTodo -> Bool
$c>= :: VTodo -> VTodo -> Bool
>= :: VTodo -> VTodo -> Bool
$cmax :: VTodo -> VTodo -> VTodo
max :: VTodo -> VTodo -> VTodo
$cmin :: VTodo -> VTodo -> VTodo
min :: VTodo -> VTodo -> VTodo
Ord, Typeable)

-- | Journal Component. 3.6.3
data VJournal = VJournal
    { VJournal -> DTStamp
vjDTStamp     :: DTStamp
    , VJournal -> UID
vjUID         :: UID
    , VJournal -> Class
vjClass       :: Class -- ^ 'def' = 'Public'
    , VJournal -> Maybe Created
vjCreated     :: Maybe Created
    , VJournal -> Maybe DTStart
vjDTStart     :: Maybe DTStart
    , VJournal -> Maybe LastModified
vjLastMod     :: Maybe LastModified
    , VJournal -> Maybe Organizer
vjOrganizer   :: Maybe Organizer
    , VJournal -> Maybe RecurrenceId
vjRecurId     :: Maybe RecurrenceId
    , VJournal -> Sequence
vjSeq         :: Sequence -- ^ 'def' = 0
    , VJournal -> Maybe JournalStatus
vjStatus      :: Maybe JournalStatus
    , VJournal -> Maybe Summary
vjSummary     :: Maybe Summary
    , VJournal -> Maybe URL
vjUrl         :: Maybe URL
    , VJournal -> Set RRule
vjRRule       :: Set RRule
    , VJournal -> Set Attachment
vjAttach      :: Set Attachment
    , VJournal -> Set Attendee
vjAttendee    :: Set Attendee
    , VJournal -> Set Categories
vjCategories  :: Set Categories
    , VJournal -> Set Comment
vjComment     :: Set Comment
    , VJournal -> Set Contact
vjContact     :: Set Contact
    , VJournal -> Set Description
vjDescription :: Set Description
    , VJournal -> Set ExDate
vjExDate      :: Set ExDate
    , VJournal -> Set RelatedTo
vjRelated     :: Set RelatedTo
    , VJournal -> Set RDate
vjRDate       :: Set RDate
    , VJournal -> Set RequestStatus
vjRStatus     :: Set RequestStatus
    , VJournal -> Set OtherProperty
vjOther       :: Set OtherProperty
    } deriving (Int -> VJournal -> ShowS
[VJournal] -> ShowS
VJournal -> String
(Int -> VJournal -> ShowS)
-> (VJournal -> String) -> ([VJournal] -> ShowS) -> Show VJournal
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VJournal -> ShowS
showsPrec :: Int -> VJournal -> ShowS
$cshow :: VJournal -> String
show :: VJournal -> String
$cshowList :: [VJournal] -> ShowS
showList :: [VJournal] -> ShowS
Show, VJournal -> VJournal -> Bool
(VJournal -> VJournal -> Bool)
-> (VJournal -> VJournal -> Bool) -> Eq VJournal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VJournal -> VJournal -> Bool
== :: VJournal -> VJournal -> Bool
$c/= :: VJournal -> VJournal -> Bool
/= :: VJournal -> VJournal -> Bool
Eq, Eq VJournal
Eq VJournal =>
(VJournal -> VJournal -> Ordering)
-> (VJournal -> VJournal -> Bool)
-> (VJournal -> VJournal -> Bool)
-> (VJournal -> VJournal -> Bool)
-> (VJournal -> VJournal -> Bool)
-> (VJournal -> VJournal -> VJournal)
-> (VJournal -> VJournal -> VJournal)
-> Ord VJournal
VJournal -> VJournal -> Bool
VJournal -> VJournal -> Ordering
VJournal -> VJournal -> VJournal
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
$ccompare :: VJournal -> VJournal -> Ordering
compare :: VJournal -> VJournal -> Ordering
$c< :: VJournal -> VJournal -> Bool
< :: VJournal -> VJournal -> Bool
$c<= :: VJournal -> VJournal -> Bool
<= :: VJournal -> VJournal -> Bool
$c> :: VJournal -> VJournal -> Bool
> :: VJournal -> VJournal -> Bool
$c>= :: VJournal -> VJournal -> Bool
>= :: VJournal -> VJournal -> Bool
$cmax :: VJournal -> VJournal -> VJournal
max :: VJournal -> VJournal -> VJournal
$cmin :: VJournal -> VJournal -> VJournal
min :: VJournal -> VJournal -> VJournal
Ord, Typeable)

-- | Free/Busy Component. 3.6.4
data VFreeBusy = VFreeBusy
    { VFreeBusy -> DTStamp
vfbDTStamp   :: DTStamp
    , VFreeBusy -> UID
vfbUID       :: UID
    , VFreeBusy -> Maybe Contact
vfbContact   :: Maybe Contact
    , VFreeBusy -> Maybe DTStart
vfbDTStart   :: Maybe DTStart
    , VFreeBusy -> Maybe DTEnd
vfbDTEnd     :: Maybe DTEnd
    , VFreeBusy -> Maybe Organizer
vfbOrganizer :: Maybe Organizer
    , VFreeBusy -> Maybe URL
vfbUrl       :: Maybe URL
    , VFreeBusy -> Set Attendee
vfbAttendee  :: Set Attendee
    , VFreeBusy -> Set Comment
vfbComment   :: Set Comment
    , VFreeBusy -> Set FreeBusy
vfbFreeBusy  :: Set FreeBusy
    , VFreeBusy -> Set RequestStatus
vfbRStatus   :: Set RequestStatus
    , VFreeBusy -> Set OtherProperty
vfbOther     :: Set OtherProperty
    } deriving (Int -> VFreeBusy -> ShowS
[VFreeBusy] -> ShowS
VFreeBusy -> String
(Int -> VFreeBusy -> ShowS)
-> (VFreeBusy -> String)
-> ([VFreeBusy] -> ShowS)
-> Show VFreeBusy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VFreeBusy -> ShowS
showsPrec :: Int -> VFreeBusy -> ShowS
$cshow :: VFreeBusy -> String
show :: VFreeBusy -> String
$cshowList :: [VFreeBusy] -> ShowS
showList :: [VFreeBusy] -> ShowS
Show, VFreeBusy -> VFreeBusy -> Bool
(VFreeBusy -> VFreeBusy -> Bool)
-> (VFreeBusy -> VFreeBusy -> Bool) -> Eq VFreeBusy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VFreeBusy -> VFreeBusy -> Bool
== :: VFreeBusy -> VFreeBusy -> Bool
$c/= :: VFreeBusy -> VFreeBusy -> Bool
/= :: VFreeBusy -> VFreeBusy -> Bool
Eq, Eq VFreeBusy
Eq VFreeBusy =>
(VFreeBusy -> VFreeBusy -> Ordering)
-> (VFreeBusy -> VFreeBusy -> Bool)
-> (VFreeBusy -> VFreeBusy -> Bool)
-> (VFreeBusy -> VFreeBusy -> Bool)
-> (VFreeBusy -> VFreeBusy -> Bool)
-> (VFreeBusy -> VFreeBusy -> VFreeBusy)
-> (VFreeBusy -> VFreeBusy -> VFreeBusy)
-> Ord VFreeBusy
VFreeBusy -> VFreeBusy -> Bool
VFreeBusy -> VFreeBusy -> Ordering
VFreeBusy -> VFreeBusy -> VFreeBusy
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
$ccompare :: VFreeBusy -> VFreeBusy -> Ordering
compare :: VFreeBusy -> VFreeBusy -> Ordering
$c< :: VFreeBusy -> VFreeBusy -> Bool
< :: VFreeBusy -> VFreeBusy -> Bool
$c<= :: VFreeBusy -> VFreeBusy -> Bool
<= :: VFreeBusy -> VFreeBusy -> Bool
$c> :: VFreeBusy -> VFreeBusy -> Bool
> :: VFreeBusy -> VFreeBusy -> Bool
$c>= :: VFreeBusy -> VFreeBusy -> Bool
>= :: VFreeBusy -> VFreeBusy -> Bool
$cmax :: VFreeBusy -> VFreeBusy -> VFreeBusy
max :: VFreeBusy -> VFreeBusy -> VFreeBusy
$cmin :: VFreeBusy -> VFreeBusy -> VFreeBusy
min :: VFreeBusy -> VFreeBusy -> VFreeBusy
Ord, Typeable)

-- | Time Zone Component. 3.6.5.
data VTimeZone = VTimeZone
    { VTimeZone -> TZID
vtzId        :: TZID
    , VTimeZone -> Maybe LastModified
vtzLastMod   :: Maybe LastModified
    , VTimeZone -> Maybe TZUrl
vtzUrl       :: Maybe TZUrl
    , VTimeZone -> Set TZProp
vtzStandardC :: Set TZProp
    , VTimeZone -> Set TZProp
vtzDaylightC :: Set TZProp
    , VTimeZone -> Set OtherProperty
vtzOther     :: Set OtherProperty
    } deriving (Int -> VTimeZone -> ShowS
[VTimeZone] -> ShowS
VTimeZone -> String
(Int -> VTimeZone -> ShowS)
-> (VTimeZone -> String)
-> ([VTimeZone] -> ShowS)
-> Show VTimeZone
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VTimeZone -> ShowS
showsPrec :: Int -> VTimeZone -> ShowS
$cshow :: VTimeZone -> String
show :: VTimeZone -> String
$cshowList :: [VTimeZone] -> ShowS
showList :: [VTimeZone] -> ShowS
Show, VTimeZone -> VTimeZone -> Bool
(VTimeZone -> VTimeZone -> Bool)
-> (VTimeZone -> VTimeZone -> Bool) -> Eq VTimeZone
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VTimeZone -> VTimeZone -> Bool
== :: VTimeZone -> VTimeZone -> Bool
$c/= :: VTimeZone -> VTimeZone -> Bool
/= :: VTimeZone -> VTimeZone -> Bool
Eq, Eq VTimeZone
Eq VTimeZone =>
(VTimeZone -> VTimeZone -> Ordering)
-> (VTimeZone -> VTimeZone -> Bool)
-> (VTimeZone -> VTimeZone -> Bool)
-> (VTimeZone -> VTimeZone -> Bool)
-> (VTimeZone -> VTimeZone -> Bool)
-> (VTimeZone -> VTimeZone -> VTimeZone)
-> (VTimeZone -> VTimeZone -> VTimeZone)
-> Ord VTimeZone
VTimeZone -> VTimeZone -> Bool
VTimeZone -> VTimeZone -> Ordering
VTimeZone -> VTimeZone -> VTimeZone
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
$ccompare :: VTimeZone -> VTimeZone -> Ordering
compare :: VTimeZone -> VTimeZone -> Ordering
$c< :: VTimeZone -> VTimeZone -> Bool
< :: VTimeZone -> VTimeZone -> Bool
$c<= :: VTimeZone -> VTimeZone -> Bool
<= :: VTimeZone -> VTimeZone -> Bool
$c> :: VTimeZone -> VTimeZone -> Bool
> :: VTimeZone -> VTimeZone -> Bool
$c>= :: VTimeZone -> VTimeZone -> Bool
>= :: VTimeZone -> VTimeZone -> Bool
$cmax :: VTimeZone -> VTimeZone -> VTimeZone
max :: VTimeZone -> VTimeZone -> VTimeZone
$cmin :: VTimeZone -> VTimeZone -> VTimeZone
min :: VTimeZone -> VTimeZone -> VTimeZone
Ord, Typeable)

-- | Time zone property, also 3.6.5.
data TZProp = TZProp
    { TZProp -> DTStart
tzpDTStart      :: DTStart
    , TZProp -> UTCOffset
tzpTZOffsetTo   :: UTCOffset
    , TZProp -> UTCOffset
tzpTZOffsetFrom :: UTCOffset
    , TZProp -> Set RRule
tzpRRule        :: Set RRule -- SHOULD NOT have multiple RRules.
    , TZProp -> Set Comment
tzpComment      :: Set Comment
    , TZProp -> Set RDate
tzpRDate        :: Set RDate
    , TZProp -> Set TZName
tzpTZName       :: Set TZName
    , TZProp -> Set OtherProperty
tzpOther        :: Set OtherProperty
    } deriving (Int -> TZProp -> ShowS
[TZProp] -> ShowS
TZProp -> String
(Int -> TZProp -> ShowS)
-> (TZProp -> String) -> ([TZProp] -> ShowS) -> Show TZProp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TZProp -> ShowS
showsPrec :: Int -> TZProp -> ShowS
$cshow :: TZProp -> String
show :: TZProp -> String
$cshowList :: [TZProp] -> ShowS
showList :: [TZProp] -> ShowS
Show, TZProp -> TZProp -> Bool
(TZProp -> TZProp -> Bool)
-> (TZProp -> TZProp -> Bool) -> Eq TZProp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TZProp -> TZProp -> Bool
== :: TZProp -> TZProp -> Bool
$c/= :: TZProp -> TZProp -> Bool
/= :: TZProp -> TZProp -> Bool
Eq, Eq TZProp
Eq TZProp =>
(TZProp -> TZProp -> Ordering)
-> (TZProp -> TZProp -> Bool)
-> (TZProp -> TZProp -> Bool)
-> (TZProp -> TZProp -> Bool)
-> (TZProp -> TZProp -> Bool)
-> (TZProp -> TZProp -> TZProp)
-> (TZProp -> TZProp -> TZProp)
-> Ord TZProp
TZProp -> TZProp -> Bool
TZProp -> TZProp -> Ordering
TZProp -> TZProp -> TZProp
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
$ccompare :: TZProp -> TZProp -> Ordering
compare :: TZProp -> TZProp -> Ordering
$c< :: TZProp -> TZProp -> Bool
< :: TZProp -> TZProp -> Bool
$c<= :: TZProp -> TZProp -> Bool
<= :: TZProp -> TZProp -> Bool
$c> :: TZProp -> TZProp -> Bool
> :: TZProp -> TZProp -> Bool
$c>= :: TZProp -> TZProp -> Bool
>= :: TZProp -> TZProp -> Bool
$cmax :: TZProp -> TZProp -> TZProp
max :: TZProp -> TZProp -> TZProp
$cmin :: TZProp -> TZProp -> TZProp
min :: TZProp -> TZProp -> TZProp
Ord, Typeable)

-- | VAlarm component. 3.6.6.
data VAlarm
    = VAlarmAudio
    { VAlarm -> Trigger
vaTrigger     :: Trigger
    , VAlarm -> Repeat
vaRepeat      :: Repeat -- ^ 'def' = 0
    , VAlarm -> Maybe DurationProp
vaDuration    :: Maybe DurationProp
    , VAlarm -> Maybe Attachment
vaAudioAttach :: Maybe Attachment
    , VAlarm -> Set OtherProperty
vaOther       :: Set OtherProperty
    , VAlarm -> OtherParams
vaActionOther :: OtherParams
    }
    | VAlarmDisplay
    { VAlarm -> Description
vaDescription :: Description
    , vaTrigger     :: Trigger
    , vaRepeat      :: Repeat
    , vaDuration    :: Maybe DurationProp
    , vaOther       :: Set OtherProperty
    , vaActionOther :: OtherParams
    }
    | VAlarmEmail
    { vaDescription :: Description
    , vaTrigger     :: Trigger
    , VAlarm -> Summary
vaSummary     :: Summary
    , VAlarm -> Set Attendee
vaAttendee    :: Set Attendee
    , vaRepeat      :: Repeat
    , vaDuration    :: Maybe DurationProp
    , VAlarm -> Set Attachment
vaMailAttach  :: Set Attachment
    , vaOther       :: Set OtherProperty
    , vaActionOther :: OtherParams
    }
    | VAlarmX
    { VAlarm -> CI Text
vaAction      :: CI Text
    , vaTrigger     :: Trigger
    , vaActionOther :: OtherParams
    , vaOther       :: Set OtherProperty
    } deriving (Int -> VAlarm -> ShowS
[VAlarm] -> ShowS
VAlarm -> String
(Int -> VAlarm -> ShowS)
-> (VAlarm -> String) -> ([VAlarm] -> ShowS) -> Show VAlarm
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VAlarm -> ShowS
showsPrec :: Int -> VAlarm -> ShowS
$cshow :: VAlarm -> String
show :: VAlarm -> String
$cshowList :: [VAlarm] -> ShowS
showList :: [VAlarm] -> ShowS
Show, VAlarm -> VAlarm -> Bool
(VAlarm -> VAlarm -> Bool)
-> (VAlarm -> VAlarm -> Bool) -> Eq VAlarm
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VAlarm -> VAlarm -> Bool
== :: VAlarm -> VAlarm -> Bool
$c/= :: VAlarm -> VAlarm -> Bool
/= :: VAlarm -> VAlarm -> Bool
Eq, Eq VAlarm
Eq VAlarm =>
(VAlarm -> VAlarm -> Ordering)
-> (VAlarm -> VAlarm -> Bool)
-> (VAlarm -> VAlarm -> Bool)
-> (VAlarm -> VAlarm -> Bool)
-> (VAlarm -> VAlarm -> Bool)
-> (VAlarm -> VAlarm -> VAlarm)
-> (VAlarm -> VAlarm -> VAlarm)
-> Ord VAlarm
VAlarm -> VAlarm -> Bool
VAlarm -> VAlarm -> Ordering
VAlarm -> VAlarm -> VAlarm
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
$ccompare :: VAlarm -> VAlarm -> Ordering
compare :: VAlarm -> VAlarm -> Ordering
$c< :: VAlarm -> VAlarm -> Bool
< :: VAlarm -> VAlarm -> Bool
$c<= :: VAlarm -> VAlarm -> Bool
<= :: VAlarm -> VAlarm -> Bool
$c> :: VAlarm -> VAlarm -> Bool
> :: VAlarm -> VAlarm -> Bool
$c>= :: VAlarm -> VAlarm -> Bool
>= :: VAlarm -> VAlarm -> Bool
$cmax :: VAlarm -> VAlarm -> VAlarm
max :: VAlarm -> VAlarm -> VAlarm
$cmin :: VAlarm -> VAlarm -> VAlarm
min :: VAlarm -> VAlarm -> VAlarm
Ord, Typeable)

-- | Any other component not recognized.
data VOther = VOther
    { VOther -> CI Text
voName  :: CI Text
    , VOther -> Set OtherProperty
voProps :: Set OtherProperty
    } deriving (Int -> VOther -> ShowS
[VOther] -> ShowS
VOther -> String
(Int -> VOther -> ShowS)
-> (VOther -> String) -> ([VOther] -> ShowS) -> Show VOther
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VOther -> ShowS
showsPrec :: Int -> VOther -> ShowS
$cshow :: VOther -> String
show :: VOther -> String
$cshowList :: [VOther] -> ShowS
showList :: [VOther] -> ShowS
Show, VOther -> VOther -> Bool
(VOther -> VOther -> Bool)
-> (VOther -> VOther -> Bool) -> Eq VOther
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VOther -> VOther -> Bool
== :: VOther -> VOther -> Bool
$c/= :: VOther -> VOther -> Bool
/= :: VOther -> VOther -> Bool
Eq, Eq VOther
Eq VOther =>
(VOther -> VOther -> Ordering)
-> (VOther -> VOther -> Bool)
-> (VOther -> VOther -> Bool)
-> (VOther -> VOther -> Bool)
-> (VOther -> VOther -> Bool)
-> (VOther -> VOther -> VOther)
-> (VOther -> VOther -> VOther)
-> Ord VOther
VOther -> VOther -> Bool
VOther -> VOther -> Ordering
VOther -> VOther -> VOther
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
$ccompare :: VOther -> VOther -> Ordering
compare :: VOther -> VOther -> Ordering
$c< :: VOther -> VOther -> Bool
< :: VOther -> VOther -> Bool
$c<= :: VOther -> VOther -> Bool
<= :: VOther -> VOther -> Bool
$c> :: VOther -> VOther -> Bool
> :: VOther -> VOther -> Bool
$c>= :: VOther -> VOther -> Bool
>= :: VOther -> VOther -> Bool
$cmax :: VOther -> VOther -> VOther
max :: VOther -> VOther -> VOther
$cmin :: VOther -> VOther -> VOther
min :: VOther -> VOther -> VOther
Ord, Typeable)

-- | Attachment. 3.8.1.1.
data Attachment
    = UriAttachment
    { Attachment -> Maybe MIMEType
attachFmtType :: Maybe MIMEType
    , Attachment -> URI
attachUri     :: URI
    , Attachment -> OtherParams
attachOther   :: OtherParams
    }
    | BinaryAttachment
    { attachFmtType :: Maybe MIMEType
    , Attachment -> ByteString
attachContent :: ByteString
    , attachOther   :: OtherParams
    } deriving (Int -> Attachment -> ShowS
[Attachment] -> ShowS
Attachment -> String
(Int -> Attachment -> ShowS)
-> (Attachment -> String)
-> ([Attachment] -> ShowS)
-> Show Attachment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Attachment -> ShowS
showsPrec :: Int -> Attachment -> ShowS
$cshow :: Attachment -> String
show :: Attachment -> String
$cshowList :: [Attachment] -> ShowS
showList :: [Attachment] -> ShowS
Show, Attachment -> Attachment -> Bool
(Attachment -> Attachment -> Bool)
-> (Attachment -> Attachment -> Bool) -> Eq Attachment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Attachment -> Attachment -> Bool
== :: Attachment -> Attachment -> Bool
$c/= :: Attachment -> Attachment -> Bool
/= :: Attachment -> Attachment -> Bool
Eq, Eq Attachment
Eq Attachment =>
(Attachment -> Attachment -> Ordering)
-> (Attachment -> Attachment -> Bool)
-> (Attachment -> Attachment -> Bool)
-> (Attachment -> Attachment -> Bool)
-> (Attachment -> Attachment -> Bool)
-> (Attachment -> Attachment -> Attachment)
-> (Attachment -> Attachment -> Attachment)
-> Ord Attachment
Attachment -> Attachment -> Bool
Attachment -> Attachment -> Ordering
Attachment -> Attachment -> Attachment
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
$ccompare :: Attachment -> Attachment -> Ordering
compare :: Attachment -> Attachment -> Ordering
$c< :: Attachment -> Attachment -> Bool
< :: Attachment -> Attachment -> Bool
$c<= :: Attachment -> Attachment -> Bool
<= :: Attachment -> Attachment -> Bool
$c> :: Attachment -> Attachment -> Bool
> :: Attachment -> Attachment -> Bool
$c>= :: Attachment -> Attachment -> Bool
>= :: Attachment -> Attachment -> Bool
$cmax :: Attachment -> Attachment -> Attachment
max :: Attachment -> Attachment -> Attachment
$cmin :: Attachment -> Attachment -> Attachment
min :: Attachment -> Attachment -> Attachment
Ord, Typeable)

-- | Categories. 3.8.1.2.
data Categories = Categories
    { Categories -> Set Text
categoriesValues   :: Set Text
    , Categories -> Maybe Language
categoriesLanguage :: Maybe Language
    , Categories -> OtherParams
categoriesOther    :: OtherParams
    } deriving (Int -> Categories -> ShowS
[Categories] -> ShowS
Categories -> String
(Int -> Categories -> ShowS)
-> (Categories -> String)
-> ([Categories] -> ShowS)
-> Show Categories
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Categories -> ShowS
showsPrec :: Int -> Categories -> ShowS
$cshow :: Categories -> String
show :: Categories -> String
$cshowList :: [Categories] -> ShowS
showList :: [Categories] -> ShowS
Show, Categories -> Categories -> Bool
(Categories -> Categories -> Bool)
-> (Categories -> Categories -> Bool) -> Eq Categories
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Categories -> Categories -> Bool
== :: Categories -> Categories -> Bool
$c/= :: Categories -> Categories -> Bool
/= :: Categories -> Categories -> Bool
Eq, Eq Categories
Eq Categories =>
(Categories -> Categories -> Ordering)
-> (Categories -> Categories -> Bool)
-> (Categories -> Categories -> Bool)
-> (Categories -> Categories -> Bool)
-> (Categories -> Categories -> Bool)
-> (Categories -> Categories -> Categories)
-> (Categories -> Categories -> Categories)
-> Ord Categories
Categories -> Categories -> Bool
Categories -> Categories -> Ordering
Categories -> Categories -> Categories
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
$ccompare :: Categories -> Categories -> Ordering
compare :: Categories -> Categories -> Ordering
$c< :: Categories -> Categories -> Bool
< :: Categories -> Categories -> Bool
$c<= :: Categories -> Categories -> Bool
<= :: Categories -> Categories -> Bool
$c> :: Categories -> Categories -> Bool
> :: Categories -> Categories -> Bool
$c>= :: Categories -> Categories -> Bool
>= :: Categories -> Categories -> Bool
$cmax :: Categories -> Categories -> Categories
max :: Categories -> Categories -> Categories
$cmin :: Categories -> Categories -> Categories
min :: Categories -> Categories -> Categories
Ord, Typeable)

-- | Classification. 3.8.1.3.
data Class = Class
    { Class -> ClassValue
classValue :: ClassValue
    , Class -> OtherParams
classOther :: OtherParams
    } deriving (Int -> Class -> ShowS
[Class] -> ShowS
Class -> String
(Int -> Class -> ShowS)
-> (Class -> String) -> ([Class] -> ShowS) -> Show Class
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Class -> ShowS
showsPrec :: Int -> Class -> ShowS
$cshow :: Class -> String
show :: Class -> String
$cshowList :: [Class] -> ShowS
showList :: [Class] -> ShowS
Show, Class -> Class -> Bool
(Class -> Class -> Bool) -> (Class -> Class -> Bool) -> Eq Class
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Class -> Class -> Bool
== :: Class -> Class -> Bool
$c/= :: Class -> Class -> Bool
/= :: Class -> Class -> Bool
Eq, Eq Class
Eq Class =>
(Class -> Class -> Ordering)
-> (Class -> Class -> Bool)
-> (Class -> Class -> Bool)
-> (Class -> Class -> Bool)
-> (Class -> Class -> Bool)
-> (Class -> Class -> Class)
-> (Class -> Class -> Class)
-> Ord Class
Class -> Class -> Bool
Class -> Class -> Ordering
Class -> Class -> Class
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
$ccompare :: Class -> Class -> Ordering
compare :: Class -> Class -> Ordering
$c< :: Class -> Class -> Bool
< :: Class -> Class -> Bool
$c<= :: Class -> Class -> Bool
<= :: Class -> Class -> Bool
$c> :: Class -> Class -> Bool
> :: Class -> Class -> Bool
$c>= :: Class -> Class -> Bool
>= :: Class -> Class -> Bool
$cmax :: Class -> Class -> Class
max :: Class -> Class -> Class
$cmin :: Class -> Class -> Class
min :: Class -> Class -> Class
Ord, Typeable)

instance Default Class where
    def :: Class
def = ClassValue -> OtherParams -> Class
Class ClassValue
forall a. Default a => a
def OtherParams
forall a. Default a => a
def

-- | Classification value. 3.8.1.3.
-- Unrecognized ClassValueX MUST be treated as Private.
data ClassValue
    = Public
    | Private
    | Confidential
    | ClassValueX (CI Text)
      deriving (Int -> ClassValue -> ShowS
[ClassValue] -> ShowS
ClassValue -> String
(Int -> ClassValue -> ShowS)
-> (ClassValue -> String)
-> ([ClassValue] -> ShowS)
-> Show ClassValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClassValue -> ShowS
showsPrec :: Int -> ClassValue -> ShowS
$cshow :: ClassValue -> String
show :: ClassValue -> String
$cshowList :: [ClassValue] -> ShowS
showList :: [ClassValue] -> ShowS
Show, ClassValue -> ClassValue -> Bool
(ClassValue -> ClassValue -> Bool)
-> (ClassValue -> ClassValue -> Bool) -> Eq ClassValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClassValue -> ClassValue -> Bool
== :: ClassValue -> ClassValue -> Bool
$c/= :: ClassValue -> ClassValue -> Bool
/= :: ClassValue -> ClassValue -> Bool
Eq, Eq ClassValue
Eq ClassValue =>
(ClassValue -> ClassValue -> Ordering)
-> (ClassValue -> ClassValue -> Bool)
-> (ClassValue -> ClassValue -> Bool)
-> (ClassValue -> ClassValue -> Bool)
-> (ClassValue -> ClassValue -> Bool)
-> (ClassValue -> ClassValue -> ClassValue)
-> (ClassValue -> ClassValue -> ClassValue)
-> Ord ClassValue
ClassValue -> ClassValue -> Bool
ClassValue -> ClassValue -> Ordering
ClassValue -> ClassValue -> ClassValue
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
$ccompare :: ClassValue -> ClassValue -> Ordering
compare :: ClassValue -> ClassValue -> Ordering
$c< :: ClassValue -> ClassValue -> Bool
< :: ClassValue -> ClassValue -> Bool
$c<= :: ClassValue -> ClassValue -> Bool
<= :: ClassValue -> ClassValue -> Bool
$c> :: ClassValue -> ClassValue -> Bool
> :: ClassValue -> ClassValue -> Bool
$c>= :: ClassValue -> ClassValue -> Bool
>= :: ClassValue -> ClassValue -> Bool
$cmax :: ClassValue -> ClassValue -> ClassValue
max :: ClassValue -> ClassValue -> ClassValue
$cmin :: ClassValue -> ClassValue -> ClassValue
min :: ClassValue -> ClassValue -> ClassValue
Ord, Typeable)

instance Default ClassValue where
    def :: ClassValue
def = ClassValue
Public

-- | Date-Time Completed. 3.8.2.1.
data Completed = Completed
    { Completed -> DateTime
completedValue :: DateTime
    , Completed -> OtherParams
completedOther :: OtherParams
    } deriving (Int -> Completed -> ShowS
[Completed] -> ShowS
Completed -> String
(Int -> Completed -> ShowS)
-> (Completed -> String)
-> ([Completed] -> ShowS)
-> Show Completed
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Completed -> ShowS
showsPrec :: Int -> Completed -> ShowS
$cshow :: Completed -> String
show :: Completed -> String
$cshowList :: [Completed] -> ShowS
showList :: [Completed] -> ShowS
Show, Completed -> Completed -> Bool
(Completed -> Completed -> Bool)
-> (Completed -> Completed -> Bool) -> Eq Completed
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Completed -> Completed -> Bool
== :: Completed -> Completed -> Bool
$c/= :: Completed -> Completed -> Bool
/= :: Completed -> Completed -> Bool
Eq, Eq Completed
Eq Completed =>
(Completed -> Completed -> Ordering)
-> (Completed -> Completed -> Bool)
-> (Completed -> Completed -> Bool)
-> (Completed -> Completed -> Bool)
-> (Completed -> Completed -> Bool)
-> (Completed -> Completed -> Completed)
-> (Completed -> Completed -> Completed)
-> Ord Completed
Completed -> Completed -> Bool
Completed -> Completed -> Ordering
Completed -> Completed -> Completed
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
$ccompare :: Completed -> Completed -> Ordering
compare :: Completed -> Completed -> Ordering
$c< :: Completed -> Completed -> Bool
< :: Completed -> Completed -> Bool
$c<= :: Completed -> Completed -> Bool
<= :: Completed -> Completed -> Bool
$c> :: Completed -> Completed -> Bool
> :: Completed -> Completed -> Bool
$c>= :: Completed -> Completed -> Bool
>= :: Completed -> Completed -> Bool
$cmax :: Completed -> Completed -> Completed
max :: Completed -> Completed -> Completed
$cmin :: Completed -> Completed -> Completed
min :: Completed -> Completed -> Completed
Ord, Typeable)

-- | Comment. 3.8.1.4.
data Comment = Comment
    { Comment -> Text
commentValue    :: Text
    , Comment -> Maybe URI
commentAltRep   :: Maybe URI
    , Comment -> Maybe Language
commentLanguage :: Maybe Language
    , Comment -> OtherParams
commentOther    :: OtherParams
    } deriving (Int -> Comment -> ShowS
[Comment] -> ShowS
Comment -> String
(Int -> Comment -> ShowS)
-> (Comment -> String) -> ([Comment] -> ShowS) -> Show Comment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Comment -> ShowS
showsPrec :: Int -> Comment -> ShowS
$cshow :: Comment -> String
show :: Comment -> String
$cshowList :: [Comment] -> ShowS
showList :: [Comment] -> ShowS
Show, Comment -> Comment -> Bool
(Comment -> Comment -> Bool)
-> (Comment -> Comment -> Bool) -> Eq Comment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Comment -> Comment -> Bool
== :: Comment -> Comment -> Bool
$c/= :: Comment -> Comment -> Bool
/= :: Comment -> Comment -> Bool
Eq, Eq Comment
Eq Comment =>
(Comment -> Comment -> Ordering)
-> (Comment -> Comment -> Bool)
-> (Comment -> Comment -> Bool)
-> (Comment -> Comment -> Bool)
-> (Comment -> Comment -> Bool)
-> (Comment -> Comment -> Comment)
-> (Comment -> Comment -> Comment)
-> Ord Comment
Comment -> Comment -> Bool
Comment -> Comment -> Ordering
Comment -> Comment -> Comment
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
$ccompare :: Comment -> Comment -> Ordering
compare :: Comment -> Comment -> Ordering
$c< :: Comment -> Comment -> Bool
< :: Comment -> Comment -> Bool
$c<= :: Comment -> Comment -> Bool
<= :: Comment -> Comment -> Bool
$c> :: Comment -> Comment -> Bool
> :: Comment -> Comment -> Bool
$c>= :: Comment -> Comment -> Bool
>= :: Comment -> Comment -> Bool
$cmax :: Comment -> Comment -> Comment
max :: Comment -> Comment -> Comment
$cmin :: Comment -> Comment -> Comment
min :: Comment -> Comment -> Comment
Ord, Typeable)

-- | Description. 3.8.1.5.
data Description = Description
    { Description -> Text
descriptionValue    :: Text
    , Description -> Maybe URI
descriptionAltRep   :: Maybe URI
    , Description -> Maybe Language
descriptionLanguage :: Maybe Language
    , Description -> OtherParams
descriptionOther    :: OtherParams
    } deriving (Int -> Description -> ShowS
[Description] -> ShowS
Description -> String
(Int -> Description -> ShowS)
-> (Description -> String)
-> ([Description] -> ShowS)
-> Show Description
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Description -> ShowS
showsPrec :: Int -> Description -> ShowS
$cshow :: Description -> String
show :: Description -> String
$cshowList :: [Description] -> ShowS
showList :: [Description] -> ShowS
Show, Description -> Description -> Bool
(Description -> Description -> Bool)
-> (Description -> Description -> Bool) -> Eq Description
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Description -> Description -> Bool
== :: Description -> Description -> Bool
$c/= :: Description -> Description -> Bool
/= :: Description -> Description -> Bool
Eq, Eq Description
Eq Description =>
(Description -> Description -> Ordering)
-> (Description -> Description -> Bool)
-> (Description -> Description -> Bool)
-> (Description -> Description -> Bool)
-> (Description -> Description -> Bool)
-> (Description -> Description -> Description)
-> (Description -> Description -> Description)
-> Ord Description
Description -> Description -> Bool
Description -> Description -> Ordering
Description -> Description -> Description
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
$ccompare :: Description -> Description -> Ordering
compare :: Description -> Description -> Ordering
$c< :: Description -> Description -> Bool
< :: Description -> Description -> Bool
$c<= :: Description -> Description -> Bool
<= :: Description -> Description -> Bool
$c> :: Description -> Description -> Bool
> :: Description -> Description -> Bool
$c>= :: Description -> Description -> Bool
>= :: Description -> Description -> Bool
$cmax :: Description -> Description -> Description
max :: Description -> Description -> Description
$cmin :: Description -> Description -> Description
min :: Description -> Description -> Description
Ord, Typeable)

-- | Geographic Position. 3.8.1.6.
data Geo = Geo
    { Geo -> Float
geoLat   :: Float
    , Geo -> Float
geoLong  :: Float
    , Geo -> OtherParams
geoOther :: OtherParams
    } deriving (Int -> Geo -> ShowS
[Geo] -> ShowS
Geo -> String
(Int -> Geo -> ShowS)
-> (Geo -> String) -> ([Geo] -> ShowS) -> Show Geo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Geo -> ShowS
showsPrec :: Int -> Geo -> ShowS
$cshow :: Geo -> String
show :: Geo -> String
$cshowList :: [Geo] -> ShowS
showList :: [Geo] -> ShowS
Show, Geo -> Geo -> Bool
(Geo -> Geo -> Bool) -> (Geo -> Geo -> Bool) -> Eq Geo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Geo -> Geo -> Bool
== :: Geo -> Geo -> Bool
$c/= :: Geo -> Geo -> Bool
/= :: Geo -> Geo -> Bool
Eq, Eq Geo
Eq Geo =>
(Geo -> Geo -> Ordering)
-> (Geo -> Geo -> Bool)
-> (Geo -> Geo -> Bool)
-> (Geo -> Geo -> Bool)
-> (Geo -> Geo -> Bool)
-> (Geo -> Geo -> Geo)
-> (Geo -> Geo -> Geo)
-> Ord Geo
Geo -> Geo -> Bool
Geo -> Geo -> Ordering
Geo -> Geo -> Geo
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
$ccompare :: Geo -> Geo -> Ordering
compare :: Geo -> Geo -> Ordering
$c< :: Geo -> Geo -> Bool
< :: Geo -> Geo -> Bool
$c<= :: Geo -> Geo -> Bool
<= :: Geo -> Geo -> Bool
$c> :: Geo -> Geo -> Bool
> :: Geo -> Geo -> Bool
$c>= :: Geo -> Geo -> Bool
>= :: Geo -> Geo -> Bool
$cmax :: Geo -> Geo -> Geo
max :: Geo -> Geo -> Geo
$cmin :: Geo -> Geo -> Geo
min :: Geo -> Geo -> Geo
Ord, Typeable)

-- | Location. 3.8.1.7.
data Location = Location
    { Location -> Text
locationValue    :: Text
    , Location -> Maybe URI
locationAltRep   :: Maybe URI
    , Location -> Maybe Language
locationLanguage :: Maybe Language
    , Location -> OtherParams
locationOther    :: OtherParams
    } deriving (Int -> Location -> ShowS
[Location] -> ShowS
Location -> String
(Int -> Location -> ShowS)
-> (Location -> String) -> ([Location] -> ShowS) -> Show Location
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Location -> ShowS
showsPrec :: Int -> Location -> ShowS
$cshow :: Location -> String
show :: Location -> String
$cshowList :: [Location] -> ShowS
showList :: [Location] -> ShowS
Show, Location -> Location -> Bool
(Location -> Location -> Bool)
-> (Location -> Location -> Bool) -> Eq Location
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Location -> Location -> Bool
== :: Location -> Location -> Bool
$c/= :: Location -> Location -> Bool
/= :: Location -> Location -> Bool
Eq, Eq Location
Eq Location =>
(Location -> Location -> Ordering)
-> (Location -> Location -> Bool)
-> (Location -> Location -> Bool)
-> (Location -> Location -> Bool)
-> (Location -> Location -> Bool)
-> (Location -> Location -> Location)
-> (Location -> Location -> Location)
-> Ord Location
Location -> Location -> Bool
Location -> Location -> Ordering
Location -> Location -> Location
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
$ccompare :: Location -> Location -> Ordering
compare :: Location -> Location -> Ordering
$c< :: Location -> Location -> Bool
< :: Location -> Location -> Bool
$c<= :: Location -> Location -> Bool
<= :: Location -> Location -> Bool
$c> :: Location -> Location -> Bool
> :: Location -> Location -> Bool
$c>= :: Location -> Location -> Bool
>= :: Location -> Location -> Bool
$cmax :: Location -> Location -> Location
max :: Location -> Location -> Location
$cmin :: Location -> Location -> Location
min :: Location -> Location -> Location
Ord, Typeable)

-- | Percent complete. 3.8.1.8.
data PercentComplete = PercentComplete
    { PercentComplete -> Int
percentCompleteValue :: Int
    , PercentComplete -> OtherParams
percentCompleteOther :: OtherParams
    } deriving (Int -> PercentComplete -> ShowS
[PercentComplete] -> ShowS
PercentComplete -> String
(Int -> PercentComplete -> ShowS)
-> (PercentComplete -> String)
-> ([PercentComplete] -> ShowS)
-> Show PercentComplete
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PercentComplete -> ShowS
showsPrec :: Int -> PercentComplete -> ShowS
$cshow :: PercentComplete -> String
show :: PercentComplete -> String
$cshowList :: [PercentComplete] -> ShowS
showList :: [PercentComplete] -> ShowS
Show, PercentComplete -> PercentComplete -> Bool
(PercentComplete -> PercentComplete -> Bool)
-> (PercentComplete -> PercentComplete -> Bool)
-> Eq PercentComplete
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PercentComplete -> PercentComplete -> Bool
== :: PercentComplete -> PercentComplete -> Bool
$c/= :: PercentComplete -> PercentComplete -> Bool
/= :: PercentComplete -> PercentComplete -> Bool
Eq, Eq PercentComplete
Eq PercentComplete =>
(PercentComplete -> PercentComplete -> Ordering)
-> (PercentComplete -> PercentComplete -> Bool)
-> (PercentComplete -> PercentComplete -> Bool)
-> (PercentComplete -> PercentComplete -> Bool)
-> (PercentComplete -> PercentComplete -> Bool)
-> (PercentComplete -> PercentComplete -> PercentComplete)
-> (PercentComplete -> PercentComplete -> PercentComplete)
-> Ord PercentComplete
PercentComplete -> PercentComplete -> Bool
PercentComplete -> PercentComplete -> Ordering
PercentComplete -> PercentComplete -> PercentComplete
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
$ccompare :: PercentComplete -> PercentComplete -> Ordering
compare :: PercentComplete -> PercentComplete -> Ordering
$c< :: PercentComplete -> PercentComplete -> Bool
< :: PercentComplete -> PercentComplete -> Bool
$c<= :: PercentComplete -> PercentComplete -> Bool
<= :: PercentComplete -> PercentComplete -> Bool
$c> :: PercentComplete -> PercentComplete -> Bool
> :: PercentComplete -> PercentComplete -> Bool
$c>= :: PercentComplete -> PercentComplete -> Bool
>= :: PercentComplete -> PercentComplete -> Bool
$cmax :: PercentComplete -> PercentComplete -> PercentComplete
max :: PercentComplete -> PercentComplete -> PercentComplete
$cmin :: PercentComplete -> PercentComplete -> PercentComplete
min :: PercentComplete -> PercentComplete -> PercentComplete
Ord, Typeable)

-- | Priority. 3.8.1.9.
data Priority = Priority
    { Priority -> Int
priorityValue :: Int
    , Priority -> OtherParams
priorityOther :: OtherParams
    } deriving (Int -> Priority -> ShowS
[Priority] -> ShowS
Priority -> String
(Int -> Priority -> ShowS)
-> (Priority -> String) -> ([Priority] -> ShowS) -> Show Priority
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Priority -> ShowS
showsPrec :: Int -> Priority -> ShowS
$cshow :: Priority -> String
show :: Priority -> String
$cshowList :: [Priority] -> ShowS
showList :: [Priority] -> ShowS
Show, Priority -> Priority -> Bool
(Priority -> Priority -> Bool)
-> (Priority -> Priority -> Bool) -> Eq Priority
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Priority -> Priority -> Bool
== :: Priority -> Priority -> Bool
$c/= :: Priority -> Priority -> Bool
/= :: Priority -> Priority -> Bool
Eq, Eq Priority
Eq Priority =>
(Priority -> Priority -> Ordering)
-> (Priority -> Priority -> Bool)
-> (Priority -> Priority -> Bool)
-> (Priority -> Priority -> Bool)
-> (Priority -> Priority -> Bool)
-> (Priority -> Priority -> Priority)
-> (Priority -> Priority -> Priority)
-> Ord Priority
Priority -> Priority -> Bool
Priority -> Priority -> Ordering
Priority -> Priority -> Priority
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
$ccompare :: Priority -> Priority -> Ordering
compare :: Priority -> Priority -> Ordering
$c< :: Priority -> Priority -> Bool
< :: Priority -> Priority -> Bool
$c<= :: Priority -> Priority -> Bool
<= :: Priority -> Priority -> Bool
$c> :: Priority -> Priority -> Bool
> :: Priority -> Priority -> Bool
$c>= :: Priority -> Priority -> Bool
>= :: Priority -> Priority -> Bool
$cmax :: Priority -> Priority -> Priority
max :: Priority -> Priority -> Priority
$cmin :: Priority -> Priority -> Priority
min :: Priority -> Priority -> Priority
Ord, Typeable)

instance Default Priority where
    def :: Priority
def = Int -> OtherParams -> Priority
Priority Int
0 OtherParams
forall a. Default a => a
def

-- | Resources. 3.8.1.10.
data Resources = Resources
    { Resources -> Set Text
resourcesValue    :: Set Text
    , Resources -> Maybe URI
resourcesAltRep   :: Maybe URI
    , Resources -> Maybe Language
resourcesLanguage :: Maybe Language
    , Resources -> OtherParams
resourcesOther    :: OtherParams
    } deriving (Int -> Resources -> ShowS
[Resources] -> ShowS
Resources -> String
(Int -> Resources -> ShowS)
-> (Resources -> String)
-> ([Resources] -> ShowS)
-> Show Resources
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Resources -> ShowS
showsPrec :: Int -> Resources -> ShowS
$cshow :: Resources -> String
show :: Resources -> String
$cshowList :: [Resources] -> ShowS
showList :: [Resources] -> ShowS
Show, Resources -> Resources -> Bool
(Resources -> Resources -> Bool)
-> (Resources -> Resources -> Bool) -> Eq Resources
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Resources -> Resources -> Bool
== :: Resources -> Resources -> Bool
$c/= :: Resources -> Resources -> Bool
/= :: Resources -> Resources -> Bool
Eq, Eq Resources
Eq Resources =>
(Resources -> Resources -> Ordering)
-> (Resources -> Resources -> Bool)
-> (Resources -> Resources -> Bool)
-> (Resources -> Resources -> Bool)
-> (Resources -> Resources -> Bool)
-> (Resources -> Resources -> Resources)
-> (Resources -> Resources -> Resources)
-> Ord Resources
Resources -> Resources -> Bool
Resources -> Resources -> Ordering
Resources -> Resources -> Resources
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
$ccompare :: Resources -> Resources -> Ordering
compare :: Resources -> Resources -> Ordering
$c< :: Resources -> Resources -> Bool
< :: Resources -> Resources -> Bool
$c<= :: Resources -> Resources -> Bool
<= :: Resources -> Resources -> Bool
$c> :: Resources -> Resources -> Bool
> :: Resources -> Resources -> Bool
$c>= :: Resources -> Resources -> Bool
>= :: Resources -> Resources -> Bool
$cmax :: Resources -> Resources -> Resources
max :: Resources -> Resources -> Resources
$cmin :: Resources -> Resources -> Resources
min :: Resources -> Resources -> Resources
Ord, Typeable)

-- | Status, but only for Events. 3.8.1.11.
data EventStatus
    = TentativeEvent { EventStatus -> OtherParams
eventStatusOther :: OtherParams }
    | ConfirmedEvent { eventStatusOther :: OtherParams }
    | CancelledEvent { eventStatusOther :: OtherParams }
      deriving (Int -> EventStatus -> ShowS
[EventStatus] -> ShowS
EventStatus -> String
(Int -> EventStatus -> ShowS)
-> (EventStatus -> String)
-> ([EventStatus] -> ShowS)
-> Show EventStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EventStatus -> ShowS
showsPrec :: Int -> EventStatus -> ShowS
$cshow :: EventStatus -> String
show :: EventStatus -> String
$cshowList :: [EventStatus] -> ShowS
showList :: [EventStatus] -> ShowS
Show, EventStatus -> EventStatus -> Bool
(EventStatus -> EventStatus -> Bool)
-> (EventStatus -> EventStatus -> Bool) -> Eq EventStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EventStatus -> EventStatus -> Bool
== :: EventStatus -> EventStatus -> Bool
$c/= :: EventStatus -> EventStatus -> Bool
/= :: EventStatus -> EventStatus -> Bool
Eq, Eq EventStatus
Eq EventStatus =>
(EventStatus -> EventStatus -> Ordering)
-> (EventStatus -> EventStatus -> Bool)
-> (EventStatus -> EventStatus -> Bool)
-> (EventStatus -> EventStatus -> Bool)
-> (EventStatus -> EventStatus -> Bool)
-> (EventStatus -> EventStatus -> EventStatus)
-> (EventStatus -> EventStatus -> EventStatus)
-> Ord EventStatus
EventStatus -> EventStatus -> Bool
EventStatus -> EventStatus -> Ordering
EventStatus -> EventStatus -> EventStatus
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
$ccompare :: EventStatus -> EventStatus -> Ordering
compare :: EventStatus -> EventStatus -> Ordering
$c< :: EventStatus -> EventStatus -> Bool
< :: EventStatus -> EventStatus -> Bool
$c<= :: EventStatus -> EventStatus -> Bool
<= :: EventStatus -> EventStatus -> Bool
$c> :: EventStatus -> EventStatus -> Bool
> :: EventStatus -> EventStatus -> Bool
$c>= :: EventStatus -> EventStatus -> Bool
>= :: EventStatus -> EventStatus -> Bool
$cmax :: EventStatus -> EventStatus -> EventStatus
max :: EventStatus -> EventStatus -> EventStatus
$cmin :: EventStatus -> EventStatus -> EventStatus
min :: EventStatus -> EventStatus -> EventStatus
Ord, Typeable)

-- | Status, but only for TODOs. 3.8.1.11.
data TodoStatus
    = TodoNeedsAction { TodoStatus -> OtherParams
todoStatusOther :: OtherParams }
    | CompletedTodo   { todoStatusOther :: OtherParams }
    | InProcessTodo   { todoStatusOther :: OtherParams }
    | CancelledTodo   { todoStatusOther :: OtherParams }
      deriving (Int -> TodoStatus -> ShowS
[TodoStatus] -> ShowS
TodoStatus -> String
(Int -> TodoStatus -> ShowS)
-> (TodoStatus -> String)
-> ([TodoStatus] -> ShowS)
-> Show TodoStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TodoStatus -> ShowS
showsPrec :: Int -> TodoStatus -> ShowS
$cshow :: TodoStatus -> String
show :: TodoStatus -> String
$cshowList :: [TodoStatus] -> ShowS
showList :: [TodoStatus] -> ShowS
Show, TodoStatus -> TodoStatus -> Bool
(TodoStatus -> TodoStatus -> Bool)
-> (TodoStatus -> TodoStatus -> Bool) -> Eq TodoStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TodoStatus -> TodoStatus -> Bool
== :: TodoStatus -> TodoStatus -> Bool
$c/= :: TodoStatus -> TodoStatus -> Bool
/= :: TodoStatus -> TodoStatus -> Bool
Eq, Eq TodoStatus
Eq TodoStatus =>
(TodoStatus -> TodoStatus -> Ordering)
-> (TodoStatus -> TodoStatus -> Bool)
-> (TodoStatus -> TodoStatus -> Bool)
-> (TodoStatus -> TodoStatus -> Bool)
-> (TodoStatus -> TodoStatus -> Bool)
-> (TodoStatus -> TodoStatus -> TodoStatus)
-> (TodoStatus -> TodoStatus -> TodoStatus)
-> Ord TodoStatus
TodoStatus -> TodoStatus -> Bool
TodoStatus -> TodoStatus -> Ordering
TodoStatus -> TodoStatus -> TodoStatus
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
$ccompare :: TodoStatus -> TodoStatus -> Ordering
compare :: TodoStatus -> TodoStatus -> Ordering
$c< :: TodoStatus -> TodoStatus -> Bool
< :: TodoStatus -> TodoStatus -> Bool
$c<= :: TodoStatus -> TodoStatus -> Bool
<= :: TodoStatus -> TodoStatus -> Bool
$c> :: TodoStatus -> TodoStatus -> Bool
> :: TodoStatus -> TodoStatus -> Bool
$c>= :: TodoStatus -> TodoStatus -> Bool
>= :: TodoStatus -> TodoStatus -> Bool
$cmax :: TodoStatus -> TodoStatus -> TodoStatus
max :: TodoStatus -> TodoStatus -> TodoStatus
$cmin :: TodoStatus -> TodoStatus -> TodoStatus
min :: TodoStatus -> TodoStatus -> TodoStatus
Ord, Typeable)

-- | Status, but only for Journals. 3.8.1.11.
data JournalStatus
    = DraftJournal     { JournalStatus -> OtherParams
journalStatusOther :: OtherParams }
    | FinalJournal     { journalStatusOther :: OtherParams }
    | CancelledJournal { journalStatusOther :: OtherParams }
      deriving (Int -> JournalStatus -> ShowS
[JournalStatus] -> ShowS
JournalStatus -> String
(Int -> JournalStatus -> ShowS)
-> (JournalStatus -> String)
-> ([JournalStatus] -> ShowS)
-> Show JournalStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JournalStatus -> ShowS
showsPrec :: Int -> JournalStatus -> ShowS
$cshow :: JournalStatus -> String
show :: JournalStatus -> String
$cshowList :: [JournalStatus] -> ShowS
showList :: [JournalStatus] -> ShowS
Show, JournalStatus -> JournalStatus -> Bool
(JournalStatus -> JournalStatus -> Bool)
-> (JournalStatus -> JournalStatus -> Bool) -> Eq JournalStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JournalStatus -> JournalStatus -> Bool
== :: JournalStatus -> JournalStatus -> Bool
$c/= :: JournalStatus -> JournalStatus -> Bool
/= :: JournalStatus -> JournalStatus -> Bool
Eq, Eq JournalStatus
Eq JournalStatus =>
(JournalStatus -> JournalStatus -> Ordering)
-> (JournalStatus -> JournalStatus -> Bool)
-> (JournalStatus -> JournalStatus -> Bool)
-> (JournalStatus -> JournalStatus -> Bool)
-> (JournalStatus -> JournalStatus -> Bool)
-> (JournalStatus -> JournalStatus -> JournalStatus)
-> (JournalStatus -> JournalStatus -> JournalStatus)
-> Ord JournalStatus
JournalStatus -> JournalStatus -> Bool
JournalStatus -> JournalStatus -> Ordering
JournalStatus -> JournalStatus -> JournalStatus
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
$ccompare :: JournalStatus -> JournalStatus -> Ordering
compare :: JournalStatus -> JournalStatus -> Ordering
$c< :: JournalStatus -> JournalStatus -> Bool
< :: JournalStatus -> JournalStatus -> Bool
$c<= :: JournalStatus -> JournalStatus -> Bool
<= :: JournalStatus -> JournalStatus -> Bool
$c> :: JournalStatus -> JournalStatus -> Bool
> :: JournalStatus -> JournalStatus -> Bool
$c>= :: JournalStatus -> JournalStatus -> Bool
>= :: JournalStatus -> JournalStatus -> Bool
$cmax :: JournalStatus -> JournalStatus -> JournalStatus
max :: JournalStatus -> JournalStatus -> JournalStatus
$cmin :: JournalStatus -> JournalStatus -> JournalStatus
min :: JournalStatus -> JournalStatus -> JournalStatus
Ord, Typeable)

-- | Summary. 3.8.1.12.
data Summary = Summary
    { Summary -> Text
summaryValue    :: Text
    , Summary -> Maybe URI
summaryAltRep   :: Maybe URI
    , Summary -> Maybe Language
summaryLanguage :: Maybe Language
    , Summary -> OtherParams
summaryOther    :: OtherParams
    } deriving (Int -> Summary -> ShowS
[Summary] -> ShowS
Summary -> String
(Int -> Summary -> ShowS)
-> (Summary -> String) -> ([Summary] -> ShowS) -> Show Summary
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Summary -> ShowS
showsPrec :: Int -> Summary -> ShowS
$cshow :: Summary -> String
show :: Summary -> String
$cshowList :: [Summary] -> ShowS
showList :: [Summary] -> ShowS
Show, Summary -> Summary -> Bool
(Summary -> Summary -> Bool)
-> (Summary -> Summary -> Bool) -> Eq Summary
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Summary -> Summary -> Bool
== :: Summary -> Summary -> Bool
$c/= :: Summary -> Summary -> Bool
/= :: Summary -> Summary -> Bool
Eq, Eq Summary
Eq Summary =>
(Summary -> Summary -> Ordering)
-> (Summary -> Summary -> Bool)
-> (Summary -> Summary -> Bool)
-> (Summary -> Summary -> Bool)
-> (Summary -> Summary -> Bool)
-> (Summary -> Summary -> Summary)
-> (Summary -> Summary -> Summary)
-> Ord Summary
Summary -> Summary -> Bool
Summary -> Summary -> Ordering
Summary -> Summary -> Summary
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
$ccompare :: Summary -> Summary -> Ordering
compare :: Summary -> Summary -> Ordering
$c< :: Summary -> Summary -> Bool
< :: Summary -> Summary -> Bool
$c<= :: Summary -> Summary -> Bool
<= :: Summary -> Summary -> Bool
$c> :: Summary -> Summary -> Bool
> :: Summary -> Summary -> Bool
$c>= :: Summary -> Summary -> Bool
>= :: Summary -> Summary -> Bool
$cmax :: Summary -> Summary -> Summary
max :: Summary -> Summary -> Summary
$cmin :: Summary -> Summary -> Summary
min :: Summary -> Summary -> Summary
Ord, Typeable)

-- | Date. 3.3.4
data Date = Date
    { Date -> Day
dateValue :: Day
    } deriving (Int -> Date -> ShowS
[Date] -> ShowS
Date -> String
(Int -> Date -> ShowS)
-> (Date -> String) -> ([Date] -> ShowS) -> Show Date
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Date -> ShowS
showsPrec :: Int -> Date -> ShowS
$cshow :: Date -> String
show :: Date -> String
$cshowList :: [Date] -> ShowS
showList :: [Date] -> ShowS
Show, Date -> Date -> Bool
(Date -> Date -> Bool) -> (Date -> Date -> Bool) -> Eq Date
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Date -> Date -> Bool
== :: Date -> Date -> Bool
$c/= :: Date -> Date -> Bool
/= :: Date -> Date -> Bool
Eq, Eq Date
Eq Date =>
(Date -> Date -> Ordering)
-> (Date -> Date -> Bool)
-> (Date -> Date -> Bool)
-> (Date -> Date -> Bool)
-> (Date -> Date -> Bool)
-> (Date -> Date -> Date)
-> (Date -> Date -> Date)
-> Ord Date
Date -> Date -> Bool
Date -> Date -> Ordering
Date -> Date -> Date
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
$ccompare :: Date -> Date -> Ordering
compare :: Date -> Date -> Ordering
$c< :: Date -> Date -> Bool
< :: Date -> Date -> Bool
$c<= :: Date -> Date -> Bool
<= :: Date -> Date -> Bool
$c> :: Date -> Date -> Bool
> :: Date -> Date -> Bool
$c>= :: Date -> Date -> Bool
>= :: Date -> Date -> Bool
$cmax :: Date -> Date -> Date
max :: Date -> Date -> Date
$cmin :: Date -> Date -> Date
min :: Date -> Date -> Date
Ord, Typeable)

-- | Date-Time value. 3.3.5.
data DateTime
    = FloatingDateTime
    { DateTime -> LocalTime
dateTimeFloating :: LocalTime
    }
    | UTCDateTime
    { DateTime -> UTCTime
dateTimeUTC :: UTCTime
    }
    | ZonedDateTime
    { dateTimeFloating :: LocalTime
    , DateTime -> Text
dateTimeZone     :: Text
    } deriving (Int -> DateTime -> ShowS
[DateTime] -> ShowS
DateTime -> String
(Int -> DateTime -> ShowS)
-> (DateTime -> String) -> ([DateTime] -> ShowS) -> Show DateTime
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DateTime -> ShowS
showsPrec :: Int -> DateTime -> ShowS
$cshow :: DateTime -> String
show :: DateTime -> String
$cshowList :: [DateTime] -> ShowS
showList :: [DateTime] -> ShowS
Show, DateTime -> DateTime -> Bool
(DateTime -> DateTime -> Bool)
-> (DateTime -> DateTime -> Bool) -> Eq DateTime
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DateTime -> DateTime -> Bool
== :: DateTime -> DateTime -> Bool
$c/= :: DateTime -> DateTime -> Bool
/= :: DateTime -> DateTime -> Bool
Eq, Eq DateTime
Eq DateTime =>
(DateTime -> DateTime -> Ordering)
-> (DateTime -> DateTime -> Bool)
-> (DateTime -> DateTime -> Bool)
-> (DateTime -> DateTime -> Bool)
-> (DateTime -> DateTime -> Bool)
-> (DateTime -> DateTime -> DateTime)
-> (DateTime -> DateTime -> DateTime)
-> Ord DateTime
DateTime -> DateTime -> Bool
DateTime -> DateTime -> Ordering
DateTime -> DateTime -> DateTime
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
$ccompare :: DateTime -> DateTime -> Ordering
compare :: DateTime -> DateTime -> Ordering
$c< :: DateTime -> DateTime -> Bool
< :: DateTime -> DateTime -> Bool
$c<= :: DateTime -> DateTime -> Bool
<= :: DateTime -> DateTime -> Bool
$c> :: DateTime -> DateTime -> Bool
> :: DateTime -> DateTime -> Bool
$c>= :: DateTime -> DateTime -> Bool
>= :: DateTime -> DateTime -> Bool
$cmax :: DateTime -> DateTime -> DateTime
max :: DateTime -> DateTime -> DateTime
$cmin :: DateTime -> DateTime -> DateTime
min :: DateTime -> DateTime -> DateTime
Ord, Typeable)

-- | Date-Time End. 3.8.2.2.
data DTEnd
    = DTEndDateTime
    { DTEnd -> DateTime
dtEndDateTimeValue :: DateTime
    , DTEnd -> OtherParams
dtEndOther         :: OtherParams
    }
    | DTEndDate
    { DTEnd -> Date
dtEndDateValue :: Date
    , dtEndOther     :: OtherParams
    } deriving (Int -> DTEnd -> ShowS
[DTEnd] -> ShowS
DTEnd -> String
(Int -> DTEnd -> ShowS)
-> (DTEnd -> String) -> ([DTEnd] -> ShowS) -> Show DTEnd
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DTEnd -> ShowS
showsPrec :: Int -> DTEnd -> ShowS
$cshow :: DTEnd -> String
show :: DTEnd -> String
$cshowList :: [DTEnd] -> ShowS
showList :: [DTEnd] -> ShowS
Show, DTEnd -> DTEnd -> Bool
(DTEnd -> DTEnd -> Bool) -> (DTEnd -> DTEnd -> Bool) -> Eq DTEnd
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DTEnd -> DTEnd -> Bool
== :: DTEnd -> DTEnd -> Bool
$c/= :: DTEnd -> DTEnd -> Bool
/= :: DTEnd -> DTEnd -> Bool
Eq, Eq DTEnd
Eq DTEnd =>
(DTEnd -> DTEnd -> Ordering)
-> (DTEnd -> DTEnd -> Bool)
-> (DTEnd -> DTEnd -> Bool)
-> (DTEnd -> DTEnd -> Bool)
-> (DTEnd -> DTEnd -> Bool)
-> (DTEnd -> DTEnd -> DTEnd)
-> (DTEnd -> DTEnd -> DTEnd)
-> Ord DTEnd
DTEnd -> DTEnd -> Bool
DTEnd -> DTEnd -> Ordering
DTEnd -> DTEnd -> DTEnd
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
$ccompare :: DTEnd -> DTEnd -> Ordering
compare :: DTEnd -> DTEnd -> Ordering
$c< :: DTEnd -> DTEnd -> Bool
< :: DTEnd -> DTEnd -> Bool
$c<= :: DTEnd -> DTEnd -> Bool
<= :: DTEnd -> DTEnd -> Bool
$c> :: DTEnd -> DTEnd -> Bool
> :: DTEnd -> DTEnd -> Bool
$c>= :: DTEnd -> DTEnd -> Bool
>= :: DTEnd -> DTEnd -> Bool
$cmax :: DTEnd -> DTEnd -> DTEnd
max :: DTEnd -> DTEnd -> DTEnd
$cmin :: DTEnd -> DTEnd -> DTEnd
min :: DTEnd -> DTEnd -> DTEnd
Ord, Typeable)

-- | Date-Time Due. 3.8.2.3.
data Due
    = DueDateTime
    { Due -> DateTime
dueDateTimeValue :: DateTime
    , Due -> OtherParams
dueOther         :: OtherParams
    }
    | DueDate
    { Due -> Date
dueDateValue :: Date
    , dueOther     :: OtherParams
    } deriving (Int -> Due -> ShowS
[Due] -> ShowS
Due -> String
(Int -> Due -> ShowS)
-> (Due -> String) -> ([Due] -> ShowS) -> Show Due
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Due -> ShowS
showsPrec :: Int -> Due -> ShowS
$cshow :: Due -> String
show :: Due -> String
$cshowList :: [Due] -> ShowS
showList :: [Due] -> ShowS
Show, Due -> Due -> Bool
(Due -> Due -> Bool) -> (Due -> Due -> Bool) -> Eq Due
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Due -> Due -> Bool
== :: Due -> Due -> Bool
$c/= :: Due -> Due -> Bool
/= :: Due -> Due -> Bool
Eq, Eq Due
Eq Due =>
(Due -> Due -> Ordering)
-> (Due -> Due -> Bool)
-> (Due -> Due -> Bool)
-> (Due -> Due -> Bool)
-> (Due -> Due -> Bool)
-> (Due -> Due -> Due)
-> (Due -> Due -> Due)
-> Ord Due
Due -> Due -> Bool
Due -> Due -> Ordering
Due -> Due -> Due
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
$ccompare :: Due -> Due -> Ordering
compare :: Due -> Due -> Ordering
$c< :: Due -> Due -> Bool
< :: Due -> Due -> Bool
$c<= :: Due -> Due -> Bool
<= :: Due -> Due -> Bool
$c> :: Due -> Due -> Bool
> :: Due -> Due -> Bool
$c>= :: Due -> Due -> Bool
>= :: Due -> Due -> Bool
$cmax :: Due -> Due -> Due
max :: Due -> Due -> Due
$cmin :: Due -> Due -> Due
min :: Due -> Due -> Due
Ord, Typeable)

-- | Date-Time Start. 3.8.2.4.
data DTStart
    = DTStartDateTime
    { DTStart -> DateTime
dtStartDateTimeValue :: DateTime
    , DTStart -> OtherParams
dtStartOther         :: OtherParams
    }
    | DTStartDate
    { DTStart -> Date
dtStartDateValue :: Date
    , dtStartOther     :: OtherParams
    } deriving (Int -> DTStart -> ShowS
[DTStart] -> ShowS
DTStart -> String
(Int -> DTStart -> ShowS)
-> (DTStart -> String) -> ([DTStart] -> ShowS) -> Show DTStart
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DTStart -> ShowS
showsPrec :: Int -> DTStart -> ShowS
$cshow :: DTStart -> String
show :: DTStart -> String
$cshowList :: [DTStart] -> ShowS
showList :: [DTStart] -> ShowS
Show, DTStart -> DTStart -> Bool
(DTStart -> DTStart -> Bool)
-> (DTStart -> DTStart -> Bool) -> Eq DTStart
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DTStart -> DTStart -> Bool
== :: DTStart -> DTStart -> Bool
$c/= :: DTStart -> DTStart -> Bool
/= :: DTStart -> DTStart -> Bool
Eq, Eq DTStart
Eq DTStart =>
(DTStart -> DTStart -> Ordering)
-> (DTStart -> DTStart -> Bool)
-> (DTStart -> DTStart -> Bool)
-> (DTStart -> DTStart -> Bool)
-> (DTStart -> DTStart -> Bool)
-> (DTStart -> DTStart -> DTStart)
-> (DTStart -> DTStart -> DTStart)
-> Ord DTStart
DTStart -> DTStart -> Bool
DTStart -> DTStart -> Ordering
DTStart -> DTStart -> DTStart
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
$ccompare :: DTStart -> DTStart -> Ordering
compare :: DTStart -> DTStart -> Ordering
$c< :: DTStart -> DTStart -> Bool
< :: DTStart -> DTStart -> Bool
$c<= :: DTStart -> DTStart -> Bool
<= :: DTStart -> DTStart -> Bool
$c> :: DTStart -> DTStart -> Bool
> :: DTStart -> DTStart -> Bool
$c>= :: DTStart -> DTStart -> Bool
>= :: DTStart -> DTStart -> Bool
$cmax :: DTStart -> DTStart -> DTStart
max :: DTStart -> DTStart -> DTStart
$cmin :: DTStart -> DTStart -> DTStart
min :: DTStart -> DTStart -> DTStart
Ord, Typeable)

-- | Duration value. 3.3.6.
data Duration -- TODO(?): Convert to DiffTime?
    = DurationDate
    { Duration -> Sign
durSign   :: Sign -- ^ 'def' = 'Positive'
    , Duration -> Int
durDay    :: Int
    , Duration -> Int
durHour   :: Int
    , Duration -> Int
durMinute :: Int
    , Duration -> Int
durSecond :: Int
    }
    | DurationTime
    { durSign   :: Sign
    , durHour   :: Int
    , durMinute :: Int
    , durSecond :: Int
    }
    | DurationWeek
    { durSign :: Sign
    , Duration -> Int
durWeek :: Int
    } deriving (Int -> Duration -> ShowS
[Duration] -> ShowS
Duration -> String
(Int -> Duration -> ShowS)
-> (Duration -> String) -> ([Duration] -> ShowS) -> Show Duration
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Duration -> ShowS
showsPrec :: Int -> Duration -> ShowS
$cshow :: Duration -> String
show :: Duration -> String
$cshowList :: [Duration] -> ShowS
showList :: [Duration] -> ShowS
Show, Duration -> Duration -> Bool
(Duration -> Duration -> Bool)
-> (Duration -> Duration -> Bool) -> Eq Duration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Duration -> Duration -> Bool
== :: Duration -> Duration -> Bool
$c/= :: Duration -> Duration -> Bool
/= :: Duration -> Duration -> Bool
Eq, Eq Duration
Eq Duration =>
(Duration -> Duration -> Ordering)
-> (Duration -> Duration -> Bool)
-> (Duration -> Duration -> Bool)
-> (Duration -> Duration -> Bool)
-> (Duration -> Duration -> Bool)
-> (Duration -> Duration -> Duration)
-> (Duration -> Duration -> Duration)
-> Ord Duration
Duration -> Duration -> Bool
Duration -> Duration -> Ordering
Duration -> Duration -> Duration
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
$ccompare :: Duration -> Duration -> Ordering
compare :: Duration -> Duration -> Ordering
$c< :: Duration -> Duration -> Bool
< :: Duration -> Duration -> Bool
$c<= :: Duration -> Duration -> Bool
<= :: Duration -> Duration -> Bool
$c> :: Duration -> Duration -> Bool
> :: Duration -> Duration -> Bool
$c>= :: Duration -> Duration -> Bool
>= :: Duration -> Duration -> Bool
$cmax :: Duration -> Duration -> Duration
max :: Duration -> Duration -> Duration
$cmin :: Duration -> Duration -> Duration
min :: Duration -> Duration -> Duration
Ord, Typeable)

-- | Sign.
data Sign = Positive | Negative
            deriving (Int -> Sign -> ShowS
[Sign] -> ShowS
Sign -> String
(Int -> Sign -> ShowS)
-> (Sign -> String) -> ([Sign] -> ShowS) -> Show Sign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Sign -> ShowS
showsPrec :: Int -> Sign -> ShowS
$cshow :: Sign -> String
show :: Sign -> String
$cshowList :: [Sign] -> ShowS
showList :: [Sign] -> ShowS
Show, Sign -> Sign -> Bool
(Sign -> Sign -> Bool) -> (Sign -> Sign -> Bool) -> Eq Sign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Sign -> Sign -> Bool
== :: Sign -> Sign -> Bool
$c/= :: Sign -> Sign -> Bool
/= :: Sign -> Sign -> Bool
Eq, Eq Sign
Eq Sign =>
(Sign -> Sign -> Ordering)
-> (Sign -> Sign -> Bool)
-> (Sign -> Sign -> Bool)
-> (Sign -> Sign -> Bool)
-> (Sign -> Sign -> Bool)
-> (Sign -> Sign -> Sign)
-> (Sign -> Sign -> Sign)
-> Ord Sign
Sign -> Sign -> Bool
Sign -> Sign -> Ordering
Sign -> Sign -> Sign
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
$ccompare :: Sign -> Sign -> Ordering
compare :: Sign -> Sign -> Ordering
$c< :: Sign -> Sign -> Bool
< :: Sign -> Sign -> Bool
$c<= :: Sign -> Sign -> Bool
<= :: Sign -> Sign -> Bool
$c> :: Sign -> Sign -> Bool
> :: Sign -> Sign -> Bool
$c>= :: Sign -> Sign -> Bool
>= :: Sign -> Sign -> Bool
$cmax :: Sign -> Sign -> Sign
max :: Sign -> Sign -> Sign
$cmin :: Sign -> Sign -> Sign
min :: Sign -> Sign -> Sign
Ord, Typeable)

instance Default Sign where
    def :: Sign
def = Sign
Positive

-- | Duration property. 3.8.2.5.
data DurationProp = DurationProp
    { DurationProp -> Duration
durationValue :: Duration
    , DurationProp -> OtherParams
durationOther :: OtherParams
    } deriving (Int -> DurationProp -> ShowS
[DurationProp] -> ShowS
DurationProp -> String
(Int -> DurationProp -> ShowS)
-> (DurationProp -> String)
-> ([DurationProp] -> ShowS)
-> Show DurationProp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DurationProp -> ShowS
showsPrec :: Int -> DurationProp -> ShowS
$cshow :: DurationProp -> String
show :: DurationProp -> String
$cshowList :: [DurationProp] -> ShowS
showList :: [DurationProp] -> ShowS
Show, DurationProp -> DurationProp -> Bool
(DurationProp -> DurationProp -> Bool)
-> (DurationProp -> DurationProp -> Bool) -> Eq DurationProp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DurationProp -> DurationProp -> Bool
== :: DurationProp -> DurationProp -> Bool
$c/= :: DurationProp -> DurationProp -> Bool
/= :: DurationProp -> DurationProp -> Bool
Eq, Eq DurationProp
Eq DurationProp =>
(DurationProp -> DurationProp -> Ordering)
-> (DurationProp -> DurationProp -> Bool)
-> (DurationProp -> DurationProp -> Bool)
-> (DurationProp -> DurationProp -> Bool)
-> (DurationProp -> DurationProp -> Bool)
-> (DurationProp -> DurationProp -> DurationProp)
-> (DurationProp -> DurationProp -> DurationProp)
-> Ord DurationProp
DurationProp -> DurationProp -> Bool
DurationProp -> DurationProp -> Ordering
DurationProp -> DurationProp -> DurationProp
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
$ccompare :: DurationProp -> DurationProp -> Ordering
compare :: DurationProp -> DurationProp -> Ordering
$c< :: DurationProp -> DurationProp -> Bool
< :: DurationProp -> DurationProp -> Bool
$c<= :: DurationProp -> DurationProp -> Bool
<= :: DurationProp -> DurationProp -> Bool
$c> :: DurationProp -> DurationProp -> Bool
> :: DurationProp -> DurationProp -> Bool
$c>= :: DurationProp -> DurationProp -> Bool
>= :: DurationProp -> DurationProp -> Bool
$cmax :: DurationProp -> DurationProp -> DurationProp
max :: DurationProp -> DurationProp -> DurationProp
$cmin :: DurationProp -> DurationProp -> DurationProp
min :: DurationProp -> DurationProp -> DurationProp
Ord, Typeable)

data FreeBusy = FreeBusy
    { FreeBusy -> FBType
freeBusyType    :: FBType
    , FreeBusy -> Set UTCPeriod
freeBusyPeriods :: Set UTCPeriod
    , FreeBusy -> OtherParams
freeBusyOther   :: OtherParams
    } deriving (Int -> FreeBusy -> ShowS
[FreeBusy] -> ShowS
FreeBusy -> String
(Int -> FreeBusy -> ShowS)
-> (FreeBusy -> String) -> ([FreeBusy] -> ShowS) -> Show FreeBusy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FreeBusy -> ShowS
showsPrec :: Int -> FreeBusy -> ShowS
$cshow :: FreeBusy -> String
show :: FreeBusy -> String
$cshowList :: [FreeBusy] -> ShowS
showList :: [FreeBusy] -> ShowS
Show, FreeBusy -> FreeBusy -> Bool
(FreeBusy -> FreeBusy -> Bool)
-> (FreeBusy -> FreeBusy -> Bool) -> Eq FreeBusy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FreeBusy -> FreeBusy -> Bool
== :: FreeBusy -> FreeBusy -> Bool
$c/= :: FreeBusy -> FreeBusy -> Bool
/= :: FreeBusy -> FreeBusy -> Bool
Eq, Eq FreeBusy
Eq FreeBusy =>
(FreeBusy -> FreeBusy -> Ordering)
-> (FreeBusy -> FreeBusy -> Bool)
-> (FreeBusy -> FreeBusy -> Bool)
-> (FreeBusy -> FreeBusy -> Bool)
-> (FreeBusy -> FreeBusy -> Bool)
-> (FreeBusy -> FreeBusy -> FreeBusy)
-> (FreeBusy -> FreeBusy -> FreeBusy)
-> Ord FreeBusy
FreeBusy -> FreeBusy -> Bool
FreeBusy -> FreeBusy -> Ordering
FreeBusy -> FreeBusy -> FreeBusy
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
$ccompare :: FreeBusy -> FreeBusy -> Ordering
compare :: FreeBusy -> FreeBusy -> Ordering
$c< :: FreeBusy -> FreeBusy -> Bool
< :: FreeBusy -> FreeBusy -> Bool
$c<= :: FreeBusy -> FreeBusy -> Bool
<= :: FreeBusy -> FreeBusy -> Bool
$c> :: FreeBusy -> FreeBusy -> Bool
> :: FreeBusy -> FreeBusy -> Bool
$c>= :: FreeBusy -> FreeBusy -> Bool
>= :: FreeBusy -> FreeBusy -> Bool
$cmax :: FreeBusy -> FreeBusy -> FreeBusy
max :: FreeBusy -> FreeBusy -> FreeBusy
$cmin :: FreeBusy -> FreeBusy -> FreeBusy
min :: FreeBusy -> FreeBusy -> FreeBusy
Ord, Typeable)

-- | Period of time. 3.3.9.
data Period
    = PeriodDates    DateTime DateTime
    | PeriodDuration DateTime Duration
      deriving (Int -> Period -> ShowS
[Period] -> ShowS
Period -> String
(Int -> Period -> ShowS)
-> (Period -> String) -> ([Period] -> ShowS) -> Show Period
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Period -> ShowS
showsPrec :: Int -> Period -> ShowS
$cshow :: Period -> String
show :: Period -> String
$cshowList :: [Period] -> ShowS
showList :: [Period] -> ShowS
Show, Period -> Period -> Bool
(Period -> Period -> Bool)
-> (Period -> Period -> Bool) -> Eq Period
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Period -> Period -> Bool
== :: Period -> Period -> Bool
$c/= :: Period -> Period -> Bool
/= :: Period -> Period -> Bool
Eq, Eq Period
Eq Period =>
(Period -> Period -> Ordering)
-> (Period -> Period -> Bool)
-> (Period -> Period -> Bool)
-> (Period -> Period -> Bool)
-> (Period -> Period -> Bool)
-> (Period -> Period -> Period)
-> (Period -> Period -> Period)
-> Ord Period
Period -> Period -> Bool
Period -> Period -> Ordering
Period -> Period -> Period
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
$ccompare :: Period -> Period -> Ordering
compare :: Period -> Period -> Ordering
$c< :: Period -> Period -> Bool
< :: Period -> Period -> Bool
$c<= :: Period -> Period -> Bool
<= :: Period -> Period -> Bool
$c> :: Period -> Period -> Bool
> :: Period -> Period -> Bool
$c>= :: Period -> Period -> Bool
>= :: Period -> Period -> Bool
$cmax :: Period -> Period -> Period
max :: Period -> Period -> Period
$cmin :: Period -> Period -> Period
min :: Period -> Period -> Period
Ord, Typeable)

-- | Period of time which must be UTC, as in FreeBusy. 3.3.9.
data UTCPeriod
    = UTCPeriodDates    UTCTime UTCTime
    | UTCPeriodDuration UTCTime Duration
      deriving (Int -> UTCPeriod -> ShowS
[UTCPeriod] -> ShowS
UTCPeriod -> String
(Int -> UTCPeriod -> ShowS)
-> (UTCPeriod -> String)
-> ([UTCPeriod] -> ShowS)
-> Show UTCPeriod
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UTCPeriod -> ShowS
showsPrec :: Int -> UTCPeriod -> ShowS
$cshow :: UTCPeriod -> String
show :: UTCPeriod -> String
$cshowList :: [UTCPeriod] -> ShowS
showList :: [UTCPeriod] -> ShowS
Show, UTCPeriod -> UTCPeriod -> Bool
(UTCPeriod -> UTCPeriod -> Bool)
-> (UTCPeriod -> UTCPeriod -> Bool) -> Eq UTCPeriod
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UTCPeriod -> UTCPeriod -> Bool
== :: UTCPeriod -> UTCPeriod -> Bool
$c/= :: UTCPeriod -> UTCPeriod -> Bool
/= :: UTCPeriod -> UTCPeriod -> Bool
Eq, Eq UTCPeriod
Eq UTCPeriod =>
(UTCPeriod -> UTCPeriod -> Ordering)
-> (UTCPeriod -> UTCPeriod -> Bool)
-> (UTCPeriod -> UTCPeriod -> Bool)
-> (UTCPeriod -> UTCPeriod -> Bool)
-> (UTCPeriod -> UTCPeriod -> Bool)
-> (UTCPeriod -> UTCPeriod -> UTCPeriod)
-> (UTCPeriod -> UTCPeriod -> UTCPeriod)
-> Ord UTCPeriod
UTCPeriod -> UTCPeriod -> Bool
UTCPeriod -> UTCPeriod -> Ordering
UTCPeriod -> UTCPeriod -> UTCPeriod
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
$ccompare :: UTCPeriod -> UTCPeriod -> Ordering
compare :: UTCPeriod -> UTCPeriod -> Ordering
$c< :: UTCPeriod -> UTCPeriod -> Bool
< :: UTCPeriod -> UTCPeriod -> Bool
$c<= :: UTCPeriod -> UTCPeriod -> Bool
<= :: UTCPeriod -> UTCPeriod -> Bool
$c> :: UTCPeriod -> UTCPeriod -> Bool
> :: UTCPeriod -> UTCPeriod -> Bool
$c>= :: UTCPeriod -> UTCPeriod -> Bool
>= :: UTCPeriod -> UTCPeriod -> Bool
$cmax :: UTCPeriod -> UTCPeriod -> UTCPeriod
max :: UTCPeriod -> UTCPeriod -> UTCPeriod
$cmin :: UTCPeriod -> UTCPeriod -> UTCPeriod
min :: UTCPeriod -> UTCPeriod -> UTCPeriod
Ord, Typeable)

-- | Free/Busy Time Type. 3.2.9.
--
-- Unrecognized FBTypeX MUST be treated as Busy.
data FBType
    = Free
    | Busy
    | BusyUnavailable
    | BusyTentative
    | FBTypeX (CI Text)
      deriving (Int -> FBType -> ShowS
[FBType] -> ShowS
FBType -> String
(Int -> FBType -> ShowS)
-> (FBType -> String) -> ([FBType] -> ShowS) -> Show FBType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FBType -> ShowS
showsPrec :: Int -> FBType -> ShowS
$cshow :: FBType -> String
show :: FBType -> String
$cshowList :: [FBType] -> ShowS
showList :: [FBType] -> ShowS
Show, FBType -> FBType -> Bool
(FBType -> FBType -> Bool)
-> (FBType -> FBType -> Bool) -> Eq FBType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FBType -> FBType -> Bool
== :: FBType -> FBType -> Bool
$c/= :: FBType -> FBType -> Bool
/= :: FBType -> FBType -> Bool
Eq, Eq FBType
Eq FBType =>
(FBType -> FBType -> Ordering)
-> (FBType -> FBType -> Bool)
-> (FBType -> FBType -> Bool)
-> (FBType -> FBType -> Bool)
-> (FBType -> FBType -> Bool)
-> (FBType -> FBType -> FBType)
-> (FBType -> FBType -> FBType)
-> Ord FBType
FBType -> FBType -> Bool
FBType -> FBType -> Ordering
FBType -> FBType -> FBType
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
$ccompare :: FBType -> FBType -> Ordering
compare :: FBType -> FBType -> Ordering
$c< :: FBType -> FBType -> Bool
< :: FBType -> FBType -> Bool
$c<= :: FBType -> FBType -> Bool
<= :: FBType -> FBType -> Bool
$c> :: FBType -> FBType -> Bool
> :: FBType -> FBType -> Bool
$c>= :: FBType -> FBType -> Bool
>= :: FBType -> FBType -> Bool
$cmax :: FBType -> FBType -> FBType
max :: FBType -> FBType -> FBType
$cmin :: FBType -> FBType -> FBType
min :: FBType -> FBType -> FBType
Ord, Typeable)

instance Default FBType where
    def :: FBType
def = FBType
Busy

-- | Time Transparency. 3.8.2.7.
data TimeTransparency
    = Opaque      { TimeTransparency -> OtherParams
timeTransparencyOther :: OtherParams }
    | Transparent { timeTransparencyOther :: OtherParams }
      deriving (Int -> TimeTransparency -> ShowS
[TimeTransparency] -> ShowS
TimeTransparency -> String
(Int -> TimeTransparency -> ShowS)
-> (TimeTransparency -> String)
-> ([TimeTransparency] -> ShowS)
-> Show TimeTransparency
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TimeTransparency -> ShowS
showsPrec :: Int -> TimeTransparency -> ShowS
$cshow :: TimeTransparency -> String
show :: TimeTransparency -> String
$cshowList :: [TimeTransparency] -> ShowS
showList :: [TimeTransparency] -> ShowS
Show, TimeTransparency -> TimeTransparency -> Bool
(TimeTransparency -> TimeTransparency -> Bool)
-> (TimeTransparency -> TimeTransparency -> Bool)
-> Eq TimeTransparency
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TimeTransparency -> TimeTransparency -> Bool
== :: TimeTransparency -> TimeTransparency -> Bool
$c/= :: TimeTransparency -> TimeTransparency -> Bool
/= :: TimeTransparency -> TimeTransparency -> Bool
Eq, Eq TimeTransparency
Eq TimeTransparency =>
(TimeTransparency -> TimeTransparency -> Ordering)
-> (TimeTransparency -> TimeTransparency -> Bool)
-> (TimeTransparency -> TimeTransparency -> Bool)
-> (TimeTransparency -> TimeTransparency -> Bool)
-> (TimeTransparency -> TimeTransparency -> Bool)
-> (TimeTransparency -> TimeTransparency -> TimeTransparency)
-> (TimeTransparency -> TimeTransparency -> TimeTransparency)
-> Ord TimeTransparency
TimeTransparency -> TimeTransparency -> Bool
TimeTransparency -> TimeTransparency -> Ordering
TimeTransparency -> TimeTransparency -> TimeTransparency
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
$ccompare :: TimeTransparency -> TimeTransparency -> Ordering
compare :: TimeTransparency -> TimeTransparency -> Ordering
$c< :: TimeTransparency -> TimeTransparency -> Bool
< :: TimeTransparency -> TimeTransparency -> Bool
$c<= :: TimeTransparency -> TimeTransparency -> Bool
<= :: TimeTransparency -> TimeTransparency -> Bool
$c> :: TimeTransparency -> TimeTransparency -> Bool
> :: TimeTransparency -> TimeTransparency -> Bool
$c>= :: TimeTransparency -> TimeTransparency -> Bool
>= :: TimeTransparency -> TimeTransparency -> Bool
$cmax :: TimeTransparency -> TimeTransparency -> TimeTransparency
max :: TimeTransparency -> TimeTransparency -> TimeTransparency
$cmin :: TimeTransparency -> TimeTransparency -> TimeTransparency
min :: TimeTransparency -> TimeTransparency -> TimeTransparency
Ord, Typeable)

instance Default TimeTransparency where
    def :: TimeTransparency
def = OtherParams -> TimeTransparency
Opaque OtherParams
forall a. Default a => a
def

-- | Time Zone Identifier. 3.8.3.1.
data TZID = TZID
    { TZID -> Text
tzidValue  :: Text
    , TZID -> Bool
tzidGlobal :: Bool
    , TZID -> OtherParams
tzidOther  :: OtherParams
    } deriving (Int -> TZID -> ShowS
[TZID] -> ShowS
TZID -> String
(Int -> TZID -> ShowS)
-> (TZID -> String) -> ([TZID] -> ShowS) -> Show TZID
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TZID -> ShowS
showsPrec :: Int -> TZID -> ShowS
$cshow :: TZID -> String
show :: TZID -> String
$cshowList :: [TZID] -> ShowS
showList :: [TZID] -> ShowS
Show, TZID -> TZID -> Bool
(TZID -> TZID -> Bool) -> (TZID -> TZID -> Bool) -> Eq TZID
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TZID -> TZID -> Bool
== :: TZID -> TZID -> Bool
$c/= :: TZID -> TZID -> Bool
/= :: TZID -> TZID -> Bool
Eq, Eq TZID
Eq TZID =>
(TZID -> TZID -> Ordering)
-> (TZID -> TZID -> Bool)
-> (TZID -> TZID -> Bool)
-> (TZID -> TZID -> Bool)
-> (TZID -> TZID -> Bool)
-> (TZID -> TZID -> TZID)
-> (TZID -> TZID -> TZID)
-> Ord TZID
TZID -> TZID -> Bool
TZID -> TZID -> Ordering
TZID -> TZID -> TZID
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
$ccompare :: TZID -> TZID -> Ordering
compare :: TZID -> TZID -> Ordering
$c< :: TZID -> TZID -> Bool
< :: TZID -> TZID -> Bool
$c<= :: TZID -> TZID -> Bool
<= :: TZID -> TZID -> Bool
$c> :: TZID -> TZID -> Bool
> :: TZID -> TZID -> Bool
$c>= :: TZID -> TZID -> Bool
>= :: TZID -> TZID -> Bool
$cmax :: TZID -> TZID -> TZID
max :: TZID -> TZID -> TZID
$cmin :: TZID -> TZID -> TZID
min :: TZID -> TZID -> TZID
Ord, Typeable)

-- | Time Zone Name. 3.8.3.2.
data TZName = TZName
    { TZName -> Text
tzNameValue    :: Text
    , TZName -> Maybe Language
tzNameLanguage :: Maybe Language
    , TZName -> OtherParams
tzNameOther    :: OtherParams
    } deriving (Int -> TZName -> ShowS
[TZName] -> ShowS
TZName -> String
(Int -> TZName -> ShowS)
-> (TZName -> String) -> ([TZName] -> ShowS) -> Show TZName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TZName -> ShowS
showsPrec :: Int -> TZName -> ShowS
$cshow :: TZName -> String
show :: TZName -> String
$cshowList :: [TZName] -> ShowS
showList :: [TZName] -> ShowS
Show, TZName -> TZName -> Bool
(TZName -> TZName -> Bool)
-> (TZName -> TZName -> Bool) -> Eq TZName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TZName -> TZName -> Bool
== :: TZName -> TZName -> Bool
$c/= :: TZName -> TZName -> Bool
/= :: TZName -> TZName -> Bool
Eq, Eq TZName
Eq TZName =>
(TZName -> TZName -> Ordering)
-> (TZName -> TZName -> Bool)
-> (TZName -> TZName -> Bool)
-> (TZName -> TZName -> Bool)
-> (TZName -> TZName -> Bool)
-> (TZName -> TZName -> TZName)
-> (TZName -> TZName -> TZName)
-> Ord TZName
TZName -> TZName -> Bool
TZName -> TZName -> Ordering
TZName -> TZName -> TZName
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
$ccompare :: TZName -> TZName -> Ordering
compare :: TZName -> TZName -> Ordering
$c< :: TZName -> TZName -> Bool
< :: TZName -> TZName -> Bool
$c<= :: TZName -> TZName -> Bool
<= :: TZName -> TZName -> Bool
$c> :: TZName -> TZName -> Bool
> :: TZName -> TZName -> Bool
$c>= :: TZName -> TZName -> Bool
>= :: TZName -> TZName -> Bool
$cmax :: TZName -> TZName -> TZName
max :: TZName -> TZName -> TZName
$cmin :: TZName -> TZName -> TZName
min :: TZName -> TZName -> TZName
Ord, Typeable)

-- | UTC Offset. 3.3.14, 3.8.3.4, and 3.8.3.3. (unified-ish)
data UTCOffset = UTCOffset
    { UTCOffset -> Int
utcOffsetValue :: Int -- ^ Number of seconds away from UTC
    , UTCOffset -> OtherParams
utcOffsetOther :: OtherParams
    } deriving (Int -> UTCOffset -> ShowS
[UTCOffset] -> ShowS
UTCOffset -> String
(Int -> UTCOffset -> ShowS)
-> (UTCOffset -> String)
-> ([UTCOffset] -> ShowS)
-> Show UTCOffset
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UTCOffset -> ShowS
showsPrec :: Int -> UTCOffset -> ShowS
$cshow :: UTCOffset -> String
show :: UTCOffset -> String
$cshowList :: [UTCOffset] -> ShowS
showList :: [UTCOffset] -> ShowS
Show, UTCOffset -> UTCOffset -> Bool
(UTCOffset -> UTCOffset -> Bool)
-> (UTCOffset -> UTCOffset -> Bool) -> Eq UTCOffset
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UTCOffset -> UTCOffset -> Bool
== :: UTCOffset -> UTCOffset -> Bool
$c/= :: UTCOffset -> UTCOffset -> Bool
/= :: UTCOffset -> UTCOffset -> Bool
Eq, Eq UTCOffset
Eq UTCOffset =>
(UTCOffset -> UTCOffset -> Ordering)
-> (UTCOffset -> UTCOffset -> Bool)
-> (UTCOffset -> UTCOffset -> Bool)
-> (UTCOffset -> UTCOffset -> Bool)
-> (UTCOffset -> UTCOffset -> Bool)
-> (UTCOffset -> UTCOffset -> UTCOffset)
-> (UTCOffset -> UTCOffset -> UTCOffset)
-> Ord UTCOffset
UTCOffset -> UTCOffset -> Bool
UTCOffset -> UTCOffset -> Ordering
UTCOffset -> UTCOffset -> UTCOffset
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
$ccompare :: UTCOffset -> UTCOffset -> Ordering
compare :: UTCOffset -> UTCOffset -> Ordering
$c< :: UTCOffset -> UTCOffset -> Bool
< :: UTCOffset -> UTCOffset -> Bool
$c<= :: UTCOffset -> UTCOffset -> Bool
<= :: UTCOffset -> UTCOffset -> Bool
$c> :: UTCOffset -> UTCOffset -> Bool
> :: UTCOffset -> UTCOffset -> Bool
$c>= :: UTCOffset -> UTCOffset -> Bool
>= :: UTCOffset -> UTCOffset -> Bool
$cmax :: UTCOffset -> UTCOffset -> UTCOffset
max :: UTCOffset -> UTCOffset -> UTCOffset
$cmin :: UTCOffset -> UTCOffset -> UTCOffset
min :: UTCOffset -> UTCOffset -> UTCOffset
Ord, Typeable)

-- | Time Zone URL. 3.8.3.5.
data TZUrl = TZUrl
    { TZUrl -> URI
tzUrlValue :: URI
    , TZUrl -> OtherParams
tzUrlOther :: OtherParams
    } deriving (Int -> TZUrl -> ShowS
[TZUrl] -> ShowS
TZUrl -> String
(Int -> TZUrl -> ShowS)
-> (TZUrl -> String) -> ([TZUrl] -> ShowS) -> Show TZUrl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TZUrl -> ShowS
showsPrec :: Int -> TZUrl -> ShowS
$cshow :: TZUrl -> String
show :: TZUrl -> String
$cshowList :: [TZUrl] -> ShowS
showList :: [TZUrl] -> ShowS
Show, TZUrl -> TZUrl -> Bool
(TZUrl -> TZUrl -> Bool) -> (TZUrl -> TZUrl -> Bool) -> Eq TZUrl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TZUrl -> TZUrl -> Bool
== :: TZUrl -> TZUrl -> Bool
$c/= :: TZUrl -> TZUrl -> Bool
/= :: TZUrl -> TZUrl -> Bool
Eq, Eq TZUrl
Eq TZUrl =>
(TZUrl -> TZUrl -> Ordering)
-> (TZUrl -> TZUrl -> Bool)
-> (TZUrl -> TZUrl -> Bool)
-> (TZUrl -> TZUrl -> Bool)
-> (TZUrl -> TZUrl -> Bool)
-> (TZUrl -> TZUrl -> TZUrl)
-> (TZUrl -> TZUrl -> TZUrl)
-> Ord TZUrl
TZUrl -> TZUrl -> Bool
TZUrl -> TZUrl -> Ordering
TZUrl -> TZUrl -> TZUrl
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
$ccompare :: TZUrl -> TZUrl -> Ordering
compare :: TZUrl -> TZUrl -> Ordering
$c< :: TZUrl -> TZUrl -> Bool
< :: TZUrl -> TZUrl -> Bool
$c<= :: TZUrl -> TZUrl -> Bool
<= :: TZUrl -> TZUrl -> Bool
$c> :: TZUrl -> TZUrl -> Bool
> :: TZUrl -> TZUrl -> Bool
$c>= :: TZUrl -> TZUrl -> Bool
>= :: TZUrl -> TZUrl -> Bool
$cmax :: TZUrl -> TZUrl -> TZUrl
max :: TZUrl -> TZUrl -> TZUrl
$cmin :: TZUrl -> TZUrl -> TZUrl
min :: TZUrl -> TZUrl -> TZUrl
Ord, Typeable)

-- | Attendee. 3.8.4.1.
data Attendee = Attendee
    { Attendee -> URI
attendeeValue    :: CalAddress
    , Attendee -> CUType
attendeeCUType   :: CUType -- ^ 'def' = 'Individual'
    , Attendee -> Set URI
attendeeMember   :: Set CalAddress
    , Attendee -> Role
attendeeRole     :: Role -- ^ 'def' = 'ReqParticipant'
    , Attendee -> PartStat
attendeePartStat :: PartStat -- ^ 'def' = 'PartStatNeedsAction'
    , Attendee -> Bool
attendeeRSVP     :: Bool
    , Attendee -> Set URI
attendeeDelTo    :: Set CalAddress
    , Attendee -> Set URI
attendeeDelFrom  :: Set CalAddress
    , Attendee -> Maybe URI
attendeeSentBy   :: Maybe CalAddress
    , Attendee -> Maybe Text
attendeeCN       :: Maybe Text
    , Attendee -> Maybe URI
attendeeDir      :: Maybe URI
    , Attendee -> Maybe Language
attendeeLanguage :: Maybe Language
    , Attendee -> OtherParams
attendeeOther    :: OtherParams
    } deriving (Int -> Attendee -> ShowS
[Attendee] -> ShowS
Attendee -> String
(Int -> Attendee -> ShowS)
-> (Attendee -> String) -> ([Attendee] -> ShowS) -> Show Attendee
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Attendee -> ShowS
showsPrec :: Int -> Attendee -> ShowS
$cshow :: Attendee -> String
show :: Attendee -> String
$cshowList :: [Attendee] -> ShowS
showList :: [Attendee] -> ShowS
Show, Attendee -> Attendee -> Bool
(Attendee -> Attendee -> Bool)
-> (Attendee -> Attendee -> Bool) -> Eq Attendee
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Attendee -> Attendee -> Bool
== :: Attendee -> Attendee -> Bool
$c/= :: Attendee -> Attendee -> Bool
/= :: Attendee -> Attendee -> Bool
Eq, Eq Attendee
Eq Attendee =>
(Attendee -> Attendee -> Ordering)
-> (Attendee -> Attendee -> Bool)
-> (Attendee -> Attendee -> Bool)
-> (Attendee -> Attendee -> Bool)
-> (Attendee -> Attendee -> Bool)
-> (Attendee -> Attendee -> Attendee)
-> (Attendee -> Attendee -> Attendee)
-> Ord Attendee
Attendee -> Attendee -> Bool
Attendee -> Attendee -> Ordering
Attendee -> Attendee -> Attendee
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
$ccompare :: Attendee -> Attendee -> Ordering
compare :: Attendee -> Attendee -> Ordering
$c< :: Attendee -> Attendee -> Bool
< :: Attendee -> Attendee -> Bool
$c<= :: Attendee -> Attendee -> Bool
<= :: Attendee -> Attendee -> Bool
$c> :: Attendee -> Attendee -> Bool
> :: Attendee -> Attendee -> Bool
$c>= :: Attendee -> Attendee -> Bool
>= :: Attendee -> Attendee -> Bool
$cmax :: Attendee -> Attendee -> Attendee
max :: Attendee -> Attendee -> Attendee
$cmin :: Attendee -> Attendee -> Attendee
min :: Attendee -> Attendee -> Attendee
Ord, Typeable)

-- | Calendar User Type. 3.2.3.
--
-- Unrecognized CUTypeX MUST be treated as Unknown.
data CUType
    = Individual
    | Group
    | Resource
    | Room
    | Unknown
    | CUTypeX (CI Text)
      deriving (Int -> CUType -> ShowS
[CUType] -> ShowS
CUType -> String
(Int -> CUType -> ShowS)
-> (CUType -> String) -> ([CUType] -> ShowS) -> Show CUType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CUType -> ShowS
showsPrec :: Int -> CUType -> ShowS
$cshow :: CUType -> String
show :: CUType -> String
$cshowList :: [CUType] -> ShowS
showList :: [CUType] -> ShowS
Show, CUType -> CUType -> Bool
(CUType -> CUType -> Bool)
-> (CUType -> CUType -> Bool) -> Eq CUType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CUType -> CUType -> Bool
== :: CUType -> CUType -> Bool
$c/= :: CUType -> CUType -> Bool
/= :: CUType -> CUType -> Bool
Eq, Eq CUType
Eq CUType =>
(CUType -> CUType -> Ordering)
-> (CUType -> CUType -> Bool)
-> (CUType -> CUType -> Bool)
-> (CUType -> CUType -> Bool)
-> (CUType -> CUType -> Bool)
-> (CUType -> CUType -> CUType)
-> (CUType -> CUType -> CUType)
-> Ord CUType
CUType -> CUType -> Bool
CUType -> CUType -> Ordering
CUType -> CUType -> CUType
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
$ccompare :: CUType -> CUType -> Ordering
compare :: CUType -> CUType -> Ordering
$c< :: CUType -> CUType -> Bool
< :: CUType -> CUType -> Bool
$c<= :: CUType -> CUType -> Bool
<= :: CUType -> CUType -> Bool
$c> :: CUType -> CUType -> Bool
> :: CUType -> CUType -> Bool
$c>= :: CUType -> CUType -> Bool
>= :: CUType -> CUType -> Bool
$cmax :: CUType -> CUType -> CUType
max :: CUType -> CUType -> CUType
$cmin :: CUType -> CUType -> CUType
min :: CUType -> CUType -> CUType
Ord, Typeable)

instance Default CUType where
    def :: CUType
def = CUType
Individual

-- | Role. 3.2.16.
data Role = Chair
          | ReqParticipant
          | OptParticipant
          | NonParticipant
          | RoleX (CI Text)
            deriving (Int -> Role -> ShowS
[Role] -> ShowS
Role -> String
(Int -> Role -> ShowS)
-> (Role -> String) -> ([Role] -> ShowS) -> Show Role
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Role -> ShowS
showsPrec :: Int -> Role -> ShowS
$cshow :: Role -> String
show :: Role -> String
$cshowList :: [Role] -> ShowS
showList :: [Role] -> ShowS
Show, Role -> Role -> Bool
(Role -> Role -> Bool) -> (Role -> Role -> Bool) -> Eq Role
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Role -> Role -> Bool
== :: Role -> Role -> Bool
$c/= :: Role -> Role -> Bool
/= :: Role -> Role -> Bool
Eq, Eq Role
Eq Role =>
(Role -> Role -> Ordering)
-> (Role -> Role -> Bool)
-> (Role -> Role -> Bool)
-> (Role -> Role -> Bool)
-> (Role -> Role -> Bool)
-> (Role -> Role -> Role)
-> (Role -> Role -> Role)
-> Ord Role
Role -> Role -> Bool
Role -> Role -> Ordering
Role -> Role -> Role
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
$ccompare :: Role -> Role -> Ordering
compare :: Role -> Role -> Ordering
$c< :: Role -> Role -> Bool
< :: Role -> Role -> Bool
$c<= :: Role -> Role -> Bool
<= :: Role -> Role -> Bool
$c> :: Role -> Role -> Bool
> :: Role -> Role -> Bool
$c>= :: Role -> Role -> Bool
>= :: Role -> Role -> Bool
$cmax :: Role -> Role -> Role
max :: Role -> Role -> Role
$cmin :: Role -> Role -> Role
min :: Role -> Role -> Role
Ord, Typeable)

instance Default Role where
    def :: Role
def = Role
ReqParticipant

-- | Participation Status. 3.2.12.
data PartStat -- Splitting requires splitting attendee too...
    = PartStatNeedsAction
    | Accepted
    | Declined
    | Tentative
    | Delegated
    | PartStatCompleted
    | InProcess
    | PartStatX (CI Text)
      deriving (Int -> PartStat -> ShowS
[PartStat] -> ShowS
PartStat -> String
(Int -> PartStat -> ShowS)
-> (PartStat -> String) -> ([PartStat] -> ShowS) -> Show PartStat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PartStat -> ShowS
showsPrec :: Int -> PartStat -> ShowS
$cshow :: PartStat -> String
show :: PartStat -> String
$cshowList :: [PartStat] -> ShowS
showList :: [PartStat] -> ShowS
Show, PartStat -> PartStat -> Bool
(PartStat -> PartStat -> Bool)
-> (PartStat -> PartStat -> Bool) -> Eq PartStat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PartStat -> PartStat -> Bool
== :: PartStat -> PartStat -> Bool
$c/= :: PartStat -> PartStat -> Bool
/= :: PartStat -> PartStat -> Bool
Eq, Eq PartStat
Eq PartStat =>
(PartStat -> PartStat -> Ordering)
-> (PartStat -> PartStat -> Bool)
-> (PartStat -> PartStat -> Bool)
-> (PartStat -> PartStat -> Bool)
-> (PartStat -> PartStat -> Bool)
-> (PartStat -> PartStat -> PartStat)
-> (PartStat -> PartStat -> PartStat)
-> Ord PartStat
PartStat -> PartStat -> Bool
PartStat -> PartStat -> Ordering
PartStat -> PartStat -> PartStat
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
$ccompare :: PartStat -> PartStat -> Ordering
compare :: PartStat -> PartStat -> Ordering
$c< :: PartStat -> PartStat -> Bool
< :: PartStat -> PartStat -> Bool
$c<= :: PartStat -> PartStat -> Bool
<= :: PartStat -> PartStat -> Bool
$c> :: PartStat -> PartStat -> Bool
> :: PartStat -> PartStat -> Bool
$c>= :: PartStat -> PartStat -> Bool
>= :: PartStat -> PartStat -> Bool
$cmax :: PartStat -> PartStat -> PartStat
max :: PartStat -> PartStat -> PartStat
$cmin :: PartStat -> PartStat -> PartStat
min :: PartStat -> PartStat -> PartStat
Ord, Typeable)

instance Default PartStat where
    def :: PartStat
def = PartStat
PartStatNeedsAction

-- | Contact. 3.8.4.2.
data Contact = Contact
    { Contact -> Text
contactValue    :: Text
    , Contact -> Maybe URI
contactAltRep   :: Maybe URI
    , Contact -> Maybe Language
contactLanguage :: Maybe Language
    , Contact -> OtherParams
contactOther    :: OtherParams
    } deriving (Int -> Contact -> ShowS
[Contact] -> ShowS
Contact -> String
(Int -> Contact -> ShowS)
-> (Contact -> String) -> ([Contact] -> ShowS) -> Show Contact
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Contact -> ShowS
showsPrec :: Int -> Contact -> ShowS
$cshow :: Contact -> String
show :: Contact -> String
$cshowList :: [Contact] -> ShowS
showList :: [Contact] -> ShowS
Show, Contact -> Contact -> Bool
(Contact -> Contact -> Bool)
-> (Contact -> Contact -> Bool) -> Eq Contact
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Contact -> Contact -> Bool
== :: Contact -> Contact -> Bool
$c/= :: Contact -> Contact -> Bool
/= :: Contact -> Contact -> Bool
Eq, Eq Contact
Eq Contact =>
(Contact -> Contact -> Ordering)
-> (Contact -> Contact -> Bool)
-> (Contact -> Contact -> Bool)
-> (Contact -> Contact -> Bool)
-> (Contact -> Contact -> Bool)
-> (Contact -> Contact -> Contact)
-> (Contact -> Contact -> Contact)
-> Ord Contact
Contact -> Contact -> Bool
Contact -> Contact -> Ordering
Contact -> Contact -> Contact
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
$ccompare :: Contact -> Contact -> Ordering
compare :: Contact -> Contact -> Ordering
$c< :: Contact -> Contact -> Bool
< :: Contact -> Contact -> Bool
$c<= :: Contact -> Contact -> Bool
<= :: Contact -> Contact -> Bool
$c> :: Contact -> Contact -> Bool
> :: Contact -> Contact -> Bool
$c>= :: Contact -> Contact -> Bool
>= :: Contact -> Contact -> Bool
$cmax :: Contact -> Contact -> Contact
max :: Contact -> Contact -> Contact
$cmin :: Contact -> Contact -> Contact
min :: Contact -> Contact -> Contact
Ord, Typeable)

-- | Organizer. 3.8.4.3.
--
-- TODO: CAL-ADDRESS-related properties.
data Organizer = Organizer
    { Organizer -> URI
organizerValue    :: CalAddress
    , Organizer -> Maybe Text
organizerCN       :: Maybe Text
    , Organizer -> Maybe URI
organizerDir      :: Maybe URI
    , Organizer -> Maybe URI
organizerSentBy   :: Maybe CalAddress
    , Organizer -> Maybe Language
organizerLanguage :: Maybe Language
    , Organizer -> OtherParams
organizerOther    :: OtherParams
    } deriving (Int -> Organizer -> ShowS
[Organizer] -> ShowS
Organizer -> String
(Int -> Organizer -> ShowS)
-> (Organizer -> String)
-> ([Organizer] -> ShowS)
-> Show Organizer
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Organizer -> ShowS
showsPrec :: Int -> Organizer -> ShowS
$cshow :: Organizer -> String
show :: Organizer -> String
$cshowList :: [Organizer] -> ShowS
showList :: [Organizer] -> ShowS
Show, Organizer -> Organizer -> Bool
(Organizer -> Organizer -> Bool)
-> (Organizer -> Organizer -> Bool) -> Eq Organizer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Organizer -> Organizer -> Bool
== :: Organizer -> Organizer -> Bool
$c/= :: Organizer -> Organizer -> Bool
/= :: Organizer -> Organizer -> Bool
Eq, Eq Organizer
Eq Organizer =>
(Organizer -> Organizer -> Ordering)
-> (Organizer -> Organizer -> Bool)
-> (Organizer -> Organizer -> Bool)
-> (Organizer -> Organizer -> Bool)
-> (Organizer -> Organizer -> Bool)
-> (Organizer -> Organizer -> Organizer)
-> (Organizer -> Organizer -> Organizer)
-> Ord Organizer
Organizer -> Organizer -> Bool
Organizer -> Organizer -> Ordering
Organizer -> Organizer -> Organizer
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
$ccompare :: Organizer -> Organizer -> Ordering
compare :: Organizer -> Organizer -> Ordering
$c< :: Organizer -> Organizer -> Bool
< :: Organizer -> Organizer -> Bool
$c<= :: Organizer -> Organizer -> Bool
<= :: Organizer -> Organizer -> Bool
$c> :: Organizer -> Organizer -> Bool
> :: Organizer -> Organizer -> Bool
$c>= :: Organizer -> Organizer -> Bool
>= :: Organizer -> Organizer -> Bool
$cmax :: Organizer -> Organizer -> Organizer
max :: Organizer -> Organizer -> Organizer
$cmin :: Organizer -> Organizer -> Organizer
min :: Organizer -> Organizer -> Organizer
Ord, Typeable)

-- | Recurrence ID. 3.8.4.4.
data RecurrenceId
    = RecurrenceIdDate
    { RecurrenceId -> Date
recurrenceIdDate  :: Date
    , RecurrenceId -> Maybe Range
recurrenceIdRange :: Maybe Range
    , RecurrenceId -> OtherParams
recurrenceIdOther :: OtherParams
    }
    | RecurrenceIdDateTime
    { RecurrenceId -> DateTime
recurrenceIdDateTime :: DateTime
    , recurrenceIdRange    :: Maybe Range
    , recurrenceIdOther    :: OtherParams
    } deriving (Int -> RecurrenceId -> ShowS
[RecurrenceId] -> ShowS
RecurrenceId -> String
(Int -> RecurrenceId -> ShowS)
-> (RecurrenceId -> String)
-> ([RecurrenceId] -> ShowS)
-> Show RecurrenceId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RecurrenceId -> ShowS
showsPrec :: Int -> RecurrenceId -> ShowS
$cshow :: RecurrenceId -> String
show :: RecurrenceId -> String
$cshowList :: [RecurrenceId] -> ShowS
showList :: [RecurrenceId] -> ShowS
Show, RecurrenceId -> RecurrenceId -> Bool
(RecurrenceId -> RecurrenceId -> Bool)
-> (RecurrenceId -> RecurrenceId -> Bool) -> Eq RecurrenceId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RecurrenceId -> RecurrenceId -> Bool
== :: RecurrenceId -> RecurrenceId -> Bool
$c/= :: RecurrenceId -> RecurrenceId -> Bool
/= :: RecurrenceId -> RecurrenceId -> Bool
Eq, Eq RecurrenceId
Eq RecurrenceId =>
(RecurrenceId -> RecurrenceId -> Ordering)
-> (RecurrenceId -> RecurrenceId -> Bool)
-> (RecurrenceId -> RecurrenceId -> Bool)
-> (RecurrenceId -> RecurrenceId -> Bool)
-> (RecurrenceId -> RecurrenceId -> Bool)
-> (RecurrenceId -> RecurrenceId -> RecurrenceId)
-> (RecurrenceId -> RecurrenceId -> RecurrenceId)
-> Ord RecurrenceId
RecurrenceId -> RecurrenceId -> Bool
RecurrenceId -> RecurrenceId -> Ordering
RecurrenceId -> RecurrenceId -> RecurrenceId
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
$ccompare :: RecurrenceId -> RecurrenceId -> Ordering
compare :: RecurrenceId -> RecurrenceId -> Ordering
$c< :: RecurrenceId -> RecurrenceId -> Bool
< :: RecurrenceId -> RecurrenceId -> Bool
$c<= :: RecurrenceId -> RecurrenceId -> Bool
<= :: RecurrenceId -> RecurrenceId -> Bool
$c> :: RecurrenceId -> RecurrenceId -> Bool
> :: RecurrenceId -> RecurrenceId -> Bool
$c>= :: RecurrenceId -> RecurrenceId -> Bool
>= :: RecurrenceId -> RecurrenceId -> Bool
$cmax :: RecurrenceId -> RecurrenceId -> RecurrenceId
max :: RecurrenceId -> RecurrenceId -> RecurrenceId
$cmin :: RecurrenceId -> RecurrenceId -> RecurrenceId
min :: RecurrenceId -> RecurrenceId -> RecurrenceId
Ord, Typeable)

-- | Recurrence Identifier Range. 3.2.13
data Range = ThisAndFuture | ThisAndPrior
             deriving (Int -> Range -> ShowS
[Range] -> ShowS
Range -> String
(Int -> Range -> ShowS)
-> (Range -> String) -> ([Range] -> ShowS) -> Show Range
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Range -> ShowS
showsPrec :: Int -> Range -> ShowS
$cshow :: Range -> String
show :: Range -> String
$cshowList :: [Range] -> ShowS
showList :: [Range] -> ShowS
Show, Range -> Range -> Bool
(Range -> Range -> Bool) -> (Range -> Range -> Bool) -> Eq Range
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Range -> Range -> Bool
== :: Range -> Range -> Bool
$c/= :: Range -> Range -> Bool
/= :: Range -> Range -> Bool
Eq, Eq Range
Eq Range =>
(Range -> Range -> Ordering)
-> (Range -> Range -> Bool)
-> (Range -> Range -> Bool)
-> (Range -> Range -> Bool)
-> (Range -> Range -> Bool)
-> (Range -> Range -> Range)
-> (Range -> Range -> Range)
-> Ord Range
Range -> Range -> Bool
Range -> Range -> Ordering
Range -> Range -> Range
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
$ccompare :: Range -> Range -> Ordering
compare :: Range -> Range -> Ordering
$c< :: Range -> Range -> Bool
< :: Range -> Range -> Bool
$c<= :: Range -> Range -> Bool
<= :: Range -> Range -> Bool
$c> :: Range -> Range -> Bool
> :: Range -> Range -> Bool
$c>= :: Range -> Range -> Bool
>= :: Range -> Range -> Bool
$cmax :: Range -> Range -> Range
max :: Range -> Range -> Range
$cmin :: Range -> Range -> Range
min :: Range -> Range -> Range
Ord, Typeable)

-- | Related To. 3.8.4.5.
data RelatedTo = RelatedTo
    { RelatedTo -> Text
relatedToValue :: Text
    , RelatedTo -> RelationshipType
relatedToType  :: RelationshipType
    , RelatedTo -> OtherParams
relatedToOther :: OtherParams
    } deriving (Int -> RelatedTo -> ShowS
[RelatedTo] -> ShowS
RelatedTo -> String
(Int -> RelatedTo -> ShowS)
-> (RelatedTo -> String)
-> ([RelatedTo] -> ShowS)
-> Show RelatedTo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RelatedTo -> ShowS
showsPrec :: Int -> RelatedTo -> ShowS
$cshow :: RelatedTo -> String
show :: RelatedTo -> String
$cshowList :: [RelatedTo] -> ShowS
showList :: [RelatedTo] -> ShowS
Show, RelatedTo -> RelatedTo -> Bool
(RelatedTo -> RelatedTo -> Bool)
-> (RelatedTo -> RelatedTo -> Bool) -> Eq RelatedTo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RelatedTo -> RelatedTo -> Bool
== :: RelatedTo -> RelatedTo -> Bool
$c/= :: RelatedTo -> RelatedTo -> Bool
/= :: RelatedTo -> RelatedTo -> Bool
Eq, Eq RelatedTo
Eq RelatedTo =>
(RelatedTo -> RelatedTo -> Ordering)
-> (RelatedTo -> RelatedTo -> Bool)
-> (RelatedTo -> RelatedTo -> Bool)
-> (RelatedTo -> RelatedTo -> Bool)
-> (RelatedTo -> RelatedTo -> Bool)
-> (RelatedTo -> RelatedTo -> RelatedTo)
-> (RelatedTo -> RelatedTo -> RelatedTo)
-> Ord RelatedTo
RelatedTo -> RelatedTo -> Bool
RelatedTo -> RelatedTo -> Ordering
RelatedTo -> RelatedTo -> RelatedTo
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
$ccompare :: RelatedTo -> RelatedTo -> Ordering
compare :: RelatedTo -> RelatedTo -> Ordering
$c< :: RelatedTo -> RelatedTo -> Bool
< :: RelatedTo -> RelatedTo -> Bool
$c<= :: RelatedTo -> RelatedTo -> Bool
<= :: RelatedTo -> RelatedTo -> Bool
$c> :: RelatedTo -> RelatedTo -> Bool
> :: RelatedTo -> RelatedTo -> Bool
$c>= :: RelatedTo -> RelatedTo -> Bool
>= :: RelatedTo -> RelatedTo -> Bool
$cmax :: RelatedTo -> RelatedTo -> RelatedTo
max :: RelatedTo -> RelatedTo -> RelatedTo
$cmin :: RelatedTo -> RelatedTo -> RelatedTo
min :: RelatedTo -> RelatedTo -> RelatedTo
Ord, Typeable)

-- | Relationship Type. 3.2.15.
--
-- Unrecognized RelationshipTypeX values MUST be treated as Parent.
data RelationshipType = Parent | Child | Sibling | RelationshipTypeX (CI Text)
                        deriving (Int -> RelationshipType -> ShowS
[RelationshipType] -> ShowS
RelationshipType -> String
(Int -> RelationshipType -> ShowS)
-> (RelationshipType -> String)
-> ([RelationshipType] -> ShowS)
-> Show RelationshipType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RelationshipType -> ShowS
showsPrec :: Int -> RelationshipType -> ShowS
$cshow :: RelationshipType -> String
show :: RelationshipType -> String
$cshowList :: [RelationshipType] -> ShowS
showList :: [RelationshipType] -> ShowS
Show, RelationshipType -> RelationshipType -> Bool
(RelationshipType -> RelationshipType -> Bool)
-> (RelationshipType -> RelationshipType -> Bool)
-> Eq RelationshipType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RelationshipType -> RelationshipType -> Bool
== :: RelationshipType -> RelationshipType -> Bool
$c/= :: RelationshipType -> RelationshipType -> Bool
/= :: RelationshipType -> RelationshipType -> Bool
Eq, Eq RelationshipType
Eq RelationshipType =>
(RelationshipType -> RelationshipType -> Ordering)
-> (RelationshipType -> RelationshipType -> Bool)
-> (RelationshipType -> RelationshipType -> Bool)
-> (RelationshipType -> RelationshipType -> Bool)
-> (RelationshipType -> RelationshipType -> Bool)
-> (RelationshipType -> RelationshipType -> RelationshipType)
-> (RelationshipType -> RelationshipType -> RelationshipType)
-> Ord RelationshipType
RelationshipType -> RelationshipType -> Bool
RelationshipType -> RelationshipType -> Ordering
RelationshipType -> RelationshipType -> RelationshipType
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
$ccompare :: RelationshipType -> RelationshipType -> Ordering
compare :: RelationshipType -> RelationshipType -> Ordering
$c< :: RelationshipType -> RelationshipType -> Bool
< :: RelationshipType -> RelationshipType -> Bool
$c<= :: RelationshipType -> RelationshipType -> Bool
<= :: RelationshipType -> RelationshipType -> Bool
$c> :: RelationshipType -> RelationshipType -> Bool
> :: RelationshipType -> RelationshipType -> Bool
$c>= :: RelationshipType -> RelationshipType -> Bool
>= :: RelationshipType -> RelationshipType -> Bool
$cmax :: RelationshipType -> RelationshipType -> RelationshipType
max :: RelationshipType -> RelationshipType -> RelationshipType
$cmin :: RelationshipType -> RelationshipType -> RelationshipType
min :: RelationshipType -> RelationshipType -> RelationshipType
Ord, Typeable)

instance Default RelationshipType where
    def :: RelationshipType
def = RelationshipType
Parent

-- | Uniform Resource Locator. 3.8.4.6.
data URL = URL
    { URL -> URI
urlValue :: URI
    , URL -> OtherParams
urlOther :: OtherParams
    } deriving (Int -> URL -> ShowS
[URL] -> ShowS
URL -> String
(Int -> URL -> ShowS)
-> (URL -> String) -> ([URL] -> ShowS) -> Show URL
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> URL -> ShowS
showsPrec :: Int -> URL -> ShowS
$cshow :: URL -> String
show :: URL -> String
$cshowList :: [URL] -> ShowS
showList :: [URL] -> ShowS
Show, URL -> URL -> Bool
(URL -> URL -> Bool) -> (URL -> URL -> Bool) -> Eq URL
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: URL -> URL -> Bool
== :: URL -> URL -> Bool
$c/= :: URL -> URL -> Bool
/= :: URL -> URL -> Bool
Eq, Eq URL
Eq URL =>
(URL -> URL -> Ordering)
-> (URL -> URL -> Bool)
-> (URL -> URL -> Bool)
-> (URL -> URL -> Bool)
-> (URL -> URL -> Bool)
-> (URL -> URL -> URL)
-> (URL -> URL -> URL)
-> Ord URL
URL -> URL -> Bool
URL -> URL -> Ordering
URL -> URL -> URL
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
$ccompare :: URL -> URL -> Ordering
compare :: URL -> URL -> Ordering
$c< :: URL -> URL -> Bool
< :: URL -> URL -> Bool
$c<= :: URL -> URL -> Bool
<= :: URL -> URL -> Bool
$c> :: URL -> URL -> Bool
> :: URL -> URL -> Bool
$c>= :: URL -> URL -> Bool
>= :: URL -> URL -> Bool
$cmax :: URL -> URL -> URL
max :: URL -> URL -> URL
$cmin :: URL -> URL -> URL
min :: URL -> URL -> URL
Ord, Typeable)

-- | Unique Identifier. 3.8.4.7.
data UID = UID
    { UID -> Text
uidValue :: Text
    , UID -> OtherParams
uidOther :: OtherParams
    } deriving (Int -> UID -> ShowS
[UID] -> ShowS
UID -> String
(Int -> UID -> ShowS)
-> (UID -> String) -> ([UID] -> ShowS) -> Show UID
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UID -> ShowS
showsPrec :: Int -> UID -> ShowS
$cshow :: UID -> String
show :: UID -> String
$cshowList :: [UID] -> ShowS
showList :: [UID] -> ShowS
Show, UID -> UID -> Bool
(UID -> UID -> Bool) -> (UID -> UID -> Bool) -> Eq UID
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UID -> UID -> Bool
== :: UID -> UID -> Bool
$c/= :: UID -> UID -> Bool
/= :: UID -> UID -> Bool
Eq, Eq UID
Eq UID =>
(UID -> UID -> Ordering)
-> (UID -> UID -> Bool)
-> (UID -> UID -> Bool)
-> (UID -> UID -> Bool)
-> (UID -> UID -> Bool)
-> (UID -> UID -> UID)
-> (UID -> UID -> UID)
-> Ord UID
UID -> UID -> Bool
UID -> UID -> Ordering
UID -> UID -> UID
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
$ccompare :: UID -> UID -> Ordering
compare :: UID -> UID -> Ordering
$c< :: UID -> UID -> Bool
< :: UID -> UID -> Bool
$c<= :: UID -> UID -> Bool
<= :: UID -> UID -> Bool
$c> :: UID -> UID -> Bool
> :: UID -> UID -> Bool
$c>= :: UID -> UID -> Bool
>= :: UID -> UID -> Bool
$cmax :: UID -> UID -> UID
max :: UID -> UID -> UID
$cmin :: UID -> UID -> UID
min :: UID -> UID -> UID
Ord, Typeable)

-- | Exception Date-Times. 3.8.5.1.
data ExDate
    = ExDates
    { ExDate -> Set Date
exDates     :: Set Date
    , ExDate -> OtherParams
exDateOther :: OtherParams
    }
    | ExDateTimes
    { ExDate -> Set DateTime
exDateTimes :: Set DateTime
    , exDateOther :: OtherParams
    } deriving (Int -> ExDate -> ShowS
[ExDate] -> ShowS
ExDate -> String
(Int -> ExDate -> ShowS)
-> (ExDate -> String) -> ([ExDate] -> ShowS) -> Show ExDate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ExDate -> ShowS
showsPrec :: Int -> ExDate -> ShowS
$cshow :: ExDate -> String
show :: ExDate -> String
$cshowList :: [ExDate] -> ShowS
showList :: [ExDate] -> ShowS
Show, ExDate -> ExDate -> Bool
(ExDate -> ExDate -> Bool)
-> (ExDate -> ExDate -> Bool) -> Eq ExDate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExDate -> ExDate -> Bool
== :: ExDate -> ExDate -> Bool
$c/= :: ExDate -> ExDate -> Bool
/= :: ExDate -> ExDate -> Bool
Eq, Eq ExDate
Eq ExDate =>
(ExDate -> ExDate -> Ordering)
-> (ExDate -> ExDate -> Bool)
-> (ExDate -> ExDate -> Bool)
-> (ExDate -> ExDate -> Bool)
-> (ExDate -> ExDate -> Bool)
-> (ExDate -> ExDate -> ExDate)
-> (ExDate -> ExDate -> ExDate)
-> Ord ExDate
ExDate -> ExDate -> Bool
ExDate -> ExDate -> Ordering
ExDate -> ExDate -> ExDate
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
$ccompare :: ExDate -> ExDate -> Ordering
compare :: ExDate -> ExDate -> Ordering
$c< :: ExDate -> ExDate -> Bool
< :: ExDate -> ExDate -> Bool
$c<= :: ExDate -> ExDate -> Bool
<= :: ExDate -> ExDate -> Bool
$c> :: ExDate -> ExDate -> Bool
> :: ExDate -> ExDate -> Bool
$c>= :: ExDate -> ExDate -> Bool
>= :: ExDate -> ExDate -> Bool
$cmax :: ExDate -> ExDate -> ExDate
max :: ExDate -> ExDate -> ExDate
$cmin :: ExDate -> ExDate -> ExDate
min :: ExDate -> ExDate -> ExDate
Ord, Typeable)

-- | Recurrence Date-Times. 3.8.5.2.
data RDate
    = RDateDates
    { RDate -> Set Date
rDateDates :: Set Date
    , RDate -> OtherParams
rDateOther :: OtherParams
    }
    | RDateDateTimes
    { RDate -> Set DateTime
rDateDateTimes :: Set DateTime
    , rDateOther     :: OtherParams
    }
    | RDatePeriods
    { RDate -> Set Period
rDatePeriods :: Set Period
    , rDateOther   :: OtherParams
    } deriving (Int -> RDate -> ShowS
[RDate] -> ShowS
RDate -> String
(Int -> RDate -> ShowS)
-> (RDate -> String) -> ([RDate] -> ShowS) -> Show RDate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RDate -> ShowS
showsPrec :: Int -> RDate -> ShowS
$cshow :: RDate -> String
show :: RDate -> String
$cshowList :: [RDate] -> ShowS
showList :: [RDate] -> ShowS
Show, RDate -> RDate -> Bool
(RDate -> RDate -> Bool) -> (RDate -> RDate -> Bool) -> Eq RDate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RDate -> RDate -> Bool
== :: RDate -> RDate -> Bool
$c/= :: RDate -> RDate -> Bool
/= :: RDate -> RDate -> Bool
Eq, Eq RDate
Eq RDate =>
(RDate -> RDate -> Ordering)
-> (RDate -> RDate -> Bool)
-> (RDate -> RDate -> Bool)
-> (RDate -> RDate -> Bool)
-> (RDate -> RDate -> Bool)
-> (RDate -> RDate -> RDate)
-> (RDate -> RDate -> RDate)
-> Ord RDate
RDate -> RDate -> Bool
RDate -> RDate -> Ordering
RDate -> RDate -> RDate
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
$ccompare :: RDate -> RDate -> Ordering
compare :: RDate -> RDate -> Ordering
$c< :: RDate -> RDate -> Bool
< :: RDate -> RDate -> Bool
$c<= :: RDate -> RDate -> Bool
<= :: RDate -> RDate -> Bool
$c> :: RDate -> RDate -> Bool
> :: RDate -> RDate -> Bool
$c>= :: RDate -> RDate -> Bool
>= :: RDate -> RDate -> Bool
$cmax :: RDate -> RDate -> RDate
max :: RDate -> RDate -> RDate
$cmin :: RDate -> RDate -> RDate
min :: RDate -> RDate -> RDate
Ord, Typeable)

-- | Frequency in recurrences. 3.3.10.
data Frequency
    = Secondly
    | Minutely
    | Hourly
    | Daily
    | Weekly
    | Monthly
    | Yearly
      deriving (Int -> Frequency -> ShowS
[Frequency] -> ShowS
Frequency -> String
(Int -> Frequency -> ShowS)
-> (Frequency -> String)
-> ([Frequency] -> ShowS)
-> Show Frequency
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Frequency -> ShowS
showsPrec :: Int -> Frequency -> ShowS
$cshow :: Frequency -> String
show :: Frequency -> String
$cshowList :: [Frequency] -> ShowS
showList :: [Frequency] -> ShowS
Show, Frequency -> Frequency -> Bool
(Frequency -> Frequency -> Bool)
-> (Frequency -> Frequency -> Bool) -> Eq Frequency
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Frequency -> Frequency -> Bool
== :: Frequency -> Frequency -> Bool
$c/= :: Frequency -> Frequency -> Bool
/= :: Frequency -> Frequency -> Bool
Eq, Eq Frequency
Eq Frequency =>
(Frequency -> Frequency -> Ordering)
-> (Frequency -> Frequency -> Bool)
-> (Frequency -> Frequency -> Bool)
-> (Frequency -> Frequency -> Bool)
-> (Frequency -> Frequency -> Bool)
-> (Frequency -> Frequency -> Frequency)
-> (Frequency -> Frequency -> Frequency)
-> Ord Frequency
Frequency -> Frequency -> Bool
Frequency -> Frequency -> Ordering
Frequency -> Frequency -> Frequency
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
$ccompare :: Frequency -> Frequency -> Ordering
compare :: Frequency -> Frequency -> Ordering
$c< :: Frequency -> Frequency -> Bool
< :: Frequency -> Frequency -> Bool
$c<= :: Frequency -> Frequency -> Bool
<= :: Frequency -> Frequency -> Bool
$c> :: Frequency -> Frequency -> Bool
> :: Frequency -> Frequency -> Bool
$c>= :: Frequency -> Frequency -> Bool
>= :: Frequency -> Frequency -> Bool
$cmax :: Frequency -> Frequency -> Frequency
max :: Frequency -> Frequency -> Frequency
$cmin :: Frequency -> Frequency -> Frequency
min :: Frequency -> Frequency -> Frequency
Ord, Typeable)

-- | Weekday, in recurrences. 3.3.10.
data Weekday = Sunday | Monday | Tuesday | Wednesday | Thursday
                      | Friday | Saturday
               deriving (Int -> Weekday -> ShowS
[Weekday] -> ShowS
Weekday -> String
(Int -> Weekday -> ShowS)
-> (Weekday -> String) -> ([Weekday] -> ShowS) -> Show Weekday
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Weekday -> ShowS
showsPrec :: Int -> Weekday -> ShowS
$cshow :: Weekday -> String
show :: Weekday -> String
$cshowList :: [Weekday] -> ShowS
showList :: [Weekday] -> ShowS
Show, Weekday -> Weekday -> Bool
(Weekday -> Weekday -> Bool)
-> (Weekday -> Weekday -> Bool) -> Eq Weekday
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Weekday -> Weekday -> Bool
== :: Weekday -> Weekday -> Bool
$c/= :: Weekday -> Weekday -> Bool
/= :: Weekday -> Weekday -> Bool
Eq, Eq Weekday
Eq Weekday =>
(Weekday -> Weekday -> Ordering)
-> (Weekday -> Weekday -> Bool)
-> (Weekday -> Weekday -> Bool)
-> (Weekday -> Weekday -> Bool)
-> (Weekday -> Weekday -> Bool)
-> (Weekday -> Weekday -> Weekday)
-> (Weekday -> Weekday -> Weekday)
-> Ord Weekday
Weekday -> Weekday -> Bool
Weekday -> Weekday -> Ordering
Weekday -> Weekday -> Weekday
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
$ccompare :: Weekday -> Weekday -> Ordering
compare :: Weekday -> Weekday -> Ordering
$c< :: Weekday -> Weekday -> Bool
< :: Weekday -> Weekday -> Bool
$c<= :: Weekday -> Weekday -> Bool
<= :: Weekday -> Weekday -> Bool
$c> :: Weekday -> Weekday -> Bool
> :: Weekday -> Weekday -> Bool
$c>= :: Weekday -> Weekday -> Bool
>= :: Weekday -> Weekday -> Bool
$cmax :: Weekday -> Weekday -> Weekday
max :: Weekday -> Weekday -> Weekday
$cmin :: Weekday -> Weekday -> Weekday
min :: Weekday -> Weekday -> Weekday
Ord, Weekday
Weekday -> Weekday -> Bounded Weekday
forall a. a -> a -> Bounded a
$cminBound :: Weekday
minBound :: Weekday
$cmaxBound :: Weekday
maxBound :: Weekday
Bounded, Int -> Weekday
Weekday -> Int
Weekday -> [Weekday]
Weekday -> Weekday
Weekday -> Weekday -> [Weekday]
Weekday -> Weekday -> Weekday -> [Weekday]
(Weekday -> Weekday)
-> (Weekday -> Weekday)
-> (Int -> Weekday)
-> (Weekday -> Int)
-> (Weekday -> [Weekday])
-> (Weekday -> Weekday -> [Weekday])
-> (Weekday -> Weekday -> [Weekday])
-> (Weekday -> Weekday -> Weekday -> [Weekday])
-> Enum Weekday
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Weekday -> Weekday
succ :: Weekday -> Weekday
$cpred :: Weekday -> Weekday
pred :: Weekday -> Weekday
$ctoEnum :: Int -> Weekday
toEnum :: Int -> Weekday
$cfromEnum :: Weekday -> Int
fromEnum :: Weekday -> Int
$cenumFrom :: Weekday -> [Weekday]
enumFrom :: Weekday -> [Weekday]
$cenumFromThen :: Weekday -> Weekday -> [Weekday]
enumFromThen :: Weekday -> Weekday -> [Weekday]
$cenumFromTo :: Weekday -> Weekday -> [Weekday]
enumFromTo :: Weekday -> Weekday -> [Weekday]
$cenumFromThenTo :: Weekday -> Weekday -> Weekday -> [Weekday]
enumFromThenTo :: Weekday -> Weekday -> Weekday -> [Weekday]
Enum, Typeable)

-- | Recur value. 3.3.10.
data Recur = Recur
    { Recur -> Frequency
recurFreq       :: Frequency
    , Recur -> Maybe (Either (Either Date DateTime) Int)
recurUntilCount :: Maybe (Either (Either Date DateTime) Int)
    , Recur -> Int
recurInterval   :: Int
    , Recur -> [Int]
recurBySecond   :: [Int]
    , Recur -> [Int]
recurByMinute   :: [Int]
    , Recur -> [Int]
recurByHour     :: [Int]
    , Recur -> [Either (Int, Weekday) Weekday]
recurByDay      :: [Either (Int, Weekday) Weekday]
    , Recur -> [Int]
recurByMonthDay :: [Int]
    , Recur -> [Int]
recurByYearDay  :: [Int]
    , Recur -> [Int]
recurByWeekNo   :: [Int]
    , Recur -> [Int]
recurByMonth    :: [Int]
    , Recur -> [Int]
recurBySetPos   :: [Int]
    , Recur -> Weekday
recurWkSt       :: Weekday
    } deriving (Int -> Recur -> ShowS
[Recur] -> ShowS
Recur -> String
(Int -> Recur -> ShowS)
-> (Recur -> String) -> ([Recur] -> ShowS) -> Show Recur
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Recur -> ShowS
showsPrec :: Int -> Recur -> ShowS
$cshow :: Recur -> String
show :: Recur -> String
$cshowList :: [Recur] -> ShowS
showList :: [Recur] -> ShowS
Show, Recur -> Recur -> Bool
(Recur -> Recur -> Bool) -> (Recur -> Recur -> Bool) -> Eq Recur
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Recur -> Recur -> Bool
== :: Recur -> Recur -> Bool
$c/= :: Recur -> Recur -> Bool
/= :: Recur -> Recur -> Bool
Eq, Eq Recur
Eq Recur =>
(Recur -> Recur -> Ordering)
-> (Recur -> Recur -> Bool)
-> (Recur -> Recur -> Bool)
-> (Recur -> Recur -> Bool)
-> (Recur -> Recur -> Bool)
-> (Recur -> Recur -> Recur)
-> (Recur -> Recur -> Recur)
-> Ord Recur
Recur -> Recur -> Bool
Recur -> Recur -> Ordering
Recur -> Recur -> Recur
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
$ccompare :: Recur -> Recur -> Ordering
compare :: Recur -> Recur -> Ordering
$c< :: Recur -> Recur -> Bool
< :: Recur -> Recur -> Bool
$c<= :: Recur -> Recur -> Bool
<= :: Recur -> Recur -> Bool
$c> :: Recur -> Recur -> Bool
> :: Recur -> Recur -> Bool
$c>= :: Recur -> Recur -> Bool
>= :: Recur -> Recur -> Bool
$cmax :: Recur -> Recur -> Recur
max :: Recur -> Recur -> Recur
$cmin :: Recur -> Recur -> Recur
min :: Recur -> Recur -> Recur
Ord, Typeable)

-- | Recurrence Rule. 3.8.5.3.
data RRule = RRule
    { RRule -> Recur
rRuleValue :: Recur
    , RRule -> OtherParams
rRuleOther :: OtherParams
    } deriving (Int -> RRule -> ShowS
[RRule] -> ShowS
RRule -> String
(Int -> RRule -> ShowS)
-> (RRule -> String) -> ([RRule] -> ShowS) -> Show RRule
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RRule -> ShowS
showsPrec :: Int -> RRule -> ShowS
$cshow :: RRule -> String
show :: RRule -> String
$cshowList :: [RRule] -> ShowS
showList :: [RRule] -> ShowS
Show, RRule -> RRule -> Bool
(RRule -> RRule -> Bool) -> (RRule -> RRule -> Bool) -> Eq RRule
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RRule -> RRule -> Bool
== :: RRule -> RRule -> Bool
$c/= :: RRule -> RRule -> Bool
/= :: RRule -> RRule -> Bool
Eq, Eq RRule
Eq RRule =>
(RRule -> RRule -> Ordering)
-> (RRule -> RRule -> Bool)
-> (RRule -> RRule -> Bool)
-> (RRule -> RRule -> Bool)
-> (RRule -> RRule -> Bool)
-> (RRule -> RRule -> RRule)
-> (RRule -> RRule -> RRule)
-> Ord RRule
RRule -> RRule -> Bool
RRule -> RRule -> Ordering
RRule -> RRule -> RRule
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
$ccompare :: RRule -> RRule -> Ordering
compare :: RRule -> RRule -> Ordering
$c< :: RRule -> RRule -> Bool
< :: RRule -> RRule -> Bool
$c<= :: RRule -> RRule -> Bool
<= :: RRule -> RRule -> Bool
$c> :: RRule -> RRule -> Bool
> :: RRule -> RRule -> Bool
$c>= :: RRule -> RRule -> Bool
>= :: RRule -> RRule -> Bool
$cmax :: RRule -> RRule -> RRule
max :: RRule -> RRule -> RRule
$cmin :: RRule -> RRule -> RRule
min :: RRule -> RRule -> RRule
Ord, Typeable)

-- | Repeat count. 3.8.6.2.
data Repeat = Repeat
    { Repeat -> Integer
repeatValue :: Integer
    , Repeat -> OtherParams
repeatOther :: OtherParams
    } deriving (Int -> Repeat -> ShowS
[Repeat] -> ShowS
Repeat -> String
(Int -> Repeat -> ShowS)
-> (Repeat -> String) -> ([Repeat] -> ShowS) -> Show Repeat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Repeat -> ShowS
showsPrec :: Int -> Repeat -> ShowS
$cshow :: Repeat -> String
show :: Repeat -> String
$cshowList :: [Repeat] -> ShowS
showList :: [Repeat] -> ShowS
Show, Repeat -> Repeat -> Bool
(Repeat -> Repeat -> Bool)
-> (Repeat -> Repeat -> Bool) -> Eq Repeat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Repeat -> Repeat -> Bool
== :: Repeat -> Repeat -> Bool
$c/= :: Repeat -> Repeat -> Bool
/= :: Repeat -> Repeat -> Bool
Eq, Eq Repeat
Eq Repeat =>
(Repeat -> Repeat -> Ordering)
-> (Repeat -> Repeat -> Bool)
-> (Repeat -> Repeat -> Bool)
-> (Repeat -> Repeat -> Bool)
-> (Repeat -> Repeat -> Bool)
-> (Repeat -> Repeat -> Repeat)
-> (Repeat -> Repeat -> Repeat)
-> Ord Repeat
Repeat -> Repeat -> Bool
Repeat -> Repeat -> Ordering
Repeat -> Repeat -> Repeat
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
$ccompare :: Repeat -> Repeat -> Ordering
compare :: Repeat -> Repeat -> Ordering
$c< :: Repeat -> Repeat -> Bool
< :: Repeat -> Repeat -> Bool
$c<= :: Repeat -> Repeat -> Bool
<= :: Repeat -> Repeat -> Bool
$c> :: Repeat -> Repeat -> Bool
> :: Repeat -> Repeat -> Bool
$c>= :: Repeat -> Repeat -> Bool
>= :: Repeat -> Repeat -> Bool
$cmax :: Repeat -> Repeat -> Repeat
max :: Repeat -> Repeat -> Repeat
$cmin :: Repeat -> Repeat -> Repeat
min :: Repeat -> Repeat -> Repeat
Ord, Typeable)

instance Default Repeat where
    def :: Repeat
def = Integer -> OtherParams -> Repeat
Repeat Integer
0 OtherParams
forall a. Default a => a
def

-- | Alarm Trigger Relationship. 3.2.14.
data AlarmTriggerRelationship = Start | End
                                deriving (Int -> AlarmTriggerRelationship -> ShowS
[AlarmTriggerRelationship] -> ShowS
AlarmTriggerRelationship -> String
(Int -> AlarmTriggerRelationship -> ShowS)
-> (AlarmTriggerRelationship -> String)
-> ([AlarmTriggerRelationship] -> ShowS)
-> Show AlarmTriggerRelationship
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AlarmTriggerRelationship -> ShowS
showsPrec :: Int -> AlarmTriggerRelationship -> ShowS
$cshow :: AlarmTriggerRelationship -> String
show :: AlarmTriggerRelationship -> String
$cshowList :: [AlarmTriggerRelationship] -> ShowS
showList :: [AlarmTriggerRelationship] -> ShowS
Show, AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool
(AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool)
-> (AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool)
-> Eq AlarmTriggerRelationship
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool
== :: AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool
$c/= :: AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool
/= :: AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool
Eq, Eq AlarmTriggerRelationship
Eq AlarmTriggerRelationship =>
(AlarmTriggerRelationship -> AlarmTriggerRelationship -> Ordering)
-> (AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool)
-> (AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool)
-> (AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool)
-> (AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool)
-> (AlarmTriggerRelationship
    -> AlarmTriggerRelationship -> AlarmTriggerRelationship)
-> (AlarmTriggerRelationship
    -> AlarmTriggerRelationship -> AlarmTriggerRelationship)
-> Ord AlarmTriggerRelationship
AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool
AlarmTriggerRelationship -> AlarmTriggerRelationship -> Ordering
AlarmTriggerRelationship
-> AlarmTriggerRelationship -> AlarmTriggerRelationship
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
$ccompare :: AlarmTriggerRelationship -> AlarmTriggerRelationship -> Ordering
compare :: AlarmTriggerRelationship -> AlarmTriggerRelationship -> Ordering
$c< :: AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool
< :: AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool
$c<= :: AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool
<= :: AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool
$c> :: AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool
> :: AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool
$c>= :: AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool
>= :: AlarmTriggerRelationship -> AlarmTriggerRelationship -> Bool
$cmax :: AlarmTriggerRelationship
-> AlarmTriggerRelationship -> AlarmTriggerRelationship
max :: AlarmTriggerRelationship
-> AlarmTriggerRelationship -> AlarmTriggerRelationship
$cmin :: AlarmTriggerRelationship
-> AlarmTriggerRelationship -> AlarmTriggerRelationship
min :: AlarmTriggerRelationship
-> AlarmTriggerRelationship -> AlarmTriggerRelationship
Ord, Typeable)

instance Default AlarmTriggerRelationship where
    def :: AlarmTriggerRelationship
def = AlarmTriggerRelationship
Start

-- | Trigger. 3.8.6.3.
data Trigger
    = TriggerDuration
    { Trigger -> Duration
triggerDuration :: Duration
    , Trigger -> AlarmTriggerRelationship
triggerRelated  :: AlarmTriggerRelationship -- ^ 'def' = 'Start'
    , Trigger -> OtherParams
triggerOther    :: OtherParams
    }
    | TriggerDateTime
    { Trigger -> UTCTime
triggerDateTime :: UTCTime
    , triggerOther    :: OtherParams
    } deriving (Int -> Trigger -> ShowS
[Trigger] -> ShowS
Trigger -> String
(Int -> Trigger -> ShowS)
-> (Trigger -> String) -> ([Trigger] -> ShowS) -> Show Trigger
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Trigger -> ShowS
showsPrec :: Int -> Trigger -> ShowS
$cshow :: Trigger -> String
show :: Trigger -> String
$cshowList :: [Trigger] -> ShowS
showList :: [Trigger] -> ShowS
Show, Trigger -> Trigger -> Bool
(Trigger -> Trigger -> Bool)
-> (Trigger -> Trigger -> Bool) -> Eq Trigger
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Trigger -> Trigger -> Bool
== :: Trigger -> Trigger -> Bool
$c/= :: Trigger -> Trigger -> Bool
/= :: Trigger -> Trigger -> Bool
Eq, Eq Trigger
Eq Trigger =>
(Trigger -> Trigger -> Ordering)
-> (Trigger -> Trigger -> Bool)
-> (Trigger -> Trigger -> Bool)
-> (Trigger -> Trigger -> Bool)
-> (Trigger -> Trigger -> Bool)
-> (Trigger -> Trigger -> Trigger)
-> (Trigger -> Trigger -> Trigger)
-> Ord Trigger
Trigger -> Trigger -> Bool
Trigger -> Trigger -> Ordering
Trigger -> Trigger -> Trigger
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
$ccompare :: Trigger -> Trigger -> Ordering
compare :: Trigger -> Trigger -> Ordering
$c< :: Trigger -> Trigger -> Bool
< :: Trigger -> Trigger -> Bool
$c<= :: Trigger -> Trigger -> Bool
<= :: Trigger -> Trigger -> Bool
$c> :: Trigger -> Trigger -> Bool
> :: Trigger -> Trigger -> Bool
$c>= :: Trigger -> Trigger -> Bool
>= :: Trigger -> Trigger -> Bool
$cmax :: Trigger -> Trigger -> Trigger
max :: Trigger -> Trigger -> Trigger
$cmin :: Trigger -> Trigger -> Trigger
min :: Trigger -> Trigger -> Trigger
Ord, Typeable)

-- | Date-Time Created. 3.8.7.1.
data Created = Created
    { Created -> UTCTime
createdValue :: UTCTime
    , Created -> OtherParams
createdOther :: OtherParams
    } deriving (Int -> Created -> ShowS
[Created] -> ShowS
Created -> String
(Int -> Created -> ShowS)
-> (Created -> String) -> ([Created] -> ShowS) -> Show Created
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Created -> ShowS
showsPrec :: Int -> Created -> ShowS
$cshow :: Created -> String
show :: Created -> String
$cshowList :: [Created] -> ShowS
showList :: [Created] -> ShowS
Show, Created -> Created -> Bool
(Created -> Created -> Bool)
-> (Created -> Created -> Bool) -> Eq Created
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Created -> Created -> Bool
== :: Created -> Created -> Bool
$c/= :: Created -> Created -> Bool
/= :: Created -> Created -> Bool
Eq, Eq Created
Eq Created =>
(Created -> Created -> Ordering)
-> (Created -> Created -> Bool)
-> (Created -> Created -> Bool)
-> (Created -> Created -> Bool)
-> (Created -> Created -> Bool)
-> (Created -> Created -> Created)
-> (Created -> Created -> Created)
-> Ord Created
Created -> Created -> Bool
Created -> Created -> Ordering
Created -> Created -> Created
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
$ccompare :: Created -> Created -> Ordering
compare :: Created -> Created -> Ordering
$c< :: Created -> Created -> Bool
< :: Created -> Created -> Bool
$c<= :: Created -> Created -> Bool
<= :: Created -> Created -> Bool
$c> :: Created -> Created -> Bool
> :: Created -> Created -> Bool
$c>= :: Created -> Created -> Bool
>= :: Created -> Created -> Bool
$cmax :: Created -> Created -> Created
max :: Created -> Created -> Created
$cmin :: Created -> Created -> Created
min :: Created -> Created -> Created
Ord, Typeable)

-- | Date-Time Stamp. 3.8.7.2.
data DTStamp = DTStamp
    { DTStamp -> UTCTime
dtStampValue :: UTCTime
    , DTStamp -> OtherParams
dtStampOther :: OtherParams
    } deriving (Int -> DTStamp -> ShowS
[DTStamp] -> ShowS
DTStamp -> String
(Int -> DTStamp -> ShowS)
-> (DTStamp -> String) -> ([DTStamp] -> ShowS) -> Show DTStamp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DTStamp -> ShowS
showsPrec :: Int -> DTStamp -> ShowS
$cshow :: DTStamp -> String
show :: DTStamp -> String
$cshowList :: [DTStamp] -> ShowS
showList :: [DTStamp] -> ShowS
Show, DTStamp -> DTStamp -> Bool
(DTStamp -> DTStamp -> Bool)
-> (DTStamp -> DTStamp -> Bool) -> Eq DTStamp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DTStamp -> DTStamp -> Bool
== :: DTStamp -> DTStamp -> Bool
$c/= :: DTStamp -> DTStamp -> Bool
/= :: DTStamp -> DTStamp -> Bool
Eq, Eq DTStamp
Eq DTStamp =>
(DTStamp -> DTStamp -> Ordering)
-> (DTStamp -> DTStamp -> Bool)
-> (DTStamp -> DTStamp -> Bool)
-> (DTStamp -> DTStamp -> Bool)
-> (DTStamp -> DTStamp -> Bool)
-> (DTStamp -> DTStamp -> DTStamp)
-> (DTStamp -> DTStamp -> DTStamp)
-> Ord DTStamp
DTStamp -> DTStamp -> Bool
DTStamp -> DTStamp -> Ordering
DTStamp -> DTStamp -> DTStamp
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
$ccompare :: DTStamp -> DTStamp -> Ordering
compare :: DTStamp -> DTStamp -> Ordering
$c< :: DTStamp -> DTStamp -> Bool
< :: DTStamp -> DTStamp -> Bool
$c<= :: DTStamp -> DTStamp -> Bool
<= :: DTStamp -> DTStamp -> Bool
$c> :: DTStamp -> DTStamp -> Bool
> :: DTStamp -> DTStamp -> Bool
$c>= :: DTStamp -> DTStamp -> Bool
>= :: DTStamp -> DTStamp -> Bool
$cmax :: DTStamp -> DTStamp -> DTStamp
max :: DTStamp -> DTStamp -> DTStamp
$cmin :: DTStamp -> DTStamp -> DTStamp
min :: DTStamp -> DTStamp -> DTStamp
Ord, Typeable)

-- | Last Modified. 3.8.7.3.
data LastModified = LastModified
    { LastModified -> UTCTime
lastModifiedValue :: UTCTime
    , LastModified -> OtherParams
lastModifiedOther :: OtherParams
    } deriving (Int -> LastModified -> ShowS
[LastModified] -> ShowS
LastModified -> String
(Int -> LastModified -> ShowS)
-> (LastModified -> String)
-> ([LastModified] -> ShowS)
-> Show LastModified
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LastModified -> ShowS
showsPrec :: Int -> LastModified -> ShowS
$cshow :: LastModified -> String
show :: LastModified -> String
$cshowList :: [LastModified] -> ShowS
showList :: [LastModified] -> ShowS
Show, LastModified -> LastModified -> Bool
(LastModified -> LastModified -> Bool)
-> (LastModified -> LastModified -> Bool) -> Eq LastModified
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LastModified -> LastModified -> Bool
== :: LastModified -> LastModified -> Bool
$c/= :: LastModified -> LastModified -> Bool
/= :: LastModified -> LastModified -> Bool
Eq, Eq LastModified
Eq LastModified =>
(LastModified -> LastModified -> Ordering)
-> (LastModified -> LastModified -> Bool)
-> (LastModified -> LastModified -> Bool)
-> (LastModified -> LastModified -> Bool)
-> (LastModified -> LastModified -> Bool)
-> (LastModified -> LastModified -> LastModified)
-> (LastModified -> LastModified -> LastModified)
-> Ord LastModified
LastModified -> LastModified -> Bool
LastModified -> LastModified -> Ordering
LastModified -> LastModified -> LastModified
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
$ccompare :: LastModified -> LastModified -> Ordering
compare :: LastModified -> LastModified -> Ordering
$c< :: LastModified -> LastModified -> Bool
< :: LastModified -> LastModified -> Bool
$c<= :: LastModified -> LastModified -> Bool
<= :: LastModified -> LastModified -> Bool
$c> :: LastModified -> LastModified -> Bool
> :: LastModified -> LastModified -> Bool
$c>= :: LastModified -> LastModified -> Bool
>= :: LastModified -> LastModified -> Bool
$cmax :: LastModified -> LastModified -> LastModified
max :: LastModified -> LastModified -> LastModified
$cmin :: LastModified -> LastModified -> LastModified
min :: LastModified -> LastModified -> LastModified
Ord, Typeable)

-- | Sequence number. 3.8.7.4.
data Sequence = Sequence
    { Sequence -> Integer
sequenceValue :: Integer
    , Sequence -> OtherParams
sequenceOther :: OtherParams
    } deriving (Int -> Sequence -> ShowS
[Sequence] -> ShowS
Sequence -> String
(Int -> Sequence -> ShowS)
-> (Sequence -> String) -> ([Sequence] -> ShowS) -> Show Sequence
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Sequence -> ShowS
showsPrec :: Int -> Sequence -> ShowS
$cshow :: Sequence -> String
show :: Sequence -> String
$cshowList :: [Sequence] -> ShowS
showList :: [Sequence] -> ShowS
Show, Sequence -> Sequence -> Bool
(Sequence -> Sequence -> Bool)
-> (Sequence -> Sequence -> Bool) -> Eq Sequence
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Sequence -> Sequence -> Bool
== :: Sequence -> Sequence -> Bool
$c/= :: Sequence -> Sequence -> Bool
/= :: Sequence -> Sequence -> Bool
Eq, Eq Sequence
Eq Sequence =>
(Sequence -> Sequence -> Ordering)
-> (Sequence -> Sequence -> Bool)
-> (Sequence -> Sequence -> Bool)
-> (Sequence -> Sequence -> Bool)
-> (Sequence -> Sequence -> Bool)
-> (Sequence -> Sequence -> Sequence)
-> (Sequence -> Sequence -> Sequence)
-> Ord Sequence
Sequence -> Sequence -> Bool
Sequence -> Sequence -> Ordering
Sequence -> Sequence -> Sequence
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
$ccompare :: Sequence -> Sequence -> Ordering
compare :: Sequence -> Sequence -> Ordering
$c< :: Sequence -> Sequence -> Bool
< :: Sequence -> Sequence -> Bool
$c<= :: Sequence -> Sequence -> Bool
<= :: Sequence -> Sequence -> Bool
$c> :: Sequence -> Sequence -> Bool
> :: Sequence -> Sequence -> Bool
$c>= :: Sequence -> Sequence -> Bool
>= :: Sequence -> Sequence -> Bool
$cmax :: Sequence -> Sequence -> Sequence
max :: Sequence -> Sequence -> Sequence
$cmin :: Sequence -> Sequence -> Sequence
min :: Sequence -> Sequence -> Sequence
Ord, Typeable)

instance Default Sequence where
    def :: Sequence
def = Integer -> OtherParams -> Sequence
Sequence Integer
0 OtherParams
forall a. Default a => a
def

-- | Request Status. 3.8.8.3.
data RequestStatus = RequestStatus
    { RequestStatus -> [Int]
requestStatusCode     :: [Int]
    , RequestStatus -> Text
requestStatusDesc     :: Text
    , RequestStatus -> Maybe Language
requestStatusLanguage :: Maybe Language
    , RequestStatus -> Maybe Text
requestStatusExt      :: Maybe Text
    , RequestStatus -> OtherParams
requestStatusOther    :: OtherParams
    } deriving (Int -> RequestStatus -> ShowS
[RequestStatus] -> ShowS
RequestStatus -> String
(Int -> RequestStatus -> ShowS)
-> (RequestStatus -> String)
-> ([RequestStatus] -> ShowS)
-> Show RequestStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RequestStatus -> ShowS
showsPrec :: Int -> RequestStatus -> ShowS
$cshow :: RequestStatus -> String
show :: RequestStatus -> String
$cshowList :: [RequestStatus] -> ShowS
showList :: [RequestStatus] -> ShowS
Show, RequestStatus -> RequestStatus -> Bool
(RequestStatus -> RequestStatus -> Bool)
-> (RequestStatus -> RequestStatus -> Bool) -> Eq RequestStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RequestStatus -> RequestStatus -> Bool
== :: RequestStatus -> RequestStatus -> Bool
$c/= :: RequestStatus -> RequestStatus -> Bool
/= :: RequestStatus -> RequestStatus -> Bool
Eq, Eq RequestStatus
Eq RequestStatus =>
(RequestStatus -> RequestStatus -> Ordering)
-> (RequestStatus -> RequestStatus -> Bool)
-> (RequestStatus -> RequestStatus -> Bool)
-> (RequestStatus -> RequestStatus -> Bool)
-> (RequestStatus -> RequestStatus -> Bool)
-> (RequestStatus -> RequestStatus -> RequestStatus)
-> (RequestStatus -> RequestStatus -> RequestStatus)
-> Ord RequestStatus
RequestStatus -> RequestStatus -> Bool
RequestStatus -> RequestStatus -> Ordering
RequestStatus -> RequestStatus -> RequestStatus
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
$ccompare :: RequestStatus -> RequestStatus -> Ordering
compare :: RequestStatus -> RequestStatus -> Ordering
$c< :: RequestStatus -> RequestStatus -> Bool
< :: RequestStatus -> RequestStatus -> Bool
$c<= :: RequestStatus -> RequestStatus -> Bool
<= :: RequestStatus -> RequestStatus -> Bool
$c> :: RequestStatus -> RequestStatus -> Bool
> :: RequestStatus -> RequestStatus -> Bool
$c>= :: RequestStatus -> RequestStatus -> Bool
>= :: RequestStatus -> RequestStatus -> Bool
$cmax :: RequestStatus -> RequestStatus -> RequestStatus
max :: RequestStatus -> RequestStatus -> RequestStatus
$cmin :: RequestStatus -> RequestStatus -> RequestStatus
min :: RequestStatus -> RequestStatus -> RequestStatus
Ord, Typeable)

-- | Any other property.
data OtherProperty = OtherProperty
    { OtherProperty -> CI Text
otherName   :: CI Text
    , OtherProperty -> ByteString
otherValue  :: ByteString
    , OtherProperty -> OtherParams
otherParams :: OtherParams
    } deriving (Int -> OtherProperty -> ShowS
[OtherProperty] -> ShowS
OtherProperty -> String
(Int -> OtherProperty -> ShowS)
-> (OtherProperty -> String)
-> ([OtherProperty] -> ShowS)
-> Show OtherProperty
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OtherProperty -> ShowS
showsPrec :: Int -> OtherProperty -> ShowS
$cshow :: OtherProperty -> String
show :: OtherProperty -> String
$cshowList :: [OtherProperty] -> ShowS
showList :: [OtherProperty] -> ShowS
Show, OtherProperty -> OtherProperty -> Bool
(OtherProperty -> OtherProperty -> Bool)
-> (OtherProperty -> OtherProperty -> Bool) -> Eq OtherProperty
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OtherProperty -> OtherProperty -> Bool
== :: OtherProperty -> OtherProperty -> Bool
$c/= :: OtherProperty -> OtherProperty -> Bool
/= :: OtherProperty -> OtherProperty -> Bool
Eq, Eq OtherProperty
Eq OtherProperty =>
(OtherProperty -> OtherProperty -> Ordering)
-> (OtherProperty -> OtherProperty -> Bool)
-> (OtherProperty -> OtherProperty -> Bool)
-> (OtherProperty -> OtherProperty -> Bool)
-> (OtherProperty -> OtherProperty -> Bool)
-> (OtherProperty -> OtherProperty -> OtherProperty)
-> (OtherProperty -> OtherProperty -> OtherProperty)
-> Ord OtherProperty
OtherProperty -> OtherProperty -> Bool
OtherProperty -> OtherProperty -> Ordering
OtherProperty -> OtherProperty -> OtherProperty
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
$ccompare :: OtherProperty -> OtherProperty -> Ordering
compare :: OtherProperty -> OtherProperty -> Ordering
$c< :: OtherProperty -> OtherProperty -> Bool
< :: OtherProperty -> OtherProperty -> Bool
$c<= :: OtherProperty -> OtherProperty -> Bool
<= :: OtherProperty -> OtherProperty -> Bool
$c> :: OtherProperty -> OtherProperty -> Bool
> :: OtherProperty -> OtherProperty -> Bool
$c>= :: OtherProperty -> OtherProperty -> Bool
>= :: OtherProperty -> OtherProperty -> Bool
$cmax :: OtherProperty -> OtherProperty -> OtherProperty
max :: OtherProperty -> OtherProperty -> OtherProperty
$cmin :: OtherProperty -> OtherProperty -> OtherProperty
min :: OtherProperty -> OtherProperty -> OtherProperty
Ord, Typeable)