module Network.XmlRpc.DTD_XMLRPC where

import           Text.XML.HaXml.OneOfN
import           Text.XML.HaXml.Types      (QName (..))
import           Text.XML.HaXml.XmlContent


{-Type decls-}

newtype I4 = I4 String          deriving (I4 -> I4 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: I4 -> I4 -> Bool
$c/= :: I4 -> I4 -> Bool
== :: I4 -> I4 -> Bool
$c== :: I4 -> I4 -> Bool
Eq,Int -> I4 -> ShowS
[I4] -> ShowS
I4 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [I4] -> ShowS
$cshowList :: [I4] -> ShowS
show :: I4 -> String
$cshow :: I4 -> String
showsPrec :: Int -> I4 -> ShowS
$cshowsPrec :: Int -> I4 -> ShowS
Show)
newtype I8 = I8 String          deriving (I8 -> I8 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: I8 -> I8 -> Bool
$c/= :: I8 -> I8 -> Bool
== :: I8 -> I8 -> Bool
$c== :: I8 -> I8 -> Bool
Eq,Int -> I8 -> ShowS
[I8] -> ShowS
I8 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [I8] -> ShowS
$cshowList :: [I8] -> ShowS
show :: I8 -> String
$cshow :: I8 -> String
showsPrec :: Int -> I8 -> ShowS
$cshowsPrec :: Int -> I8 -> ShowS
Show)
newtype AInt = AInt String              deriving (AInt -> AInt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AInt -> AInt -> Bool
$c/= :: AInt -> AInt -> Bool
== :: AInt -> AInt -> Bool
$c== :: AInt -> AInt -> Bool
Eq,Int -> AInt -> ShowS
[AInt] -> ShowS
AInt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AInt] -> ShowS
$cshowList :: [AInt] -> ShowS
show :: AInt -> String
$cshow :: AInt -> String
showsPrec :: Int -> AInt -> ShowS
$cshowsPrec :: Int -> AInt -> ShowS
Show)
newtype Boolean = Boolean String                deriving (Boolean -> Boolean -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Boolean -> Boolean -> Bool
$c/= :: Boolean -> Boolean -> Bool
== :: Boolean -> Boolean -> Bool
$c== :: Boolean -> Boolean -> Bool
Eq,Int -> Boolean -> ShowS
[Boolean] -> ShowS
Boolean -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Boolean] -> ShowS
$cshowList :: [Boolean] -> ShowS
show :: Boolean -> String
$cshow :: Boolean -> String
showsPrec :: Int -> Boolean -> ShowS
$cshowsPrec :: Int -> Boolean -> ShowS
Show)
newtype AString = AString String                deriving (AString -> AString -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AString -> AString -> Bool
$c/= :: AString -> AString -> Bool
== :: AString -> AString -> Bool
$c== :: AString -> AString -> Bool
Eq,Int -> AString -> ShowS
[AString] -> ShowS
AString -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AString] -> ShowS
$cshowList :: [AString] -> ShowS
show :: AString -> String
$cshow :: AString -> String
showsPrec :: Int -> AString -> ShowS
$cshowsPrec :: Int -> AString -> ShowS
Show)
newtype ADouble = ADouble String                deriving (ADouble -> ADouble -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ADouble -> ADouble -> Bool
$c/= :: ADouble -> ADouble -> Bool
== :: ADouble -> ADouble -> Bool
$c== :: ADouble -> ADouble -> Bool
Eq,Int -> ADouble -> ShowS
[ADouble] -> ShowS
ADouble -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ADouble] -> ShowS
$cshowList :: [ADouble] -> ShowS
show :: ADouble -> String
$cshow :: ADouble -> String
showsPrec :: Int -> ADouble -> ShowS
$cshowsPrec :: Int -> ADouble -> ShowS
Show)
newtype DateTime_iso8601 = DateTime_iso8601 String              deriving (DateTime_iso8601 -> DateTime_iso8601 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DateTime_iso8601 -> DateTime_iso8601 -> Bool
$c/= :: DateTime_iso8601 -> DateTime_iso8601 -> Bool
== :: DateTime_iso8601 -> DateTime_iso8601 -> Bool
$c== :: DateTime_iso8601 -> DateTime_iso8601 -> Bool
Eq,Int -> DateTime_iso8601 -> ShowS
[DateTime_iso8601] -> ShowS
DateTime_iso8601 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DateTime_iso8601] -> ShowS
$cshowList :: [DateTime_iso8601] -> ShowS
show :: DateTime_iso8601 -> String
$cshow :: DateTime_iso8601 -> String
showsPrec :: Int -> DateTime_iso8601 -> ShowS
$cshowsPrec :: Int -> DateTime_iso8601 -> ShowS
Show)
newtype Base64 = Base64 String          deriving (Base64 -> Base64 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Base64 -> Base64 -> Bool
$c/= :: Base64 -> Base64 -> Bool
== :: Base64 -> Base64 -> Bool
$c== :: Base64 -> Base64 -> Bool
Eq,Int -> Base64 -> ShowS
[Base64] -> ShowS
Base64 -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Base64] -> ShowS
$cshowList :: [Base64] -> ShowS
show :: Base64 -> String
$cshow :: Base64 -> String
showsPrec :: Int -> Base64 -> ShowS
$cshowsPrec :: Int -> Base64 -> ShowS
Show)
newtype Data = Data [Value]             deriving (Data -> Data -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Data -> Data -> Bool
$c/= :: Data -> Data -> Bool
== :: Data -> Data -> Bool
$c== :: Data -> Data -> Bool
Eq,Int -> Data -> ShowS
[Data] -> ShowS
Data -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Data] -> ShowS
$cshowList :: [Data] -> ShowS
show :: Data -> String
$cshow :: Data -> String
showsPrec :: Int -> Data -> ShowS
$cshowsPrec :: Int -> Data -> ShowS
Show)
newtype Array = Array Data              deriving (Array -> Array -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Array -> Array -> Bool
$c/= :: Array -> Array -> Bool
== :: Array -> Array -> Bool
$c== :: Array -> Array -> Bool
Eq,Int -> Array -> ShowS
[Array] -> ShowS
Array -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Array] -> ShowS
$cshowList :: [Array] -> ShowS
show :: Array -> String
$cshow :: Array -> String
showsPrec :: Int -> Array -> ShowS
$cshowsPrec :: Int -> Array -> ShowS
Show)
newtype Name = Name String              deriving (Name -> Name -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c== :: Name -> Name -> Bool
Eq,Int -> Name -> ShowS
[Name] -> ShowS
Name -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Name] -> ShowS
$cshowList :: [Name] -> ShowS
show :: Name -> String
$cshow :: Name -> String
showsPrec :: Int -> Name -> ShowS
$cshowsPrec :: Int -> Name -> ShowS
Show)
data Member = Member Name Value
            deriving (Member -> Member -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Member -> Member -> Bool
$c/= :: Member -> Member -> Bool
== :: Member -> Member -> Bool
$c== :: Member -> Member -> Bool
Eq,Int -> Member -> ShowS
[Member] -> ShowS
Member -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Member] -> ShowS
$cshowList :: [Member] -> ShowS
show :: Member -> String
$cshow :: Member -> String
showsPrec :: Int -> Member -> ShowS
$cshowsPrec :: Int -> Member -> ShowS
Show)
newtype Struct = Struct [Member]                deriving (Struct -> Struct -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Struct -> Struct -> Bool
$c/= :: Struct -> Struct -> Bool
== :: Struct -> Struct -> Bool
$c== :: Struct -> Struct -> Bool
Eq,Int -> Struct -> ShowS
[Struct] -> ShowS
Struct -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Struct] -> ShowS
$cshowList :: [Struct] -> ShowS
show :: Struct -> String
$cshow :: Struct -> String
showsPrec :: Int -> Struct -> ShowS
$cshowsPrec :: Int -> Struct -> ShowS
Show)
newtype Nil = Nil ()                    deriving (Nil -> Nil -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Nil -> Nil -> Bool
$c/= :: Nil -> Nil -> Bool
== :: Nil -> Nil -> Bool
$c== :: Nil -> Nil -> Bool
Eq,Int -> Nil -> ShowS
[Nil] -> ShowS
Nil -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Nil] -> ShowS
$cshowList :: [Nil] -> ShowS
show :: Nil -> String
$cshow :: Nil -> String
showsPrec :: Int -> Nil -> ShowS
$cshowsPrec :: Int -> Nil -> ShowS
Show)
newtype Value = Value [Value_]          deriving (Value -> Value -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Value -> Value -> Bool
$c/= :: Value -> Value -> Bool
== :: Value -> Value -> Bool
$c== :: Value -> Value -> Bool
Eq,Int -> Value -> ShowS
[Value] -> ShowS
Value -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Value] -> ShowS
$cshowList :: [Value] -> ShowS
show :: Value -> String
$cshow :: Value -> String
showsPrec :: Int -> Value -> ShowS
$cshowsPrec :: Int -> Value -> ShowS
Show)
data Value_ = Value_Str String
            | Value_I4 I4
            | Value_I8 I8
            | Value_AInt AInt
            | Value_Boolean Boolean
            | Value_AString AString
            | Value_DateTime_iso8601 DateTime_iso8601
            | Value_ADouble ADouble
            | Value_Base64 Base64
            | Value_Struct Struct
            | Value_Array Array
            | Value_Nil Nil
            deriving (Value_ -> Value_ -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Value_ -> Value_ -> Bool
$c/= :: Value_ -> Value_ -> Bool
== :: Value_ -> Value_ -> Bool
$c== :: Value_ -> Value_ -> Bool
Eq,Int -> Value_ -> ShowS
[Value_] -> ShowS
Value_ -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Value_] -> ShowS
$cshowList :: [Value_] -> ShowS
show :: Value_ -> String
$cshow :: Value_ -> String
showsPrec :: Int -> Value_ -> ShowS
$cshowsPrec :: Int -> Value_ -> ShowS
Show)
newtype Param = Param Value             deriving (Param -> Param -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Param -> Param -> Bool
$c/= :: Param -> Param -> Bool
== :: Param -> Param -> Bool
$c== :: Param -> Param -> Bool
Eq,Int -> Param -> ShowS
[Param] -> ShowS
Param -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Param] -> ShowS
$cshowList :: [Param] -> ShowS
show :: Param -> String
$cshow :: Param -> String
showsPrec :: Int -> Param -> ShowS
$cshowsPrec :: Int -> Param -> ShowS
Show)
newtype Params = Params [Param]                 deriving (Params -> Params -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Params -> Params -> Bool
$c/= :: Params -> Params -> Bool
== :: Params -> Params -> Bool
$c== :: Params -> Params -> Bool
Eq,Int -> Params -> ShowS
[Params] -> ShowS
Params -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Params] -> ShowS
$cshowList :: [Params] -> ShowS
show :: Params -> String
$cshow :: Params -> String
showsPrec :: Int -> Params -> ShowS
$cshowsPrec :: Int -> Params -> ShowS
Show)
newtype MethodName = MethodName String          deriving (MethodName -> MethodName -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MethodName -> MethodName -> Bool
$c/= :: MethodName -> MethodName -> Bool
== :: MethodName -> MethodName -> Bool
$c== :: MethodName -> MethodName -> Bool
Eq,Int -> MethodName -> ShowS
[MethodName] -> ShowS
MethodName -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MethodName] -> ShowS
$cshowList :: [MethodName] -> ShowS
show :: MethodName -> String
$cshow :: MethodName -> String
showsPrec :: Int -> MethodName -> ShowS
$cshowsPrec :: Int -> MethodName -> ShowS
Show)
data MethodCall = MethodCall MethodName (Maybe Params)
                deriving (MethodCall -> MethodCall -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MethodCall -> MethodCall -> Bool
$c/= :: MethodCall -> MethodCall -> Bool
== :: MethodCall -> MethodCall -> Bool
$c== :: MethodCall -> MethodCall -> Bool
Eq,Int -> MethodCall -> ShowS
[MethodCall] -> ShowS
MethodCall -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MethodCall] -> ShowS
$cshowList :: [MethodCall] -> ShowS
show :: MethodCall -> String
$cshow :: MethodCall -> String
showsPrec :: Int -> MethodCall -> ShowS
$cshowsPrec :: Int -> MethodCall -> ShowS
Show)
newtype Fault = Fault Value             deriving (Fault -> Fault -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Fault -> Fault -> Bool
$c/= :: Fault -> Fault -> Bool
== :: Fault -> Fault -> Bool
$c== :: Fault -> Fault -> Bool
Eq,Int -> Fault -> ShowS
[Fault] -> ShowS
Fault -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Fault] -> ShowS
$cshowList :: [Fault] -> ShowS
show :: Fault -> String
$cshow :: Fault -> String
showsPrec :: Int -> Fault -> ShowS
$cshowsPrec :: Int -> Fault -> ShowS
Show)
data MethodResponse = MethodResponseParams Params
                    | MethodResponseFault Fault
                    deriving (MethodResponse -> MethodResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MethodResponse -> MethodResponse -> Bool
$c/= :: MethodResponse -> MethodResponse -> Bool
== :: MethodResponse -> MethodResponse -> Bool
$c== :: MethodResponse -> MethodResponse -> Bool
Eq,Int -> MethodResponse -> ShowS
[MethodResponse] -> ShowS
MethodResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MethodResponse] -> ShowS
$cshowList :: [MethodResponse] -> ShowS
show :: MethodResponse -> String
$cshow :: MethodResponse -> String
showsPrec :: Int -> MethodResponse -> ShowS
$cshowsPrec :: Int -> MethodResponse -> ShowS
Show)


{-Instance decls-}

instance HTypeable I4 where
    toHType :: I4 -> HType
toHType I4
x = String -> [HType] -> [Constr] -> HType
Defined String
"i4" [] []
instance XmlContent I4 where
    toContents :: I4 -> [Content ()]
toContents (I4 String
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"i4") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser I4
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"i4"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return (String -> I4
I4) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <i4>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable I8 where
    toHType :: I8 -> HType
toHType I8
x = String -> [HType] -> [Constr] -> HType
Defined String
"i8" [] []
instance XmlContent I8 where
    toContents :: I8 -> [Content ()]
toContents (I8 String
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"i8") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser I8
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"i8"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return (String -> I8
I8) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <i8>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable AInt where
    toHType :: AInt -> HType
toHType AInt
x = String -> [HType] -> [Constr] -> HType
Defined String
"int" [] []
instance XmlContent AInt where
    toContents :: AInt -> [Content ()]
toContents (AInt String
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"int") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser AInt
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"int"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return (String -> AInt
AInt) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <int>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable Boolean where
    toHType :: Boolean -> HType
toHType Boolean
x = String -> [HType] -> [Constr] -> HType
Defined String
"boolean" [] []
instance XmlContent Boolean where
    toContents :: Boolean -> [Content ()]
toContents (Boolean String
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"boolean") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser Boolean
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"boolean"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Boolean
Boolean) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <boolean>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable AString where
    toHType :: AString -> HType
toHType AString
x = String -> [HType] -> [Constr] -> HType
Defined String
"string" [] []
instance XmlContent AString where
    toContents :: AString -> [Content ()]
toContents (AString String
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"string") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser AString
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"string"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return (String -> AString
AString) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <string>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable ADouble where
    toHType :: ADouble -> HType
toHType ADouble
x = String -> [HType] -> [Constr] -> HType
Defined String
"double" [] []
instance XmlContent ADouble where
    toContents :: ADouble -> [Content ()]
toContents (ADouble String
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"double") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser ADouble
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"double"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ADouble
ADouble) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <double>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable DateTime_iso8601 where
    toHType :: DateTime_iso8601 -> HType
toHType DateTime_iso8601
x = String -> [HType] -> [Constr] -> HType
Defined String
"dateTime.iso8601" [] []
instance XmlContent DateTime_iso8601 where
    toContents :: DateTime_iso8601 -> [Content ()]
toContents (DateTime_iso8601 String
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"dateTime.iso8601") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser DateTime_iso8601
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"dateTime.iso8601"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return (String -> DateTime_iso8601
DateTime_iso8601)
                       forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <dateTime.iso8601>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable Nil where
    toHType :: Nil -> HType
toHType Nil
x = String -> [HType] -> [Constr] -> HType
Defined String
"nil" [] []
instance XmlContent Nil where
    toContents :: Nil -> [Content ()]
toContents (Nil ()
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"nil") [] []) ()]
    parseContents :: XMLParser Nil
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"nil"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return (() -> Nil
Nil) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (forall (m :: * -> *) a. Monad m => a -> m a
return ())
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <nil/>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable Base64 where
    toHType :: Base64 -> HType
toHType Base64
x = String -> [HType] -> [Constr] -> HType
Defined String
"base64" [] []
instance XmlContent Base64 where
    toContents :: Base64 -> [Content ()]
toContents (Base64 String
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"base64") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser Base64
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"base64"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Base64
Base64) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <base64>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable Data where
    toHType :: Data -> HType
toHType Data
x = String -> [HType] -> [Constr] -> HType
Defined String
"data" [] []
instance XmlContent Data where
    toContents :: Data -> [Content ()]
toContents (Data [Value]
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"data") [] (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall a. XmlContent a => a -> [Content ()]
toContents [Value]
a)) ()]
    parseContents :: XMLParser Data
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"data"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return ([Value] -> Data
Data) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall (f :: * -> *) a. Alternative f => f a -> f [a]
many forall a. XmlContent a => XMLParser a
parseContents
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <data>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable Array where
    toHType :: Array -> HType
toHType Array
x = String -> [HType] -> [Constr] -> HType
Defined String
"array" [] []
instance XmlContent Array where
    toContents :: Array -> [Content ()]
toContents (Array Data
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"array") [] (forall a. XmlContent a => a -> [Content ()]
toContents Data
a)) ()]
    parseContents :: XMLParser Array
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"array"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return (Data -> Array
Array) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <array>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable Name where
    toHType :: Name -> HType
toHType Name
x = String -> [HType] -> [Constr] -> HType
Defined String
"name" [] []
instance XmlContent Name where
    toContents :: Name -> [Content ()]
toContents (Name String
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"name") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser Name
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"name"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Name
Name) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <name>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable Member where
    toHType :: Member -> HType
toHType Member
x = String -> [HType] -> [Constr] -> HType
Defined String
"member" [] []
instance XmlContent Member where
    toContents :: Member -> [Content ()]
toContents (Member Name
a Value
b) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"member") [] (forall a. XmlContent a => a -> [Content ()]
toContents Name
a forall a. [a] -> [a] -> [a]
++ forall a. XmlContent a => a -> [Content ()]
toContents Value
b)) ()]
    parseContents :: XMLParser Member
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"member"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Value -> Member
Member) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
                       forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <member>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable Struct where
    toHType :: Struct -> HType
toHType Struct
x = String -> [HType] -> [Constr] -> HType
Defined String
"struct" [] []
instance XmlContent Struct where
    toContents :: Struct -> [Content ()]
toContents (Struct [Member]
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"struct") [] (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall a. XmlContent a => a -> [Content ()]
toContents [Member]
a)) ()]
    parseContents :: XMLParser Struct
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"struct"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return ([Member] -> Struct
Struct) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall (f :: * -> *) a. Alternative f => f a -> f [a]
many forall a. XmlContent a => XMLParser a
parseContents
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <struct>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable Value where
    toHType :: Value -> HType
toHType Value
x = String -> [HType] -> [Constr] -> HType
Defined String
"value" [] []
instance XmlContent Value where
    toContents :: Value -> [Content ()]
toContents (Value [Value_]
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"value") [] (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall a. XmlContent a => a -> [Content ()]
toContents [Value_]
a)) ()]
    parseContents :: XMLParser Value
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"value"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return ([Value_] -> Value
Value) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall (f :: * -> *) a. Alternative f => f a -> f [a]
many forall a. XmlContent a => XMLParser a
parseContents
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <value>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable Value_ where
    toHType :: Value_ -> HType
toHType Value_
x = String -> [HType] -> [Constr] -> HType
Defined String
"value" [] []
instance XmlContent Value_ where
    toContents :: Value_ -> [Content ()]
toContents (Value_Str String
a) = String -> [Content ()]
toText String
a
    toContents (Value_I4 I4
a) = forall a. XmlContent a => a -> [Content ()]
toContents I4
a
    toContents (Value_I8 I8
a) = forall a. XmlContent a => a -> [Content ()]
toContents I8
a
    toContents (Value_AInt AInt
a) = forall a. XmlContent a => a -> [Content ()]
toContents AInt
a
    toContents (Value_Boolean Boolean
a) = forall a. XmlContent a => a -> [Content ()]
toContents Boolean
a
    toContents (Value_AString AString
a) = forall a. XmlContent a => a -> [Content ()]
toContents AString
a
    toContents (Value_DateTime_iso8601 DateTime_iso8601
a) = forall a. XmlContent a => a -> [Content ()]
toContents DateTime_iso8601
a
    toContents (Value_ADouble ADouble
a) = forall a. XmlContent a => a -> [Content ()]
toContents ADouble
a
    toContents (Value_Base64 Base64
a) = forall a. XmlContent a => a -> [Content ()]
toContents Base64
a
    toContents (Value_Struct Struct
a) = forall a. XmlContent a => a -> [Content ()]
toContents Struct
a
    toContents (Value_Array Array
a) = forall a. XmlContent a => a -> [Content ()]
toContents Array
a
    toContents (Value_Nil Nil
a) = forall a. XmlContent a => a -> [Content ()]
toContents Nil
a
    parseContents :: XMLParser Value_
parseContents = forall (p :: * -> *) a. PolyParse p => [p a] -> p a
oneOf
        [ forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Value_
Value_Str) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) String
text
        , forall (m :: * -> *) a. Monad m => a -> m a
return (I4 -> Value_
Value_I4) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
        , forall (m :: * -> *) a. Monad m => a -> m a
return (I8 -> Value_
Value_I8) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
        , forall (m :: * -> *) a. Monad m => a -> m a
return (AInt -> Value_
Value_AInt) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
        , forall (m :: * -> *) a. Monad m => a -> m a
return (Boolean -> Value_
Value_Boolean) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
        , forall (m :: * -> *) a. Monad m => a -> m a
return (AString -> Value_
Value_AString) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
        , forall (m :: * -> *) a. Monad m => a -> m a
return (DateTime_iso8601 -> Value_
Value_DateTime_iso8601) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
        , forall (m :: * -> *) a. Monad m => a -> m a
return (ADouble -> Value_
Value_ADouble) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
        , forall (m :: * -> *) a. Monad m => a -> m a
return (Base64 -> Value_
Value_Base64) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
        , forall (m :: * -> *) a. Monad m => a -> m a
return (Struct -> Value_
Value_Struct) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
        , forall (m :: * -> *) a. Monad m => a -> m a
return (Array -> Value_
Value_Array) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
        , forall (m :: * -> *) a. Monad m => a -> m a
return (Nil -> Value_
Value_Nil) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
        ] forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <value>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable Param where
    toHType :: Param -> HType
toHType Param
x = String -> [HType] -> [Constr] -> HType
Defined String
"param" [] []
instance XmlContent Param where
    toContents :: Param -> [Content ()]
toContents (Param Value
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"param") [] (forall a. XmlContent a => a -> [Content ()]
toContents Value
a)) ()]
    parseContents :: XMLParser Param
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"param"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return (Value -> Param
Param) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <param>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable Params where
    toHType :: Params -> HType
toHType Params
x = String -> [HType] -> [Constr] -> HType
Defined String
"params" [] []
instance XmlContent Params where
    toContents :: Params -> [Content ()]
toContents (Params [Param]
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"params") [] (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall a. XmlContent a => a -> [Content ()]
toContents [Param]
a)) ()]
    parseContents :: XMLParser Params
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"params"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return ([Param] -> Params
Params) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall (f :: * -> *) a. Alternative f => f a -> f [a]
many forall a. XmlContent a => XMLParser a
parseContents
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <params>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable MethodName where
    toHType :: MethodName -> HType
toHType MethodName
x = String -> [HType] -> [Constr] -> HType
Defined String
"methodName" [] []
instance XmlContent MethodName where
    toContents :: MethodName -> [Content ()]
toContents (MethodName String
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"methodName") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser MethodName
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"methodName"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return (String -> MethodName
MethodName)
                       forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <methodName>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable MethodCall where
    toHType :: MethodCall -> HType
toHType MethodCall
x = String -> [HType] -> [Constr] -> HType
Defined String
"methodCall" [] []
instance XmlContent MethodCall where
    toContents :: MethodCall -> [Content ()]
toContents (MethodCall MethodName
a Maybe Params
b) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"methodCall") [] (forall a. XmlContent a => a -> [Content ()]
toContents MethodName
a forall a. [a] -> [a] -> [a]
++
                                      forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] forall a. XmlContent a => a -> [Content ()]
toContents Maybe Params
b)) ()]
    parseContents :: XMLParser MethodCall
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"methodCall"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return (MethodName -> Maybe Params -> MethodCall
MethodCall) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
                       forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall a. XmlContent a => XMLParser a
parseContents
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <methodCall>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable Fault where
    toHType :: Fault -> HType
toHType Fault
x = String -> [HType] -> [Constr] -> HType
Defined String
"fault" [] []
instance XmlContent Fault where
    toContents :: Fault -> [Content ()]
toContents (Fault Value
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"fault") [] (forall a. XmlContent a => a -> [Content ()]
toContents Value
a)) ()]
    parseContents :: XMLParser Fault
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"fault"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return (Value -> Fault
Fault) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
        } forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <fault>, "forall a. [a] -> [a] -> [a]
++)

instance HTypeable MethodResponse where
    toHType :: MethodResponse -> HType
toHType MethodResponse
x = String -> [HType] -> [Constr] -> HType
Defined String
"methodResponse" [] []
instance XmlContent MethodResponse where
    toContents :: MethodResponse -> [Content ()]
toContents (MethodResponseParams Params
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"methodResponse") [] (forall a. XmlContent a => a -> [Content ()]
toContents Params
a) ) ()]
    toContents (MethodResponseFault Fault
a) =
        [forall i. Element i -> i -> Content i
CElem (forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"methodResponse") [] (forall a. XmlContent a => a -> [Content ()]
toContents Fault
a) ) ()]
    parseContents :: XMLParser MethodResponse
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"methodResponse"]
        ; forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e forall a b. (a -> b) -> a -> b
$ forall (p :: * -> *) a. PolyParse p => [p a] -> p a
oneOf
            [ forall (m :: * -> *) a. Monad m => a -> m a
return (Params -> MethodResponse
MethodResponseParams) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
            , forall (m :: * -> *) a. Monad m => a -> m a
return (Fault -> MethodResponse
MethodResponseFault) forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` forall a. XmlContent a => XMLParser a
parseContents
            ] forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <methodResponse>, "forall a. [a] -> [a] -> [a]
++)
        }



{-Done-}