    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
    (I4 -> I4 -> Bool) -> (I4 -> I4 -> Bool) -> Eq I4
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: I4 -> I4 -> Bool
    == :: I4 -> I4 -> Bool
    $c/= :: I4 -> I4 -> Bool
    /= :: I4 -> I4 -> Bool
    Eq,Int -> I4 -> ShowS
    [I4] -> ShowS
    I4 -> String
    (Int -> I4 -> ShowS)
    -> (I4 -> String) -> ([I4] -> ShowS) -> Show I4
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> I4 -> ShowS
    showsPrec :: Int -> I4 -> ShowS
    $cshow :: I4 -> String
    show :: I4 -> String
    $cshowList :: [I4] -> ShowS
    showList :: [I4] -> ShowS
    Show)
    newtype I8 = I8 String          deriving (I8 -> I8 -> Bool
    (I8 -> I8 -> Bool) -> (I8 -> I8 -> Bool) -> Eq I8
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: I8 -> I8 -> Bool
    == :: I8 -> I8 -> Bool
    $c/= :: I8 -> I8 -> Bool
    /= :: I8 -> I8 -> Bool
    Eq,Int -> I8 -> ShowS
    [I8] -> ShowS
    I8 -> String
    (Int -> I8 -> ShowS)
    -> (I8 -> String) -> ([I8] -> ShowS) -> Show I8
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> I8 -> ShowS
    showsPrec :: Int -> I8 -> ShowS
    $cshow :: I8 -> String
    show :: I8 -> String
    $cshowList :: [I8] -> ShowS
    showList :: [I8] -> ShowS
    Show)
    newtype AInt = AInt String              deriving (AInt -> AInt -> Bool
    (AInt -> AInt -> Bool) -> (AInt -> AInt -> Bool) -> Eq AInt
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AInt -> AInt -> Bool
    == :: AInt -> AInt -> Bool
    $c/= :: AInt -> AInt -> Bool
    /= :: AInt -> AInt -> Bool
    Eq,Int -> AInt -> ShowS
    [AInt] -> ShowS
    AInt -> String
    (Int -> AInt -> ShowS)
    -> (AInt -> String) -> ([AInt] -> ShowS) -> Show AInt
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AInt -> ShowS
    showsPrec :: Int -> AInt -> ShowS
    $cshow :: AInt -> String
    show :: AInt -> String
    $cshowList :: [AInt] -> ShowS
    showList :: [AInt] -> ShowS
    Show)
    newtype Boolean = Boolean String                deriving (Boolean -> Boolean -> Bool
    (Boolean -> Boolean -> Bool)
    -> (Boolean -> Boolean -> Bool) -> Eq Boolean
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Boolean -> Boolean -> Bool
    == :: Boolean -> Boolean -> Bool
    $c/= :: Boolean -> Boolean -> Bool
    /= :: Boolean -> Boolean -> Bool
    Eq,Int -> Boolean -> ShowS
    [Boolean] -> ShowS
    Boolean -> String
    (Int -> Boolean -> ShowS)
    -> (Boolean -> String) -> ([Boolean] -> ShowS) -> Show Boolean
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Boolean -> ShowS
    showsPrec :: Int -> Boolean -> ShowS
    $cshow :: Boolean -> String
    show :: Boolean -> String
    $cshowList :: [Boolean] -> ShowS
    showList :: [Boolean] -> ShowS
    Show)
    newtype AString = AString String                deriving (AString -> AString -> Bool
    (AString -> AString -> Bool)
    -> (AString -> AString -> Bool) -> Eq AString
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AString -> AString -> Bool
    == :: AString -> AString -> Bool
    $c/= :: AString -> AString -> Bool
    /= :: AString -> AString -> Bool
    Eq,Int -> AString -> ShowS
    [AString] -> ShowS
    AString -> String
    (Int -> AString -> ShowS)
    -> (AString -> String) -> ([AString] -> ShowS) -> Show AString
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AString -> ShowS
    showsPrec :: Int -> AString -> ShowS
    $cshow :: AString -> String
    show :: AString -> String
    $cshowList :: [AString] -> ShowS
    showList :: [AString] -> ShowS
    Show)
    newtype ADouble = ADouble String                deriving (ADouble -> ADouble -> Bool
    (ADouble -> ADouble -> Bool)
    -> (ADouble -> ADouble -> Bool) -> Eq ADouble
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ADouble -> ADouble -> Bool
    == :: ADouble -> ADouble -> Bool
    $c/= :: ADouble -> ADouble -> Bool
    /= :: ADouble -> ADouble -> Bool
    Eq,Int -> ADouble -> ShowS
    [ADouble] -> ShowS
    ADouble -> String
    (Int -> ADouble -> ShowS)
    -> (ADouble -> String) -> ([ADouble] -> ShowS) -> Show ADouble
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ADouble -> ShowS
    showsPrec :: Int -> ADouble -> ShowS
    $cshow :: ADouble -> String
    show :: ADouble -> String
    $cshowList :: [ADouble] -> ShowS
    showList :: [ADouble] -> ShowS
    Show)
    newtype DateTime_iso8601 = DateTime_iso8601 String              deriving (DateTime_iso8601 -> DateTime_iso8601 -> Bool
    (DateTime_iso8601 -> DateTime_iso8601 -> Bool)
    -> (DateTime_iso8601 -> DateTime_iso8601 -> Bool)
    -> Eq DateTime_iso8601
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DateTime_iso8601 -> DateTime_iso8601 -> Bool
    == :: DateTime_iso8601 -> DateTime_iso8601 -> Bool
    $c/= :: DateTime_iso8601 -> DateTime_iso8601 -> Bool
    /= :: DateTime_iso8601 -> DateTime_iso8601 -> Bool
    Eq,Int -> DateTime_iso8601 -> ShowS
    [DateTime_iso8601] -> ShowS
    DateTime_iso8601 -> String
    (Int -> DateTime_iso8601 -> ShowS)
    -> (DateTime_iso8601 -> String)
    -> ([DateTime_iso8601] -> ShowS)
    -> Show DateTime_iso8601
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DateTime_iso8601 -> ShowS
    showsPrec :: Int -> DateTime_iso8601 -> ShowS
    $cshow :: DateTime_iso8601 -> String
    show :: DateTime_iso8601 -> String
    $cshowList :: [DateTime_iso8601] -> ShowS
    showList :: [DateTime_iso8601] -> ShowS
    Show)
    newtype Base64 = Base64 String          deriving (Base64 -> Base64 -> Bool
    (Base64 -> Base64 -> Bool)
    -> (Base64 -> Base64 -> Bool) -> Eq Base64
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Base64 -> Base64 -> Bool
    == :: Base64 -> Base64 -> Bool
    $c/= :: Base64 -> Base64 -> Bool
    /= :: Base64 -> Base64 -> Bool
    Eq,Int -> Base64 -> ShowS
    [Base64] -> ShowS
    Base64 -> String
    (Int -> Base64 -> ShowS)
    -> (Base64 -> String) -> ([Base64] -> ShowS) -> Show Base64
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Base64 -> ShowS
    showsPrec :: Int -> Base64 -> ShowS
    $cshow :: Base64 -> String
    show :: Base64 -> String
    $cshowList :: [Base64] -> ShowS
    showList :: [Base64] -> ShowS
    Show)
    newtype Data = Data [Value]             deriving (Data -> Data -> Bool
    (Data -> Data -> Bool) -> (Data -> Data -> Bool) -> Eq Data
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Data -> Data -> Bool
    == :: Data -> Data -> Bool
    $c/= :: Data -> Data -> Bool
    /= :: Data -> Data -> Bool
    Eq,Int -> Data -> ShowS
    [Data] -> ShowS
    Data -> String
    (Int -> Data -> ShowS)
    -> (Data -> String) -> ([Data] -> ShowS) -> Show Data
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Data -> ShowS
    showsPrec :: Int -> Data -> ShowS
    $cshow :: Data -> String
    show :: Data -> String
    $cshowList :: [Data] -> ShowS
    showList :: [Data] -> ShowS
    Show)
    newtype Array = Array Data              deriving (Array -> Array -> Bool
    (Array -> Array -> Bool) -> (Array -> Array -> Bool) -> Eq Array
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Array -> Array -> Bool
    == :: Array -> Array -> Bool
    $c/= :: Array -> Array -> Bool
    /= :: Array -> Array -> Bool
    Eq,Int -> Array -> ShowS
    [Array] -> ShowS
    Array -> String
    (Int -> Array -> ShowS)
    -> (Array -> String) -> ([Array] -> ShowS) -> Show Array
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Array -> ShowS
    showsPrec :: Int -> Array -> ShowS
    $cshow :: Array -> String
    show :: Array -> String
    $cshowList :: [Array] -> ShowS
    showList :: [Array] -> ShowS
    Show)
    newtype Name = Name String              deriving (Name -> Name -> Bool
    (Name -> Name -> Bool) -> (Name -> Name -> Bool) -> Eq Name
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Name -> Name -> Bool
    == :: Name -> Name -> Bool
    $c/= :: Name -> Name -> Bool
    /= :: Name -> Name -> Bool
    Eq,Int -> Name -> ShowS
    [Name] -> ShowS
    Name -> String
    (Int -> Name -> ShowS)
    -> (Name -> String) -> ([Name] -> ShowS) -> Show Name
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Name -> ShowS
    showsPrec :: Int -> Name -> ShowS
    $cshow :: Name -> String
    show :: Name -> String
    $cshowList :: [Name] -> ShowS
    showList :: [Name] -> ShowS
    Show)
    data Member = Member Name Value
                deriving (Member -> Member -> Bool
    (Member -> Member -> Bool)
    -> (Member -> Member -> Bool) -> Eq Member
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Member -> Member -> Bool
    == :: Member -> Member -> Bool
    $c/= :: Member -> Member -> Bool
    /= :: Member -> Member -> Bool
    Eq,Int -> Member -> ShowS
    [Member] -> ShowS
    Member -> String
    (Int -> Member -> ShowS)
    -> (Member -> String) -> ([Member] -> ShowS) -> Show Member
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Member -> ShowS
    showsPrec :: Int -> Member -> ShowS
    $cshow :: Member -> String
    show :: Member -> String
    $cshowList :: [Member] -> ShowS
    showList :: [Member] -> ShowS
    Show)
    newtype Struct = Struct [Member]                deriving (Struct -> Struct -> Bool
    (Struct -> Struct -> Bool)
    -> (Struct -> Struct -> Bool) -> Eq Struct
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Struct -> Struct -> Bool
    == :: Struct -> Struct -> Bool
    $c/= :: Struct -> Struct -> Bool
    /= :: Struct -> Struct -> Bool
    Eq,Int -> Struct -> ShowS
    [Struct] -> ShowS
    Struct -> String
    (Int -> Struct -> ShowS)
    -> (Struct -> String) -> ([Struct] -> ShowS) -> Show Struct
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Struct -> ShowS
    showsPrec :: Int -> Struct -> ShowS
    $cshow :: Struct -> String
    show :: Struct -> String
    $cshowList :: [Struct] -> ShowS
    showList :: [Struct] -> ShowS
    Show)
    newtype Nil = Nil ()                    deriving (Nil -> Nil -> Bool
    (Nil -> Nil -> Bool) -> (Nil -> Nil -> Bool) -> Eq Nil
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Nil -> Nil -> Bool
    == :: Nil -> Nil -> Bool
    $c/= :: Nil -> Nil -> Bool
    /= :: Nil -> Nil -> Bool
    Eq,Int -> Nil -> ShowS
    [Nil] -> ShowS
    Nil -> String
    (Int -> Nil -> ShowS)
    -> (Nil -> String) -> ([Nil] -> ShowS) -> Show Nil
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Nil -> ShowS
    showsPrec :: Int -> Nil -> ShowS
    $cshow :: Nil -> String
    show :: Nil -> String
    $cshowList :: [Nil] -> ShowS
    showList :: [Nil] -> ShowS
    Show)
    newtype Value = Value [Value_]          deriving (Value -> Value -> Bool
    (Value -> Value -> Bool) -> (Value -> Value -> Bool) -> Eq Value
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Value -> Value -> Bool
    == :: Value -> Value -> Bool
    $c/= :: Value -> Value -> Bool
    /= :: Value -> Value -> Bool
    Eq,Int -> Value -> ShowS
    [Value] -> ShowS
    Value -> String
    (Int -> Value -> ShowS)
    -> (Value -> String) -> ([Value] -> ShowS) -> Show Value
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Value -> ShowS
    showsPrec :: Int -> Value -> ShowS
    $cshow :: Value -> String
    show :: Value -> String
    $cshowList :: [Value] -> ShowS
    showList :: [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
    (Value_ -> Value_ -> Bool)
    -> (Value_ -> Value_ -> Bool) -> Eq Value_
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Value_ -> Value_ -> Bool
    == :: Value_ -> Value_ -> Bool
    $c/= :: Value_ -> Value_ -> Bool
    /= :: Value_ -> Value_ -> Bool
    Eq,Int -> Value_ -> ShowS
    [Value_] -> ShowS
    Value_ -> String
    (Int -> Value_ -> ShowS)
    -> (Value_ -> String) -> ([Value_] -> ShowS) -> Show Value_
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Value_ -> ShowS
    showsPrec :: Int -> Value_ -> ShowS
    $cshow :: Value_ -> String
    show :: Value_ -> String
    $cshowList :: [Value_] -> ShowS
    showList :: [Value_] -> ShowS
    Show)
    newtype Param = Param Value             deriving (Param -> Param -> Bool
    (Param -> Param -> Bool) -> (Param -> Param -> Bool) -> Eq Param
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Param -> Param -> Bool
    == :: Param -> Param -> Bool
    $c/= :: Param -> Param -> Bool
    /= :: Param -> Param -> Bool
    Eq,Int -> Param -> ShowS
    [Param] -> ShowS
    Param -> String
    (Int -> Param -> ShowS)
    -> (Param -> String) -> ([Param] -> ShowS) -> Show Param
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Param -> ShowS
    showsPrec :: Int -> Param -> ShowS
    $cshow :: Param -> String
    show :: Param -> String
    $cshowList :: [Param] -> ShowS
    showList :: [Param] -> ShowS
    Show)
    newtype Params = Params [Param]                 deriving (Params -> Params -> Bool
    (Params -> Params -> Bool)
    -> (Params -> Params -> Bool) -> Eq Params
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Params -> Params -> Bool
    == :: Params -> Params -> Bool
    $c/= :: Params -> Params -> Bool
    /= :: Params -> Params -> Bool
    Eq,Int -> Params -> ShowS
    [Params] -> ShowS
    Params -> String
    (Int -> Params -> ShowS)
    -> (Params -> String) -> ([Params] -> ShowS) -> Show Params
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Params -> ShowS
    showsPrec :: Int -> Params -> ShowS
    $cshow :: Params -> String
    show :: Params -> String
    $cshowList :: [Params] -> ShowS
    showList :: [Params] -> ShowS
    Show)
    newtype MethodName = MethodName String          deriving (MethodName -> MethodName -> Bool
    (MethodName -> MethodName -> Bool)
    -> (MethodName -> MethodName -> Bool) -> Eq MethodName
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MethodName -> MethodName -> Bool
    == :: MethodName -> MethodName -> Bool
    $c/= :: MethodName -> MethodName -> Bool
    /= :: MethodName -> MethodName -> Bool
    Eq,Int -> MethodName -> ShowS
    [MethodName] -> ShowS
    MethodName -> String
    (Int -> MethodName -> ShowS)
    -> (MethodName -> String)
    -> ([MethodName] -> ShowS)
    -> Show MethodName
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MethodName -> ShowS
    showsPrec :: Int -> MethodName -> ShowS
    $cshow :: MethodName -> String
    show :: MethodName -> String
    $cshowList :: [MethodName] -> ShowS
    showList :: [MethodName] -> ShowS
    Show)
    data MethodCall = MethodCall MethodName (Maybe Params)
                    deriving (MethodCall -> MethodCall -> Bool
    (MethodCall -> MethodCall -> Bool)
    -> (MethodCall -> MethodCall -> Bool) -> Eq MethodCall
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MethodCall -> MethodCall -> Bool
    == :: MethodCall -> MethodCall -> Bool
    $c/= :: MethodCall -> MethodCall -> Bool
    /= :: MethodCall -> MethodCall -> Bool
    Eq,Int -> MethodCall -> ShowS
    [MethodCall] -> ShowS
    MethodCall -> String
    (Int -> MethodCall -> ShowS)
    -> (MethodCall -> String)
    -> ([MethodCall] -> ShowS)
    -> Show MethodCall
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MethodCall -> ShowS
    showsPrec :: Int -> MethodCall -> ShowS
    $cshow :: MethodCall -> String
    show :: MethodCall -> String
    $cshowList :: [MethodCall] -> ShowS
    showList :: [MethodCall] -> ShowS
    Show)
    newtype Fault = Fault Value             deriving (Fault -> Fault -> Bool
    (Fault -> Fault -> Bool) -> (Fault -> Fault -> Bool) -> Eq Fault
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Fault -> Fault -> Bool
    == :: Fault -> Fault -> Bool
    $c/= :: Fault -> Fault -> Bool
    /= :: Fault -> Fault -> Bool
    Eq,Int -> Fault -> ShowS
    [Fault] -> ShowS
    Fault -> String
    (Int -> Fault -> ShowS)
    -> (Fault -> String) -> ([Fault] -> ShowS) -> Show Fault
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Fault -> ShowS
    showsPrec :: Int -> Fault -> ShowS
    $cshow :: Fault -> String
    show :: Fault -> String
    $cshowList :: [Fault] -> ShowS
    showList :: [Fault] -> ShowS
    Show)
    data MethodResponse = MethodResponseParams Params
                        | MethodResponseFault Fault
                        deriving (MethodResponse -> MethodResponse -> Bool
    (MethodResponse -> MethodResponse -> Bool)
    -> (MethodResponse -> MethodResponse -> Bool) -> Eq MethodResponse
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MethodResponse -> MethodResponse -> Bool
    == :: MethodResponse -> MethodResponse -> Bool
    $c/= :: MethodResponse -> MethodResponse -> Bool
    /= :: MethodResponse -> MethodResponse -> Bool
    Eq,Int -> MethodResponse -> ShowS
    [MethodResponse] -> ShowS
    MethodResponse -> String
    (Int -> MethodResponse -> ShowS)
    -> (MethodResponse -> String)
    -> ([MethodResponse] -> ShowS)
    -> Show MethodResponse
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MethodResponse -> ShowS
    showsPrec :: Int -> MethodResponse -> ShowS
    $cshow :: MethodResponse -> String
    show :: MethodResponse -> String
    $cshowList :: [MethodResponse] -> ShowS
    showList :: [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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    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@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "i4"]
            ; interior e $ return (I4) `apply` (text `onFail` return "")
            } XMLParser I4 -> ShowS -> XMLParser I4
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <i4>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    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@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "i8"]
            ; interior e $ return (I8) `apply` (text `onFail` return "")
            } XMLParser I8 -> ShowS -> XMLParser I8
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <i8>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    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@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "int"]
            ; interior e $ return (AInt) `apply` (text `onFail` return "")
            } XMLParser AInt -> ShowS -> XMLParser AInt
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <int>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    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@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "boolean"]
            ; interior e $ return (Boolean) `apply` (text `onFail` return "")
            } XMLParser Boolean -> ShowS -> XMLParser Boolean
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <boolean>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    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@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "string"]
            ; interior e $ return (AString) `apply` (text `onFail` return "")
            } XMLParser AString -> ShowS -> XMLParser AString
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <string>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    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@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "double"]
            ; interior e $ return (ADouble) `apply` (text `onFail` return "")
            } XMLParser ADouble -> ShowS -> XMLParser ADouble
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <double>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    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@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "dateTime.iso8601"]
            ; interior e $ return (DateTime_iso8601)
                           `apply` (text `onFail` return "")
            } XMLParser DateTime_iso8601 -> ShowS -> XMLParser DateTime_iso8601
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <dateTime.iso8601>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    forall i. QName -> [Attribute] -> [Content i] -> Element i
    Elem (String -> QName
    N String
    "nil") [] []) ()]
        parseContents :: XMLParser Nil
    parseContents = do
            { e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "nil"]
            ; interior e $ return (Nil) `apply` (return ())
            } XMLParser Nil -> ShowS -> XMLParser Nil
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <nil/>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    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@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "base64"]
            ; interior e $ return (Base64) `apply` (text `onFail` return "")
            } XMLParser Base64 -> ShowS -> XMLParser Base64
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <base64>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    forall i. QName -> [Attribute] -> [Content i] -> Element i
    Elem (String -> QName
    N String
    "data") [] ((Value -> [Content ()]) -> [Value] -> [Content ()]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap Value -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents [Value]
    a)) ()]
        parseContents :: XMLParser Data
    parseContents = do
            { e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "data"]
            ; interior e $ return (Data) `apply` many parseContents
            } XMLParser Data -> ShowS -> XMLParser Data
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <data>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    forall i. QName -> [Attribute] -> [Content i] -> Element i
    Elem (String -> QName
    N String
    "array") [] (Data -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents Data
    a)) ()]
        parseContents :: XMLParser Array
    parseContents = do
            { e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "array"]
            ; interior e $ return (Array) `apply` parseContents
            } XMLParser Array -> ShowS -> XMLParser Array
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <array>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    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@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "name"]
            ; interior e $ return (Name) `apply` (text `onFail` return "")
            } XMLParser Name -> ShowS -> XMLParser Name
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <name>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    forall i. QName -> [Attribute] -> [Content i] -> Element i
    Elem (String -> QName
    N String
    "member") [] (Name -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents Name
    a [Content ()] -> [Content ()] -> [Content ()]
    forall a. [a] -> [a] -> [a]
    ++ Value -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents Value
    b)) ()]
        parseContents :: XMLParser Member
    parseContents = do
            { e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "member"]
            ; interior e $ return (Member) `apply` parseContents
                           `apply` parseContents
            } XMLParser Member -> ShowS -> XMLParser Member
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <member>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    forall i. QName -> [Attribute] -> [Content i] -> Element i
    Elem (String -> QName
    N String
    "struct") [] ((Member -> [Content ()]) -> [Member] -> [Content ()]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap Member -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents [Member]
    a)) ()]
        parseContents :: XMLParser Struct
    parseContents = do
            { e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "struct"]
            ; interior e $ return (Struct) `apply` many parseContents
            } XMLParser Struct -> ShowS -> XMLParser Struct
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <struct>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    forall i. QName -> [Attribute] -> [Content i] -> Element i
    Elem (String -> QName
    N String
    "value") [] ((Value_ -> [Content ()]) -> [Value_] -> [Content ()]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap Value_ -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents [Value_]
    a)) ()]
        parseContents :: Parser (Content Posn) Value
    parseContents = do
            { e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "value"]
            ; interior e $ return (Value) `apply` many parseContents
            } Parser (Content Posn) Value -> ShowS -> Parser (Content Posn) Value
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <value>, "String -> ShowS
    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) = I4 -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents I4
    a
        toContents (Value_I8 I8
    a) = I8 -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents I8
    a
        toContents (Value_AInt AInt
    a) = AInt -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents AInt
    a
        toContents (Value_Boolean Boolean
    a) = Boolean -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents Boolean
    a
        toContents (Value_AString AString
    a) = AString -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents AString
    a
        toContents (Value_DateTime_iso8601 DateTime_iso8601
    a) = DateTime_iso8601 -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents DateTime_iso8601
    a
        toContents (Value_ADouble ADouble
    a) = ADouble -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents ADouble
    a
        toContents (Value_Base64 Base64
    a) = Base64 -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents Base64
    a
        toContents (Value_Struct Struct
    a) = Struct -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents Struct
    a
        toContents (Value_Array Array
    a) = Array -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents Array
    a
        toContents (Value_Nil Nil
    a) = Nil -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents Nil
    a
        parseContents :: Parser (Content Posn) Value_
    parseContents = [Parser (Content Posn) Value_] -> Parser (Content Posn) Value_
    forall (p :: * -> *) a. PolyParse p => [p a] -> p a
    oneOf
            [ (String -> Value_) -> Parser (Content Posn) (String -> Value_)
    forall a. a -> Parser (Content Posn) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (String -> Value_
    Value_Str) Parser (Content Posn) (String -> Value_)
    -> Parser (Content Posn) String -> Parser (Content Posn) Value_
    forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
    `apply` Parser (Content Posn) String
    text
            , (I4 -> Value_) -> Parser (Content Posn) (I4 -> Value_)
    forall a. a -> Parser (Content Posn) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (I4 -> Value_
    Value_I4) Parser (Content Posn) (I4 -> Value_)
    -> XMLParser I4 -> Parser (Content Posn) Value_
    forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
    `apply` XMLParser I4
    forall a. XmlContent a => XMLParser a
    parseContents
            , (I8 -> Value_) -> Parser (Content Posn) (I8 -> Value_)
    forall a. a -> Parser (Content Posn) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (I8 -> Value_
    Value_I8) Parser (Content Posn) (I8 -> Value_)
    -> XMLParser I8 -> Parser (Content Posn) Value_
    forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
    `apply` XMLParser I8
    forall a. XmlContent a => XMLParser a
    parseContents
            , (AInt -> Value_) -> Parser (Content Posn) (AInt -> Value_)
    forall a. a -> Parser (Content Posn) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (AInt -> Value_
    Value_AInt) Parser (Content Posn) (AInt -> Value_)
    -> XMLParser AInt -> Parser (Content Posn) Value_
    forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
    `apply` XMLParser AInt
    forall a. XmlContent a => XMLParser a
    parseContents
            , (Boolean -> Value_) -> Parser (Content Posn) (Boolean -> Value_)
    forall a. a -> Parser (Content Posn) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Boolean -> Value_
    Value_Boolean) Parser (Content Posn) (Boolean -> Value_)
    -> XMLParser Boolean -> Parser (Content Posn) Value_
    forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
    `apply` XMLParser Boolean
    forall a. XmlContent a => XMLParser a
    parseContents
            , (AString -> Value_) -> Parser (Content Posn) (AString -> Value_)
    forall a. a -> Parser (Content Posn) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (AString -> Value_
    Value_AString) Parser (Content Posn) (AString -> Value_)
    -> XMLParser AString -> Parser (Content Posn) Value_
    forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
    `apply` XMLParser AString
    forall a. XmlContent a => XMLParser a
    parseContents
            , (DateTime_iso8601 -> Value_)
    -> Parser (Content Posn) (DateTime_iso8601 -> Value_)
    forall a. a -> Parser (Content Posn) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (DateTime_iso8601 -> Value_
    Value_DateTime_iso8601) Parser (Content Posn) (DateTime_iso8601 -> Value_)
    -> XMLParser DateTime_iso8601 -> Parser (Content Posn) Value_
    forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
    `apply` XMLParser DateTime_iso8601
    forall a. XmlContent a => XMLParser a
    parseContents
            , (ADouble -> Value_) -> Parser (Content Posn) (ADouble -> Value_)
    forall a. a -> Parser (Content Posn) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ADouble -> Value_
    Value_ADouble) Parser (Content Posn) (ADouble -> Value_)
    -> XMLParser ADouble -> Parser (Content Posn) Value_
    forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
    `apply` XMLParser ADouble
    forall a. XmlContent a => XMLParser a
    parseContents
            , (Base64 -> Value_) -> Parser (Content Posn) (Base64 -> Value_)
    forall a. a -> Parser (Content Posn) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Base64 -> Value_
    Value_Base64) Parser (Content Posn) (Base64 -> Value_)
    -> XMLParser Base64 -> Parser (Content Posn) Value_
    forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
    `apply` XMLParser Base64
    forall a. XmlContent a => XMLParser a
    parseContents
            , (Struct -> Value_) -> Parser (Content Posn) (Struct -> Value_)
    forall a. a -> Parser (Content Posn) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Struct -> Value_
    Value_Struct) Parser (Content Posn) (Struct -> Value_)
    -> XMLParser Struct -> Parser (Content Posn) Value_
    forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
    `apply` XMLParser Struct
    forall a. XmlContent a => XMLParser a
    parseContents
            , (Array -> Value_) -> Parser (Content Posn) (Array -> Value_)
    forall a. a -> Parser (Content Posn) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Array -> Value_
    Value_Array) Parser (Content Posn) (Array -> Value_)
    -> XMLParser Array -> Parser (Content Posn) Value_
    forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
    `apply` XMLParser Array
    forall a. XmlContent a => XMLParser a
    parseContents
            , (Nil -> Value_) -> Parser (Content Posn) (Nil -> Value_)
    forall a. a -> Parser (Content Posn) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Nil -> Value_
    Value_Nil) Parser (Content Posn) (Nil -> Value_)
    -> XMLParser Nil -> Parser (Content Posn) Value_
    forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
    `apply` XMLParser Nil
    forall a. XmlContent a => XMLParser a
    parseContents
            ] Parser (Content Posn) Value_
    -> ShowS -> Parser (Content Posn) Value_
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <value>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    forall i. QName -> [Attribute] -> [Content i] -> Element i
    Elem (String -> QName
    N String
    "param") [] (Value -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents Value
    a)) ()]
        parseContents :: XMLParser Param
    parseContents = do
            { e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "param"]
            ; interior e $ return (Param) `apply` parseContents
            } XMLParser Param -> ShowS -> XMLParser Param
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <param>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    forall i. QName -> [Attribute] -> [Content i] -> Element i
    Elem (String -> QName
    N String
    "params") [] ((Param -> [Content ()]) -> [Param] -> [Content ()]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap Param -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents [Param]
    a)) ()]
        parseContents :: XMLParser Params
    parseContents = do
            { e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "params"]
            ; interior e $ return (Params) `apply` many parseContents
            } XMLParser Params -> ShowS -> XMLParser Params
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <params>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    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@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "methodName"]
            ; interior e $ return (MethodName)
                           `apply` (text `onFail` return "")
            } XMLParser MethodName -> ShowS -> XMLParser MethodName
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <methodName>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    forall i. QName -> [Attribute] -> [Content i] -> Element i
    Elem (String -> QName
    N String
    "methodCall") [] (MethodName -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents MethodName
    a [Content ()] -> [Content ()] -> [Content ()]
    forall a. [a] -> [a] -> [a]
    ++
                                          [Content ()]
    -> (Params -> [Content ()]) -> Maybe Params -> [Content ()]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe [] Params -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents Maybe Params
    b)) ()]
        parseContents :: XMLParser MethodCall
    parseContents = do
            { e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "methodCall"]
            ; interior e $ return (MethodCall) `apply` parseContents
                           `apply` optional parseContents
            } XMLParser MethodCall -> ShowS -> XMLParser MethodCall
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <methodCall>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    forall i. QName -> [Attribute] -> [Content i] -> Element i
    Elem (String -> QName
    N String
    "fault") [] (Value -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents Value
    a)) ()]
        parseContents :: XMLParser Fault
    parseContents = do
            { e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "fault"]
            ; interior e $ return (Fault) `apply` parseContents
            } XMLParser Fault -> ShowS -> XMLParser Fault
    forall a.
    Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
    forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
    `adjustErr` (String
    "in <fault>, "String -> ShowS
    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) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    forall i. QName -> [Attribute] -> [Content i] -> Element i
    Elem (String -> QName
    N String
    "methodResponse") [] (Params -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents Params
    a) ) ()]
        toContents (MethodResponseFault Fault
    a) =
            [Element () -> () -> Content ()
    forall i. Element i -> i -> Content i
    CElem (QName -> [Attribute] -> [Content ()] -> Element ()
    forall i. QName -> [Attribute] -> [Content i] -> Element i
    Elem (String -> QName
    N String
    "methodResponse") [] (Fault -> [Content ()]
    forall a. XmlContent a => a -> [Content ()]
    toContents Fault
    a) ) ()]
        parseContents :: XMLParser MethodResponse
    parseContents = do
            { e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
    element [String
    "methodResponse"]
            ; interior e $ oneOf
                [ return (MethodResponseParams) `apply` parseContents
                , return (MethodResponseFault) `apply` parseContents
                ] `adjustErr` ("in <methodResponse>, "++)
            }

    {-Done-}