diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 # purescript-bridge
 
 
-[![Build Status](https://travis-ci.org/eskimor/purescript-bridge.svg?branch=master)](https://travis-ci.org/eskimor/purescript-bridge)
+[![Haskell library and example](https://github.com/eskimor/purescript-bridge/actions/workflows/haskell.yml/badge.svg)](https://github.com/eskimor/purescript-bridge/actions/workflows/haskell.yml) [![Purescript example](https://github.com/eskimor/purescript-bridge/actions/workflows/purescript.yml/badge.svg)](https://github.com/eskimor/purescript-bridge/actions/workflows/purescript.yml) [![Build Status](https://travis-ci.org/eskimor/purescript-bridge.svg?branch=master)](https://travis-ci.org/eskimor/purescript-bridge)
 
 
 
@@ -10,11 +10,18 @@
 
 Data type translation is fully and easily customizable by providing your own `BridgePart` instances!
 
+The latest version of this project requires **Purescript 0.15**.
+
 ## JSON encoding / decoding
 
-For compatible JSON representations you should be using [aeson](http://hackage.haskell.org/package/aeson)'s generic encoding/decoding with default options
-and `encodeJson` and `decodeJson` from "Data.Argonaut.Generic.Aeson" in [purescript-argonaut-generic-codecs](https://github.com/eskimor/purescript-argonaut-generic-codecs).
+For compatible JSON representations:
 
+* On Haskell side:
+  * Use [`aeson`](http://hackage.haskell.org/package/aeson)'s generic encoding/decoding with default options
+* On Purescript side:
+  * Use [`purescript-argonaut-aeson-generic >=0.4.1`](https://pursuit.purescript.org/packages/purescript-argonaut-aeson-generic/0.4.1) ([GitHub](https://github.com/coot/purescript-argonaut-aeson-generic))
+  * Or use [`purescript-foreign-generic`](https://pursuit.purescript.org/packages/purescript-foreign-generic).
+    * [This branch](https://github.com/paf31/purescript-foreign-generic/pull/76) is updated for Purescript 0.15.
 
 ## Documentation
 
diff --git a/purescript-bridge.cabal b/purescript-bridge.cabal
--- a/purescript-bridge.cabal
+++ b/purescript-bridge.cabal
@@ -10,7 +10,7 @@
 -- PVP summary:      +-+------- breaking API changes
 --                   | | +----- non-breaking API additions
 --                   | | | +--- code changes with no API change
-version:             0.14.0.0
+version:             0.15.0.0
 
 -- A short (one-line) description of the package.
 synopsis:            Generate PureScript data types from Haskell data types
diff --git a/src/Language/PureScript/Bridge.hs b/src/Language/PureScript/Bridge.hs
--- a/src/Language/PureScript/Bridge.hs
+++ b/src/Language/PureScript/Bridge.hs
@@ -130,12 +130,18 @@
     <|> listBridge
     <|> maybeBridge
     <|> eitherBridge
+    <|> strMapBridge
     <|> boolBridge
     <|> intBridge
     <|> doubleBridge
     <|> tupleBridge
     <|> unitBridge
     <|> noContentBridge
+    <|> wordBridge
+    <|> word8Bridge
+    <|> word16Bridge
+    <|> word32Bridge
+    <|> word64Bridge
 
 -- | Translate types in a constructor.
 bridgeConstructor :: FullBridge -> DataConstructor 'Haskell -> DataConstructor 'PureScript
diff --git a/src/Language/PureScript/Bridge/Builder.hs b/src/Language/PureScript/Bridge/Builder.hs
--- a/src/Language/PureScript/Bridge/Builder.hs
+++ b/src/Language/PureScript/Bridge/Builder.hs
@@ -43,6 +43,7 @@
 import           Control.Monad.Trans.Reader          (Reader, ReaderT (..),
                                                       runReader)
 import           Data.Maybe                          (fromMaybe)
+import           Data.Monoid ((<>))
 import qualified Data.Text                           as T
 import           Language.PureScript.Bridge.TypeInfo
 
diff --git a/src/Language/PureScript/Bridge/CodeGenSwitches.hs b/src/Language/PureScript/Bridge/CodeGenSwitches.hs
--- a/src/Language/PureScript/Bridge/CodeGenSwitches.hs
+++ b/src/Language/PureScript/Bridge/CodeGenSwitches.hs
@@ -3,13 +3,13 @@
     ( Settings (..)
     , ForeignOptions(..)
     , defaultSettings
-    , purs_0_11_settings
     , Switch
     , getSettings
     , defaultSwitch
     , noLenses, genLenses
     , useGen, useGenRep
-    , genForeign, noForeign
+    , genForeign, noForeign, noArgonautCodecs
+    , genArgonautCodecs
     ) where
 
 
@@ -19,24 +19,20 @@
 data Settings = Settings
     { generateLenses :: Bool -- ^use purescript-profunctor-lens for generated PS-types?
     , genericsGenRep :: Bool -- ^generate generics using purescript-generics-rep instead of purescript-generics
+    , generateArgonautCodecs :: Bool -- ^generate Data.Argonaut.Decode.Class EncodeJson and DecodeJson instances
     , generateForeign :: Maybe ForeignOptions -- ^generate Foreign.Generic Encode and Decode instances
     }
     deriving (Eq, Show)
 
 data ForeignOptions = ForeignOptions
     { unwrapSingleConstructors :: Bool
+    , unwrapSingleArguments    :: Bool
     }
     deriving (Eq, Show)
 
 -- | Settings to generate Lenses
 defaultSettings :: Settings
-defaultSettings = Settings True True Nothing
-
-
--- |settings for purescript 0.11.x
-purs_0_11_settings :: Settings
-purs_0_11_settings = Settings True False Nothing
-
+defaultSettings = Settings True True True Nothing
 
 -- | you can `mappend` switches to control the code generation
 type Switch = Endo Settings
@@ -56,6 +52,10 @@
 noLenses :: Switch
 noLenses = Endo $ \settings -> settings { generateLenses = False }
 
+-- | Switch off the generatation of argonaut-codecs
+noArgonautCodecs :: Switch
+noArgonautCodecs = Endo $ \settings ->
+  settings { generateArgonautCodecs = False }
 
 -- | Switch on the generatation of profunctor-lenses
 genLenses :: Switch
@@ -73,6 +73,10 @@
 
 genForeign :: ForeignOptions -> Switch
 genForeign opts = Endo $ \settings -> settings { generateForeign = Just opts }
+
+genArgonautCodecs :: Switch
+genArgonautCodecs = Endo $ \settings ->
+  settings { generateArgonautCodecs = True }
 
 noForeign :: Switch
 noForeign = Endo $ \settings -> settings { generateForeign = Nothing }
diff --git a/src/Language/PureScript/Bridge/PSTypes.hs b/src/Language/PureScript/Bridge/PSTypes.hs
--- a/src/Language/PureScript/Bridge/PSTypes.hs
+++ b/src/Language/PureScript/Bridge/PSTypes.hs
@@ -31,6 +31,11 @@
 psEither :: MonadReader BridgeData m => m PSType
 psEither = TypeInfo "purescript-either" "Data.Either" "Either" <$> psTypeParameters
 
+psObject :: MonadReader BridgeData m => m PSType
+psObject = do
+  valueTypes <- tail <$> psTypeParameters
+  return $ TypeInfo "purescript-foreign-object" "Foreign.Object" "Object" valueTypes
+
 psInt :: PSType
 psInt = TypeInfo {
     _typePackage = ""
@@ -73,5 +78,45 @@
     _typePackage = "purescript-prelude"
   , _typeModule = "Prelude"
   , _typeName = "Unit"
+  , _typeParameters = []
+  }
+
+psWord :: PSType
+psWord = TypeInfo  {
+    _typePackage = "purescript-word"
+  , _typeModule = "Data.Word"
+  , _typeName = "Word"
+  , _typeParameters = []
+  }
+
+psWord8 :: PSType
+psWord8 = TypeInfo  {
+    _typePackage = "purescript-word"
+  , _typeModule = "Data.Word"
+  , _typeName = "Word8"
+  , _typeParameters = []
+  }
+
+psWord16 :: PSType
+psWord16 = TypeInfo  {
+    _typePackage = "purescript-word"
+  , _typeModule = "Data.Word"
+  , _typeName = "Word16"
+  , _typeParameters = []
+  }
+
+psWord32 :: PSType
+psWord32 = TypeInfo  {
+    _typePackage = "purescript-word"
+  , _typeModule = "Data.Word"
+  , _typeName = "Word32"
+  , _typeParameters = []
+  }
+
+psWord64 :: PSType
+psWord64 = TypeInfo  {
+    _typePackage = "purescript-word"
+  , _typeModule = "Data.Word"
+  , _typeName = "Word64"
   , _typeParameters = []
   }
diff --git a/src/Language/PureScript/Bridge/Primitives.hs b/src/Language/PureScript/Bridge/Primitives.hs
--- a/src/Language/PureScript/Bridge/Primitives.hs
+++ b/src/Language/PureScript/Bridge/Primitives.hs
@@ -19,6 +19,9 @@
 eitherBridge :: BridgePart
 eitherBridge = typeName ^== "Either" >> psEither
 
+strMapBridge :: BridgePart
+strMapBridge = typeName ^== "Map" >> psObject
+
 -- | Dummy bridge, translates every type with 'clearPackageFixUp'
 dummyBridge :: MonadReader BridgeData m => m PSType
 dummyBridge = clearPackageFixUp
@@ -49,3 +52,18 @@
 
 noContentBridge :: BridgePart
 noContentBridge = typeName ^== "NoContent" >> return psUnit
+
+wordBridge :: BridgePart
+wordBridge = typeName ^== "Word" >> return psWord
+
+word8Bridge :: BridgePart
+word8Bridge = typeName ^== "Word8" >> return psWord8
+
+word16Bridge :: BridgePart
+word16Bridge = typeName ^== "Word16" >> return psWord16
+
+word32Bridge :: BridgePart
+word32Bridge = typeName ^== "Word32" >> return psWord32
+
+word64Bridge :: BridgePart
+word64Bridge = typeName ^== "Word64" >> return psWord64
diff --git a/src/Language/PureScript/Bridge/Printer.hs b/src/Language/PureScript/Bridge/Printer.hs
--- a/src/Language/PureScript/Bridge/Printer.hs
+++ b/src/Language/PureScript/Bridge/Printer.hs
@@ -1,6 +1,8 @@
 {-# LANGUAGE DataKinds         #-}
 {-# LANGUAGE KindSignatures    #-}
 {-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE RecordWildCards   #-}
+{-# LANGUAGE LambdaCase        #-}
 
 module Language.PureScript.Bridge.Printer where
 
@@ -8,6 +10,7 @@
 import           Control.Monad
 import           Data.Map.Strict (Map)
 import qualified Data.Map.Strict as Map
+import           Data.Monoid ((<>))
 import           Data.Set (Set)
 import           Data.Maybe (isJust)
 import qualified Data.Set as Set
@@ -17,7 +20,6 @@
 import           System.Directory
 import           System.FilePath
 
-
 import           Language.PureScript.Bridge.SumType
 import           Language.PureScript.Bridge.TypeInfo
 import qualified Language.PureScript.Bridge.CodeGenSwitches as Switches
@@ -33,6 +35,7 @@
 
 data ImportLine = ImportLine {
   importModule :: !Text
+, importAlias  :: !(Maybe Text)
 , importTypes  :: !(Set Text)
 } deriving Show
 
@@ -66,45 +69,63 @@
      ]
   <> map (sumTypeToText settings) (psTypes m)
   where
-    otherImports = importsFromList (_lensImports settings <> _genericsImports settings <> _foreignImports settings)
+    otherImports = importsFromList $
+      _lensImports settings
+      <> _genericsImports settings
+      <> _argonautCodecsImports settings
+      <> _foreignImports settings
     allImports = Map.elems $ mergeImportLines otherImports (psImportLines m)
 
-
 _genericsImports :: Switches.Settings -> [ImportLine]
 _genericsImports settings
   | Switches.genericsGenRep settings =
-     [ ImportLine "Data.Generic.Rep" $ Set.fromList ["class Generic"] ]
+     [ ImportLine "Data.Generic.Rep" Nothing $ Set.fromList ["class Generic"] ]
   | otherwise =
-    [ ImportLine "Data.Generic" $ Set.fromList ["class Generic"] ]
-
+    [ ImportLine "Data.Generic" Nothing $ Set.fromList ["class Generic"] ]
 
 _lensImports :: Switches.Settings -> [ImportLine]
 _lensImports settings
   | Switches.generateLenses settings =
-    [ ImportLine "Data.Maybe" $ Set.fromList ["Maybe(..)"]
-    , ImportLine "Data.Lens" $ Set.fromList ["Iso'", "Prism'", "Lens'", "prism'", "lens"]
-    , ImportLine "Data.Lens.Record" $ Set.fromList ["prop"]
-    , ImportLine "Data.Lens.Iso.Newtype" $ Set.fromList ["_Newtype"]
-    , ImportLine "Data.Symbol" $ Set.fromList ["SProxy(SProxy)"]
-    , ImportLine "Data.Newtype" $ Set.fromList ["class Newtype"]
+    [ ImportLine "Data.Lens" Nothing $ Set.fromList ["Iso'", "Prism'", "Lens'", "prism'", "lens"]
+    , ImportLine "Data.Lens.Iso.Newtype" Nothing $ Set.fromList ["_Newtype"]
+    , ImportLine "Data.Lens.Record" Nothing $ Set.fromList ["prop"]
+    ] <> baseline <>
+    [ ImportLine "Type.Proxy" Nothing $ Set.fromList ["Proxy(Proxy)"]
     ]
-  | otherwise =
-    [ ImportLine "Data.Maybe" $ Set.fromList ["Maybe(..)"]
-    , ImportLine "Data.Newtype" $ Set.fromList ["class Newtype"]
+  | otherwise = baseline
+  where
+    baseline =
+      [ ImportLine "Data.Maybe" Nothing $ Set.fromList ["Maybe(..)"]
+      , ImportLine "Data.Newtype" Nothing $ Set.fromList ["class Newtype"]
+      ]
+
+_argonautCodecsImports :: Switches.Settings -> [ImportLine]
+_argonautCodecsImports settings
+  | Switches.generateArgonautCodecs settings =
+    [ ImportLine "Data.Argonaut.Aeson.Decode.Generic" Nothing $ Set.fromList [ "genericDecodeAeson" ]
+    , ImportLine "Data.Argonaut.Aeson.Encode.Generic" Nothing $ Set.fromList [ "genericEncodeAeson" ]
+    , ImportLine "Data.Argonaut.Aeson.Options" (Just "Argonaut") $ Set.fromList [ "defaultOptions" ]
+    , ImportLine "Data.Argonaut.Decode.Class" Nothing $ Set.fromList [ "class DecodeJson", "class DecodeJsonField", "decodeJson" ]
+    , ImportLine "Data.Argonaut.Encode.Class" Nothing $ Set.fromList [ "class EncodeJson", "encodeJson" ]
     ]
+  | otherwise = mempty
 
 _foreignImports :: Switches.Settings -> [ImportLine]
 _foreignImports settings
   | (isJust . Switches.generateForeign) settings = 
-      [ ImportLine "Foreign.Generic" $ Set.fromList ["defaultOptions", "genericDecode", "genericEncode"]
-      , ImportLine "Foreign.Class" $ Set.fromList ["class Decode", "class Encode"]
+      [ ImportLine "Foreign.Class" Nothing $ Set.fromList ["class Decode", "class Encode"]
+      , ImportLine "Foreign.Generic" Nothing $ Set.fromList ["defaultOptions", "genericDecode", "genericEncode"]
       ]
-  | otherwise = []
+  | otherwise = mempty
 
 importLineToText :: ImportLine -> Text
-importLineToText l = "import " <> importModule l <> " (" <> typeList <> ")"
+importLineToText = \case
+  ImportLine importModule Nothing importTypes ->
+    "import " <> importModule <> " (" <> typeList importTypes <> ")"
+  ImportLine importModule (Just importAlias) _ ->
+    "import " <> importModule <> " as " <> importAlias
   where
-    typeList = T.intercalate ", " (Set.toList (importTypes l))
+    typeList s = T.intercalate ", " (Set.toList s)
 
 sumTypeToText :: Switches.Settings -> SumType 'PureScript -> Text
 sumTypeToText settings st =
@@ -119,13 +140,35 @@
 sumTypeToTypeDecls settings (SumType t cs is) = T.unlines $
     dataOrNewtype <> " " <> typeInfoToText True t <> " ="
   : "    " <> T.intercalate "\n  | " (map (constructorToText 4) cs) <> "\n"
-  : instances settings (SumType t cs (filter genForeign is))
+  : instances settings (SumType t cs (filter genForeign . filter genArgonautCodec $ is))
   where
     dataOrNewtype = if isJust (nootype cs) then "newtype" else "data"
-    genForeign Encode = (isJust . Switches.generateForeign) settings
-    genForeign Decode = (isJust . Switches.generateForeign) settings
-    genForeign _ = True
+    genForeign :: Instance -> Bool
+    genForeign = \case
+      Encode -> check
+      Decode -> check
+      _      -> True
+      where check = (isJust . Switches.generateForeign) settings
 
+    genArgonautCodec :: Instance -> Bool
+    genArgonautCodec = \case
+      EncodeJson -> check
+      DecodeJson -> check
+      _          -> True
+      where check = Switches.generateArgonautCodecs settings
+
+foreignOptionsToPurescript :: Maybe Switches.ForeignOptions -> Text
+foreignOptionsToPurescript = \case
+  Nothing -> mempty
+  Just (Switches.ForeignOptions{..}) ->
+    " { unwrapSingleConstructors = "
+    <> (T.toLower . T.pack . show $ unwrapSingleConstructors)
+    <> " , unwrapSingleArguments = "
+    <> (T.toLower . T.pack . show $ unwrapSingleArguments)
+    <> " }"
+
+
+
 -- | Given a Purescript type, generate instances for typeclass
 -- instances it claims to have.
 instances :: Switches.Settings -> SumType 'PureScript -> [Text]
@@ -135,9 +178,8 @@
     go Encode = "instance encode" <> _typeName t <> " :: " <> extras <> "Encode " <> typeInfoToText False t <> " where\n" <>
                 "  encode = genericEncode $ defaultOptions" <> encodeOpts
       where
-        encodeOpts = case Switches.generateForeign settings of
-                      Nothing -> ""
-                      Just fopts -> " { unwrapSingleConstructors = " <> (T.toLower . T.pack . show . Switches.unwrapSingleConstructors) fopts <> " }"
+        encodeOpts =
+          foreignOptionsToPurescript $ Switches.generateForeign settings
         stpLength = length sumTypeParameters
         extras | stpLength == 0 = mempty
                | otherwise = bracketWrap constraintsInner <> " => "
@@ -145,12 +187,23 @@
         constraintsInner = T.intercalate ", " $ map instances sumTypeParameters
         instances params = genericInstance settings params <> ", " <> encodeInstance params
         bracketWrap x = "(" <> x <> ")"
+    go EncodeJson = "instance encodeJson" <> _typeName t <> " :: " <> extras <> "EncodeJson " <> typeInfoToText False t <> " where\n" <>
+                "  encodeJson = genericEncodeAeson Argonaut.defaultOptions"
+      where
+        encodeOpts =
+          foreignOptionsToPurescript $ Switches.generateForeign settings
+        stpLength = length sumTypeParameters
+        extras | stpLength == 0 = mempty
+               | otherwise = bracketWrap constraintsInner <> " => "
+        sumTypeParameters = filter (isTypeParam t) . Set.toList $ getUsedTypes st
+        constraintsInner = T.intercalate ", " $ map instances sumTypeParameters
+        instances params = genericInstance settings params <> ", " <> encodeJsonInstance params
+        bracketWrap x = "(" <> x <> ")"
     go Decode = "instance decode" <> _typeName t <> " :: " <> extras <> "Decode " <> typeInfoToText False t <> " where\n" <>
                 "  decode = genericDecode $ defaultOptions" <> decodeOpts
       where
-        decodeOpts = case Switches.generateForeign settings of
-                      Nothing -> ""
-                      Just fopts -> " { unwrapSingleConstructors = " <> (T.toLower . T.pack . show . Switches.unwrapSingleConstructors) fopts <> " }"
+        decodeOpts =
+          foreignOptionsToPurescript $ Switches.generateForeign settings
         stpLength = length sumTypeParameters
         extras | stpLength == 0 = mempty
                | otherwise = bracketWrap constraintsInner <> " => "
@@ -158,6 +211,16 @@
         constraintsInner = T.intercalate ", " $ map instances sumTypeParameters
         instances params = genericInstance settings params <> ", " <> decodeInstance params
         bracketWrap x = "(" <> x <> ")"
+    go DecodeJson = "instance decodeJson" <> _typeName t <> " :: " <> extras <> "DecodeJson " <> typeInfoToText False t <> " where\n" <>
+                "  decodeJson = genericDecodeAeson Argonaut.defaultOptions"
+      where
+        stpLength = length sumTypeParameters
+        extras | stpLength == 0 = mempty
+               | otherwise = bracketWrap constraintsInner <> " => "
+        sumTypeParameters = filter (isTypeParam t) . Set.toList $ getUsedTypes st
+        constraintsInner = T.intercalate ", " $ map instances sumTypeParameters
+        instances params = genericInstance settings params <> ", " <> decodeJsonInstance params <> ", " <> decodeJsonFieldInstance params
+        bracketWrap x = "(" <> x <> ")"
     go i = "derive instance " <> T.toLower c <> _typeName t <> " :: " <> extras i <> c <> " " <> typeInfoToText False t <> postfix i
       where c = T.pack $ show i
             extras Generic | stpLength == 0 = mempty
@@ -180,9 +243,18 @@
 encodeInstance :: PSType -> Text
 encodeInstance params = "Encode " <> typeInfoToText False params
 
+encodeJsonInstance :: PSType -> Text
+encodeJsonInstance params = "EncodeJson " <> typeInfoToText False params
+
 decodeInstance :: PSType -> Text
 decodeInstance params = "Decode " <> typeInfoToText False params
 
+decodeJsonInstance :: PSType -> Text
+decodeJsonInstance params = "DecodeJson " <> typeInfoToText False params
+
+decodeJsonFieldInstance :: PSType -> Text
+decodeJsonFieldInstance params = "DecodeJsonField " <> typeInfoToText False params
+
 genericInstance :: Switches.Settings -> PSType -> Text
 genericInstance settings params =
   if not (Switches.genericsGenRep settings) then
@@ -227,7 +299,6 @@
 spaces :: Int -> Text
 spaces c = T.replicate c " "
 
-
 typeNameAndForall :: TypeInfo 'PureScript -> (Text, Text)
 typeNameAndForall typeInfo = (typName, forAll)
   where
@@ -297,7 +368,7 @@
 recordEntryToLens st e =
   if hasUnderscore
   then lensName <> forAll <>  "Lens' " <> typName <> " " <> recType <> "\n"
-      <> lensName <> " = _Newtype <<< prop (SProxy :: SProxy \"" <> recName <> "\")\n"
+      <> lensName <> " = _Newtype <<< prop (Proxy :: Proxy \"" <> recName <> "\")\n"
   else ""
   where
     (typName, forAll) = typeNameAndForall (st ^. sumTypeInfo)
@@ -356,20 +427,21 @@
                 then Map.alter (Just . updateLine) (_typeModule t)
                 else id
 
-    updateLine Nothing = ImportLine (_typeModule t) (Set.singleton (_typeName t))
-    updateLine (Just (ImportLine m types)) = ImportLine m $ Set.insert (_typeName t) types
+    updateLine Nothing = ImportLine (_typeModule t) Nothing (Set.singleton (_typeName t))
+    updateLine (Just (ImportLine m alias types)) =
+      ImportLine m alias (Set.insert (_typeName t) types)
 
 importsFromList :: [ImportLine] -> Map Text ImportLine
 importsFromList ls = let
     pairs = zip (map importModule ls) ls
-    merge a b = ImportLine (importModule a) (importTypes a `Set.union` importTypes b)
+    merge a b = ImportLine (importModule a) (importAlias a) (importTypes a `Set.union` importTypes b)
   in
     Map.fromListWith merge pairs
 
 mergeImportLines :: ImportLines -> ImportLines -> ImportLines
 mergeImportLines = Map.unionWith mergeLines
   where
-    mergeLines a b = ImportLine (importModule a) (importTypes a `Set.union` importTypes b)
+    mergeLines a b = ImportLine (importModule a) (importAlias a) (importTypes a `Set.union` importTypes b)
 
 unlessM :: Monad m => m Bool -> m () -> m ()
 unlessM mbool action = mbool >>= flip unless action
diff --git a/src/Language/PureScript/Bridge/SumType.hs b/src/Language/PureScript/Bridge/SumType.hs
--- a/src/Language/PureScript/Bridge/SumType.hs
+++ b/src/Language/PureScript/Bridge/SumType.hs
@@ -55,12 +55,12 @@
 --   In order to get the type information we use a dummy variable of type 'Proxy' (YourType).
 mkSumType :: forall t. (Generic t, Typeable t, GDataConstructor (Rep t))
           => Proxy t -> SumType 'Haskell
-mkSumType p = SumType (mkTypeInfo p) constructors (Encode : Decode : Generic : maybeToList (nootype constructors))
+mkSumType p = SumType (mkTypeInfo p) constructors (Encode : Decode : EncodeJson : DecodeJson : Generic : maybeToList (nootype constructors))
   where
     constructors = gToConstructors (from (undefined :: t))
 
 -- | Purescript typeclass instances that can be generated for your Haskell types.
-data Instance = Encode | Decode | Generic | Newtype | Eq | Ord deriving (Eq, Show)
+data Instance = Encode | EncodeJson | Decode | DecodeJson | Generic | Newtype | Eq | Ord deriving (Eq, Show)
 
 -- | The Purescript typeclass `Newtype` might be derivable if the original
 -- Haskell type was a simple type wrapper.
@@ -85,7 +85,6 @@
                   , _sigValues      :: !(Either [TypeInfo lang] [RecordEntry lang])
                   } deriving (Show, Eq)
 
-
 data RecordEntry (lang :: Language) =
   RecordEntry { _recLabel :: !Text -- ^ e.g. `runState` for `State`
               , _recValue :: !(TypeInfo lang)
@@ -117,7 +116,6 @@
 instance (GRecordEntry a, GRecordEntry b) => GRecordEntry (a :*: b) where
   gToRecordEntries (_ :: (a :*: b) f) = gToRecordEntries (undefined :: a f)
                                      ++ gToRecordEntries (undefined :: b f)
-
 
 instance GRecordEntry U1 where
   gToRecordEntries _ = []
diff --git a/test/Spec.hs b/test/Spec.hs
--- a/test/Spec.hs
+++ b/test/Spec.hs
@@ -4,6 +4,7 @@
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE RankNTypes            #-}
+{-# LANGUAGE TypeApplications      #-}
 {-# LANGUAGE TypeSynonymInstances  #-}
 
 module Main where
@@ -11,6 +12,7 @@
 import           Data.Monoid                               ((<>))
 import           Data.Proxy
 import qualified Data.Text                                 as T
+import           Data.Word                                 (Word, Word64)
 import           Language.PureScript.Bridge
 import           Language.PureScript.Bridge.TypeParameters
 import           Language.PureScript.Bridge.CodeGenSwitches
@@ -25,8 +27,7 @@
 
 allTests :: Spec
 allTests = do
-  describe "buildBridge for purescript 0.12" $ do
-    let settings = purs_0_11_settings
+  describe "buildBridge for purescript 0.14" $ do
     it "tests with Int" $
       let bst = buildBridge defaultBridge (mkTypeInfo (Proxy :: Proxy Int))
           ti  = TypeInfo { _typePackage    = ""
@@ -51,12 +52,12 @@
                                       ]
                   }
                 ]
-                [Eq, Ord, Encode, Decode, Generic]
+                [Eq, Ord, Encode, Decode, EncodeJson, DecodeJson, Generic]
        in bst `shouldBe` st
     it "tests generation of for custom type Foo" $
      let prox = Proxy :: Proxy Foo
          recType = bridgeSumType (buildBridge defaultBridge) (order prox $ mkSumType prox)
-         recTypeText = sumTypeToText settings recType
+         recTypeText = sumTypeToText defaultSettings recType
          txt = T.stripEnd $
                T.unlines [ "data Foo ="
                          , "    Foo"
@@ -65,7 +66,11 @@
                          , ""
                          , "derive instance eqFoo :: Eq Foo"
                          , "derive instance ordFoo :: Ord Foo"
-                         , "derive instance genericFoo :: Generic Foo"
+                         , "instance encodeJsonFoo :: EncodeJson Foo where"
+                         , "  encodeJson = genericEncodeAeson Argonaut.defaultOptions"
+                         , "instance decodeJsonFoo :: DecodeJson Foo where"
+                         , "  decodeJson = genericDecodeAeson Argonaut.defaultOptions"
+                         , "derive instance genericFoo :: Generic Foo _"
                          , ""
                          , "--------------------------------------------------------------------------------"
                          , "_Foo :: Prism' Foo Unit"
@@ -92,18 +97,23 @@
     it "tests the generation of a whole (dummy) module" $
       let advanced = bridgeSumType (buildBridge defaultBridge) (mkSumType (Proxy :: Proxy (Bar A B M1 C)))
           modules = sumTypeToModule advanced Map.empty
-          m = head . map (moduleToText settings) . Map.elems $ modules
+          m = head . map (moduleToText defaultSettings) . Map.elems $ modules
           txt = T.unlines [ "-- File auto generated by purescript-bridge! --"
                           , "module TestData where"
                           , ""
+                          , "import Data.Argonaut.Aeson.Decode.Generic (genericDecodeAeson)"
+                          , "import Data.Argonaut.Aeson.Encode.Generic (genericEncodeAeson)"
+                          , "import Data.Argonaut.Aeson.Options as Argonaut"
+                          , "import Data.Argonaut.Decode.Class (class DecodeJson, class DecodeJsonField, decodeJson)"
+                          , "import Data.Argonaut.Encode.Class (class EncodeJson, encodeJson)"
                           , "import Data.Either (Either)"
-                          , "import Data.Generic (class Generic)"
+                          , "import Data.Generic.Rep (class Generic)"
                           , "import Data.Lens (Iso', Lens', Prism', lens, prism')"
                           , "import Data.Lens.Iso.Newtype (_Newtype)"
                           , "import Data.Lens.Record (prop)"
                           , "import Data.Maybe (Maybe, Maybe(..))"
                           , "import Data.Newtype (class Newtype)"
-                          , "import Data.Symbol (SProxy(SProxy))"
+                          , "import Type.Proxy (Proxy(Proxy))"
                           , ""
                           , "import Prelude"
                           , ""
@@ -115,7 +125,11 @@
                           , "      myMonadicResult :: m b"
                           , "    }"
                           , ""
-                          , "derive instance genericBar :: (Generic a, Generic b, Generic (m b)) => Generic (Bar a b m c)"
+                          , "instance encodeJsonBar :: (Generic a ra, EncodeJson a, Generic b rb, EncodeJson b, Generic (m b) rmb, EncodeJson (m b)) => EncodeJson (Bar a b m c) where"
+                          , "  encodeJson = genericEncodeAeson Argonaut.defaultOptions"
+                          , "instance decodeJsonBar :: (Generic a ra, DecodeJson a, DecodeJsonField a, Generic b rb, DecodeJson b, DecodeJsonField b, Generic (m b) rmb, DecodeJson (m b), DecodeJsonField (m b)) => DecodeJson (Bar a b m c) where"
+                          , "  decodeJson = genericDecodeAeson Argonaut.defaultOptions"
+                          , "derive instance genericBar :: (Generic a ra, Generic b rb, Generic (m b) rmb) => Generic (Bar a b m c) _"
                           , ""
                           , "--------------------------------------------------------------------------------"
                           , "_Bar1 :: forall a b m c. Prism' (Bar a b m c) (Maybe a)"
@@ -202,16 +216,16 @@
           recTypeOptics = recordOptics recType
           txt = T.unlines [
                             "a :: forall a b. Lens' (SingleRecord a b) a"
-                          , "a = _Newtype <<< prop (SProxy :: SProxy \"_a\")"
+                          , "a = _Newtype <<< prop (Proxy :: Proxy \"_a\")"
                           , ""
                           , "b :: forall a b. Lens' (SingleRecord a b) b"
-                          , "b = _Newtype <<< prop (SProxy :: SProxy \"_b\")"
+                          , "b = _Newtype <<< prop (Proxy :: Proxy \"_b\")"
                           , ""
                           ]
       in (barOptics <> recTypeOptics) `shouldBe` txt
     it "tests generation of newtypes for record data type" $
       let recType = bridgeSumType (buildBridge defaultBridge) (mkSumType (Proxy :: Proxy (SingleRecord A B)))
-          recTypeText = sumTypeToText settings recType
+          recTypeText = sumTypeToText defaultSettings recType
           txt = T.stripEnd $
                 T.unlines [ "newtype SingleRecord a b ="
                           , "    SingleRecord {"
@@ -220,7 +234,11 @@
                           , "    , c :: String"
                           , "    }"
                           , ""
-                          , "derive instance genericSingleRecord :: (Generic a, Generic b) => Generic (SingleRecord a b)"
+                          , "instance encodeJsonSingleRecord :: (Generic a ra, EncodeJson a, Generic b rb, EncodeJson b) => EncodeJson (SingleRecord a b) where"
+                          , "  encodeJson = genericEncodeAeson Argonaut.defaultOptions"
+                          , "instance decodeJsonSingleRecord :: (Generic a ra, DecodeJson a, DecodeJsonField a, Generic b rb, DecodeJson b, DecodeJsonField b) => DecodeJson (SingleRecord a b) where"
+                          , "  decodeJson = genericDecodeAeson Argonaut.defaultOptions"
+                          , "derive instance genericSingleRecord :: (Generic a ra, Generic b rb) => Generic (SingleRecord a b) _"
                           , "derive instance newtypeSingleRecord :: Newtype (SingleRecord a b) _"
                           , ""
                           , "--------------------------------------------------------------------------------"
@@ -228,22 +246,26 @@
                           , "_SingleRecord = _Newtype"
                           ,""
                           , "a :: forall a b. Lens' (SingleRecord a b) a"
-                          , "a = _Newtype <<< prop (SProxy :: SProxy \"_a\")"
+                          , "a = _Newtype <<< prop (Proxy :: Proxy \"_a\")"
                           , ""
                           , "b :: forall a b. Lens' (SingleRecord a b) b"
-                          , "b = _Newtype <<< prop (SProxy :: SProxy \"_b\")"
+                          , "b = _Newtype <<< prop (Proxy :: Proxy \"_b\")"
                           , ""
                           , "--------------------------------------------------------------------------------"
                           ]
       in recTypeText `shouldBe` txt
     it "tests generation of newtypes for haskell newtype" $
       let recType = bridgeSumType (buildBridge defaultBridge) (mkSumType (Proxy :: Proxy SomeNewtype))
-          recTypeText = sumTypeToText settings recType
+          recTypeText = sumTypeToText defaultSettings recType
           txt = T.stripEnd $
                 T.unlines [ "newtype SomeNewtype ="
                           , "    SomeNewtype Int"
                           , ""
-                          , "derive instance genericSomeNewtype :: Generic SomeNewtype"
+                          , "instance encodeJsonSomeNewtype :: EncodeJson SomeNewtype where"
+                          , "  encodeJson = genericEncodeAeson Argonaut.defaultOptions"
+                          , "instance decodeJsonSomeNewtype :: DecodeJson SomeNewtype where"
+                          , "  decodeJson = genericDecodeAeson Argonaut.defaultOptions"
+                          , "derive instance genericSomeNewtype :: Generic SomeNewtype _"
                           , "derive instance newtypeSomeNewtype :: Newtype SomeNewtype _"
                           , ""
                           , "--------------------------------------------------------------------------------"
@@ -254,12 +276,16 @@
       in recTypeText `shouldBe` txt
     it "tests generation of newtypes for haskell data type with one argument" $
       let recType = bridgeSumType (buildBridge defaultBridge) (mkSumType (Proxy :: Proxy SingleValueConstr))
-          recTypeText = sumTypeToText settings recType
+          recTypeText = sumTypeToText defaultSettings recType
           txt = T.stripEnd $
                 T.unlines [ "newtype SingleValueConstr ="
                           , "    SingleValueConstr Int"
                           , ""
-                          , "derive instance genericSingleValueConstr :: Generic SingleValueConstr"
+                          , "instance encodeJsonSingleValueConstr :: EncodeJson SingleValueConstr where"
+                          , "  encodeJson = genericEncodeAeson Argonaut.defaultOptions"
+                          , "instance decodeJsonSingleValueConstr :: DecodeJson SingleValueConstr where"
+                          , "  decodeJson = genericDecodeAeson Argonaut.defaultOptions"
+                          , "derive instance genericSingleValueConstr :: Generic SingleValueConstr _"
                           , "derive instance newtypeSingleValueConstr :: Newtype SingleValueConstr _"
                           , ""
                           , "--------------------------------------------------------------------------------"
@@ -270,12 +296,16 @@
       in recTypeText `shouldBe` txt
     it "tests generation for haskell data type with one constructor, two arguments" $
       let recType = bridgeSumType (buildBridge defaultBridge) (mkSumType (Proxy :: Proxy SingleProduct))
-          recTypeText = sumTypeToText settings recType
+          recTypeText = sumTypeToText defaultSettings recType
           txt = T.stripEnd $
                 T.unlines [ "data SingleProduct ="
                           , "    SingleProduct String Int"
                           , ""
-                          , "derive instance genericSingleProduct :: Generic SingleProduct"
+                          , "instance encodeJsonSingleProduct :: EncodeJson SingleProduct where"
+                          , "  encodeJson = genericEncodeAeson Argonaut.defaultOptions"
+                          , "instance decodeJsonSingleProduct :: DecodeJson SingleProduct where"
+                          , "  decodeJson = genericDecodeAeson Argonaut.defaultOptions"
+                          , "derive instance genericSingleProduct :: Generic SingleProduct _"
                           , ""
                           , "--------------------------------------------------------------------------------"
                           , "_SingleProduct :: Prism' SingleProduct { a :: String, b :: Int }"
@@ -291,8 +321,8 @@
           recTypeOptics = recordOptics recType
       in recTypeOptics `shouldBe` "" -- No record optics for multi-constructors
 
-  describe "buildBridge without lens-code-gen for purescript 0.11" $ do
-    let settings = getSettings (noLenses <> useGen)
+  describe "buildBridge without lens-code-gen and argonaut-codecs" $ do
+    let settings = getSettings (noLenses <> useGen <> noArgonautCodecs)
     it "tests generation of for custom type Foo" $
       let proxy = Proxy :: Proxy Foo
           recType = bridgeSumType (buildBridge defaultBridge) (order proxy $ mkSumType proxy)
@@ -378,8 +408,8 @@
       in recTypeText `shouldBe` txt
 
 
-  describe "buildBridge without lens-code-gen and generics-rep" $ do
-    let settings = getSettings (noLenses <> useGenRep)
+  describe "buildBridge without lens-code-gen, generics-rep, and argonaut-codecs" $ do
+    let settings = getSettings (noLenses <> useGenRep <> noArgonautCodecs)
     it "tests generation of for custom type Foo" $
       let proxy = Proxy :: Proxy Foo
           recType = bridgeSumType (buildBridge defaultBridge) (order proxy $ mkSumType proxy)
@@ -464,3 +494,42 @@
                           ]
       in recTypeText `shouldBe` txt
  
+  describe "tests bridging Haskells Data.Word to PureScripts Data.Word from purescript-word" $ do
+    describe "moduleToText" $
+      it "should contain the right import and datatype" $ do
+        let settings = getSettings (noLenses <> useGen <> noArgonautCodecs)
+            createModuleText :: SumType 'Haskell -> T.Text
+            createModuleText sumType =
+              let bridge = buildBridge defaultBridge
+                  modules = sumTypeToModule (bridgeSumType bridge sumType) Map.empty
+               in head . map (moduleToText settings) . Map.elems $ modules
+            expectedText =
+              T.unlines
+                [ "-- File auto generated by purescript-bridge! --"
+                , "module TestData where"
+                , ""
+                , "import Data.Generic (class Generic)"
+                , "import Data.Maybe (Maybe(..))"
+                , "import Data.Newtype (class Newtype)"
+                , "import Data.Word (Word64)"
+                , ""
+                , "import Prelude"
+                , ""
+                , "newtype Simple Word64 ="
+                , "    Simple Word64"
+                , ""
+                , "derive instance genericSimple :: Generic Word64 => Generic (Simple Word64)"
+                , "derive instance newtypeSimple :: Newtype (Simple Word64) _"
+                , ""
+                ]
+        createModuleText (mkSumType (Proxy @(Simple Word64))) `shouldBe`  expectedText
+    describe "buildBridge" $
+      it "should create the correct type information for Word" $ do
+        let bst = buildBridge defaultBridge (mkTypeInfo (Proxy @Word))
+            ti  = TypeInfo { _typePackage    = "purescript-word"
+                         , _typeModule     = "Data.Word"
+                         , _typeName       = "Word"
+                         , _typeParameters = []}
+         in bst `shouldBe` ti
+
+
diff --git a/test/TestData.hs b/test/TestData.hs
--- a/test/TestData.hs
+++ b/test/TestData.hs
@@ -30,6 +30,8 @@
    haskType ^== mkTypeInfo (Proxy :: Proxy String)
    return psString
 
+data Simple a = Simple a deriving (Generic, Typeable, Show)
+
 data Foo = Foo
          | Bar Int
          | FooBar Int Text