diff --git a/Text/XML/LibXML/Enumerator.hs b/Text/XML/LibXML/Enumerator.hs
--- a/Text/XML/LibXML/Enumerator.hs
+++ b/Text/XML/LibXML/Enumerator.hs
@@ -9,8 +9,7 @@
 --
 -----------------------------------------------------------------------------
 module Text.XML.LibXML.Enumerator
-	( Event (..)
-	, parseBytesIO
+	( parseBytesIO
 	, parseTextIO
 	, parseBytesST
 	, parseTextST
@@ -19,6 +18,7 @@
 import qualified Data.Enumerator as E
 import Data.Enumerator ((>>==))
 import qualified Data.Text as T
+import qualified Data.Text.Lazy as TL
 import qualified Data.XML.Types as X
 import qualified Text.XML.LibXML.SAX as SAX
 
@@ -29,17 +29,7 @@
 import qualified Data.STRef as ST
 import qualified Data.IORef as IO
 
-data Event
-	= EventBeginDocument
-	| EventEndDocument
-	| EventBeginElement X.Name [X.Attribute]
-	| EventEndElement X.Name
-	| EventCharacters T.Text
-	| EventComment T.Text
-	| EventInstruction X.Instruction
-	deriving (Show, Eq)
-
-newParserIO :: Maybe T.Text -> IO (SAX.Parser IO, IO.IORef [Event], IO.IORef (Maybe T.Text))
+newParserIO :: Maybe T.Text -> IO (SAX.Parser IO, IO.IORef [X.Event], IO.IORef (Maybe T.Text))
 newParserIO name = do
 	errRef <- IO.newIORef Nothing
 	p <- SAX.newParserIO (\msg -> IO.writeIORef errRef (Just msg)) name
@@ -48,7 +38,7 @@
 	setCallbacks p addEvent
 	return (p, eventRef, errRef)
 
-newParserST :: Maybe T.Text -> ST s (SAX.Parser (ST s), ST.STRef s [Event], ST.STRef s (Maybe T.Text))
+newParserST :: Maybe T.Text -> ST s (SAX.Parser (ST s), ST.STRef s [X.Event], ST.STRef s (Maybe T.Text))
 newParserST name = do
 	errRef <- ST.newSTRef Nothing
 	p <- SAX.newParserST (\msg -> ST.writeSTRef errRef (Just msg)) name
@@ -57,28 +47,30 @@
 	setCallbacks p addEvent
 	return (p, eventRef, errRef)
 
-setCallbacks :: Monad m => SAX.Parser m -> (Event -> m Bool) -> m ()
+setCallbacks :: Monad m => SAX.Parser m -> (X.Event -> m Bool) -> m ()
 setCallbacks p addEvent = do
 	let set cb st = SAX.setCallback p cb st
 	
-	set SAX.parsedBeginDocument (addEvent EventBeginDocument)
-	set SAX.parsedEndDocument (addEvent EventEndDocument)
-	set SAX.parsedBeginElement ((addEvent .) . EventBeginElement)
-	set SAX.parsedEndElement (addEvent . EventEndElement)
-	set SAX.parsedCharacters (addEvent . EventCharacters)
-	set SAX.parsedComment (addEvent . EventComment)
-	set SAX.parsedInstruction (addEvent . EventInstruction)
+	let fromStrict txt = TL.fromChunks [txt]
+	
+	set SAX.parsedBeginDocument (addEvent X.EventBeginDocument)
+	set SAX.parsedEndDocument (addEvent X.EventEndDocument)
+	set SAX.parsedBeginElement ((addEvent .) . X.EventBeginElement)
+	set SAX.parsedEndElement (addEvent . X.EventEndElement)
+	set SAX.parsedCharacters (addEvent . X.EventContent . X.ContentText . fromStrict)
+	set SAX.parsedComment (addEvent . X.EventComment . fromStrict)
+	set SAX.parsedInstruction (addEvent . X.EventInstruction)
 
-parseBytesIO :: MonadIO m => Maybe T.Text -> E.Enumeratee B.ByteString Event m b
+parseBytesIO :: MonadIO m => Maybe T.Text -> E.Enumeratee B.ByteString X.Event m b
 parseBytesIO = parseIO SAX.parseBytes
 
-parseTextIO :: MonadIO m => Maybe T.Text -> E.Enumeratee T.Text Event m b
+parseTextIO :: MonadIO m => Maybe T.Text -> E.Enumeratee T.Text X.Event m b
 parseTextIO = parseIO SAX.parseText
 
 parseIO :: MonadIO m
         => (SAX.Parser IO -> a -> IO ())
         -> Maybe T.Text
-        -> E.Enumeratee a Event m b
+        -> E.Enumeratee a X.Event m b
 parseIO parseFn name s = E.Iteratee $ do
 	(p, eventRef, errRef) <- liftIO $ newParserIO name
 	
@@ -94,15 +86,15 @@
 	let complete = withEvents (SAX.parseComplete p)
 	E.runIteratee $ eneeParser parseChunk complete s
 
-parseBytesST :: Maybe T.Text -> E.Enumeratee B.ByteString Event (ST s) b
+parseBytesST :: Maybe T.Text -> E.Enumeratee B.ByteString X.Event (ST s) b
 parseBytesST = parseST SAX.parseBytes
 
-parseTextST :: Maybe T.Text -> E.Enumeratee T.Text Event (ST s) b
+parseTextST :: Maybe T.Text -> E.Enumeratee T.Text X.Event (ST s) b
 parseTextST = parseST SAX.parseText
 
 parseST :: (SAX.Parser (ST s) -> a -> ST s ())
         -> Maybe T.Text
-        -> E.Enumeratee a Event (ST s) b
+        -> E.Enumeratee a X.Event (ST s) b
 parseST parseFn name s = E.Iteratee $ do
 	(p, eventRef, errRef) <- newParserST name
 	
@@ -119,9 +111,9 @@
 	E.runIteratee $ eneeParser parseChunk complete s
 
 eneeParser :: Monad m
-           => (a -> m ([Event], Maybe T.Text))
-           -> m ([Event], Maybe T.Text)
-           -> E.Enumeratee a Event m b
+           => (a -> m ([X.Event], Maybe T.Text))
+           -> m ([X.Event], Maybe T.Text)
+           -> E.Enumeratee a X.Event m b
 eneeParser parseChunk parseComplete = E.checkDone (E.continue . step) where
 	step k E.EOF = checkEvents k parseComplete (\k' -> E.yield (E.Continue k') E.EOF)
 	step k (E.Chunks xs) = parseLoop k xs
diff --git a/libxml-enumerator.cabal b/libxml-enumerator.cabal
--- a/libxml-enumerator.cabal
+++ b/libxml-enumerator.cabal
@@ -1,5 +1,5 @@
 name: libxml-enumerator
-version: 0.3
+version: 0.4
 synopsis: Enumerator-based API for libXML's SAX interface
 license: MIT
 license-file: license.txt
@@ -23,7 +23,7 @@
     , enumerator >= 0.4 && < 0.5
     , transformers >= 0.2 && < 0.3
     , libxml-sax >= 0.6 && < 0.7
-    , xml-types >= 0.1 && < 0.2
+    , xml-types >= 0.1.1 && < 0.2
 
   exposed-modules:
     Text.XML.LibXML.Enumerator