diff --git a/seqid.cabal b/seqid.cabal
--- a/seqid.cabal
+++ b/seqid.cabal
@@ -1,5 +1,5 @@
 name:                seqid
-version:             0.5.3
+version:             0.6.0
 synopsis:            Sequence ID production and consumption
 description:         Uniquely identify elements in a sequence.
 License:             BSD3
diff --git a/src/Data/SequenceId.hs b/src/Data/SequenceId.hs
--- a/src/Data/SequenceId.hs
+++ b/src/Data/SequenceId.hs
@@ -16,7 +16,6 @@
          -- * Types
        , SequenceIdError (..)
        , SequenceIdErrorType (..)
-       , SequenceId (..)
        ) where
 
 
@@ -24,36 +23,28 @@
 import           Control.Monad.State.Class (MonadState, get, modify', put)
 import           Control.Monad.Trans.Class (MonadTrans)
 import           Control.Monad.Trans.State (StateT (..), evalStateT, execStateT)
-import           Data.Word                 (Word32)
 
 
-newtype SequenceIdT m a = SequenceIdT { unSequenceIdT :: StateT SequenceId m a }
-                        deriving (Monad, Applicative, Functor, MonadState SequenceId, MonadTrans)
-
-newtype SequenceId = SequenceId { unSequenceId :: Word32 }
-                   deriving (Eq, Ord, Num, Integral, Real, Enum)
-
-instance Show SequenceId where
-    show (SequenceId n) = show n
+newtype SequenceIdT s m a = SequenceIdT { unSequenceIdT :: StateT s m a }
+    deriving (Monad, Applicative, Functor, MonadState s, MonadTrans)
 
 
-evalSequenceIdT :: Monad m => SequenceIdT m b -> SequenceId -> m b
+evalSequenceIdT :: Monad m => SequenceIdT s m b -> s -> m b
 evalSequenceIdT = evalStateT . unSequenceIdT
 
 
-execSequenceIdT :: Monad m => SequenceIdT m b -> SequenceId -> m SequenceId
+execSequenceIdT :: Monad m => SequenceIdT s m b -> s -> m s
 execSequenceIdT = execStateT . unSequenceIdT
 
 
-runSequenceIdT :: Monad m => SequenceIdT m b -> SequenceId -> m (b, SequenceId)
+runSequenceIdT :: Monad m => SequenceIdT s m b -> s -> m (b, s)
 runSequenceIdT = runStateT . unSequenceIdT
 
 
-data SequenceIdError =
-    SequenceIdError
+data SequenceIdError a = SequenceIdError
     { errType   :: !SequenceIdErrorType
-    , lastSeqId :: !SequenceId
-    , currSeqId :: !SequenceId
+    , lastSeqId :: !a
+    , currSeqId :: !a
     } deriving (Eq, Show)
 
 
@@ -65,8 +56,9 @@
 
 -- | If the current sequence ID is greater than 1 more than the last
 -- sequence ID then the appropriate error is returned.
-checkSeqIdM :: Monad m => SequenceId -- ^ Current sequence ID
-            -> (SequenceIdT m) (Maybe SequenceIdError)
+checkSeqIdM :: (Integral s, Monad m)
+            => s -- ^ Current sequence ID
+            -> SequenceIdT s m (Maybe (SequenceIdError s))
 checkSeqIdM currSeq = do
     lastSeq <- get
     put $ max lastSeq currSeq
@@ -75,30 +67,32 @@
 
 -- | If the difference between the sequence IDs is not 1 then the
 -- appropriate error is returned.
-checkSeqId :: SequenceId -- ^ Last sequence ID
-           -> SequenceId -- ^ Current sequence ID
-           -> Maybe SequenceIdError
+checkSeqId :: Integral s
+           => s -- ^ Last sequence ID
+           -> s -- ^ Current sequence ID
+           -> Maybe (SequenceIdError s)
 checkSeqId lastSeq currSeq
     | delta lastSeq currSeq > 1 = Just $ SequenceIdError SequenceIdDropped    lastSeq currSeq
     | delta lastSeq currSeq < 1 = Just $ SequenceIdError SequenceIdDuplicated lastSeq currSeq
     | otherwise                 = Nothing
 
 
-delta :: SequenceId -> SequenceId -> Int
+delta :: Integral s => s -> s -> Int
 delta lastSeq currSeq = fromIntegral currSeq - fromIntegral lastSeq
 
 
 -- | Update to the next sequense ID
-incrementSeqIdM :: Monad m => SequenceIdT m SequenceId -- ^ Next sequence ID
+incrementSeqIdM :: (Monad m, Integral s) => SequenceIdT s m s -- ^ Next sequence ID
 incrementSeqIdM = modify' incrementSeqId >> get
 
 
 -- | Increment to the next sequense ID
-incrementSeqId :: SequenceId -- ^ Last sequence ID
-               -> SequenceId -- ^ Next sequence ID
+incrementSeqId :: Integral s
+               => s -- ^ Last sequence ID
+               -> s -- ^ Next sequence ID
 incrementSeqId = (+1)
 
 
 -- | Last seen sequense ID
-lastSeqIdM :: Monad m => SequenceIdT m SequenceId -- ^ Last sequence ID
+lastSeqIdM :: Monad m => SequenceIdT s m s -- ^ Last sequence ID
 lastSeqIdM = get