diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,9 @@
+# 0.13.0.0
+
+This release drops support for the old API. To upgrade to the new API,
+Users should first upgrade to the latest 0.12.x version, switch their
+code to use the new API, and then upgrade to this version.
+
 # 0.12.1.0
 
 This release backports some fixes and minor features in the new API.
diff --git a/bench/Main.hs b/bench/Main.hs
--- a/bench/Main.hs
+++ b/bench/Main.hs
@@ -3,12 +3,13 @@
 module Main (main) where
 
 
-import qualified Capnp                     as C
+import qualified Capnp.New                 as C
 import qualified Capnp.Untyped             as U
 import           Control.DeepSeq           (NFData(..))
 import           Control.Monad             (unless)
 import           Criterion.Main
 import qualified Data.ByteString           as BS
+import           Data.Mutable              (thaw)
 import           System.Exit               (ExitCode(..))
 import qualified System.Process.ByteString as PB
 
@@ -46,7 +47,7 @@
             C.canonicalize root
         , env
             (C.evalLimitT maxBound $ do
-                mutMsg <- C.thaw msg
+                mutMsg <- thaw msg
                 newMsg <- C.newMessage Nothing
                 pure (mutMsg, newMsg)
             )
diff --git a/capnp.cabal b/capnp.cabal
--- a/capnp.cabal
+++ b/capnp.cabal
@@ -1,6 +1,6 @@
 cabal-version:            2.2
 name:                     capnp
-version:                  0.12.1.0
+version:                  0.13.0.0
 category:                 Data, Serialization, Network, Rpc
 copyright:                2016-2021 haskell-capnp contributors (see CONTRIBUTORS file).
 author:                   Ian Denhardt
@@ -34,7 +34,6 @@
   , core-schema/capnp/compat/json.capnp
   , core-schema/capnp/c++.capnp
   , scripts/format.sh
-  , scripts/gen-basic-instances.hs
   , scripts/hlint.sh
   , scripts/README.md
   , scripts/regen.sh
@@ -93,74 +92,43 @@
       -- generated code:
       gen/lib
     exposed-modules:
-        Capnp
-      , Capnp.Address
-      , Capnp.Basics
-      , Capnp.Basics.Pure
+        Capnp.Address
       , Capnp.Bits
       , Capnp.Canonicalize
-      , Capnp.Classes
       , Capnp.New
       , Capnp.New.Accessors
       , Capnp.New.Basics
       , Capnp.New.Classes
       , Capnp.New.Constraints
+      , Capnp.New.Rpc.Common
       , Capnp.New.Rpc.Server
       , Capnp.Convert
       , Capnp.Errors
       , Capnp.Fields
-      , Capnp.GenHelpers
-      , Capnp.GenHelpers.Pure
-      , Capnp.GenHelpers.Rpc
       , Capnp.GenHelpers.New
+      , Capnp.GenHelpers.New.Rpc
       , Capnp.IO
       , Capnp.Message
       , Capnp.Pointer
       , Capnp.Untyped
-      , Capnp.Untyped.Pure
       , Capnp.Repr
       , Capnp.Repr.Methods
       , Capnp.Repr.Parsed
       , Capnp.TraversalLimit
       , Capnp.Rpc
       , Capnp.Rpc.Promise
-      , Capnp.Rpc.Invoke
       , Capnp.Rpc.Untyped
       , Capnp.Rpc.Errors
       , Capnp.Rpc.Transport
       , Capnp.Rpc.Server
       , Capnp.Tutorial
 
-      , Capnp.GenHelpers.ReExports
-      , Capnp.GenHelpers.ReExports.Supervisors
-      , Capnp.GenHelpers.ReExports.Data.Default
-      , Capnp.GenHelpers.ReExports.Data.Text
-      , Capnp.GenHelpers.ReExports.Data.ByteString
-      , Capnp.GenHelpers.ReExports.Data.Vector
-      , Capnp.GenHelpers.ReExports.Control.Concurrent.STM
-      , Capnp.GenHelpers.ReExports.Control.Monad.STM.Class
-
       , Data.Mutable
 
       , Capnp.Gen
       , Capnp.Gen.Capnp
 
       -- BEGIN GENERATED SCHEMA MODULES
-      , Capnp.Gen.Capnp.Cxx.Pure
-      , Capnp.Gen.Capnp.Compat.Json.Pure
-      , Capnp.Gen.Capnp.Persistent.Pure
-      , Capnp.Gen.Capnp.Rpc.Pure
-      , Capnp.Gen.Capnp.RpcTwoparty.Pure
-      , Capnp.Gen.Capnp.Schema.Pure
-      , Capnp.Gen.Capnp.Stream.Pure
-      , Capnp.Gen.Capnp.Cxx
-      , Capnp.Gen.Capnp.Compat.Json
-      , Capnp.Gen.Capnp.Persistent
-      , Capnp.Gen.Capnp.Rpc
-      , Capnp.Gen.Capnp.RpcTwoparty
-      , Capnp.Gen.Capnp.Schema
-      , Capnp.Gen.Capnp.Stream
-
       , Capnp.Gen.Capnp.Cxx.New
       , Capnp.Gen.Capnp.Compat.Json.New
       , Capnp.Gen.Capnp.Persistent.New
@@ -169,13 +137,6 @@
       , Capnp.Gen.Capnp.Schema.New
       , Capnp.Gen.Capnp.Stream.New
 
-      , Capnp.Gen.ById.Xbdf87d7bb8304e81.Pure
-      , Capnp.Gen.ById.X8ef99297a43a5e34.Pure
-      , Capnp.Gen.ById.Xb8630836983feed7.Pure
-      , Capnp.Gen.ById.Xb312981b2552a250.Pure
-      , Capnp.Gen.ById.Xa184c7885cdaf2a1.Pure
-      , Capnp.Gen.ById.Xa93fc509624c72d9.Pure
-      , Capnp.Gen.ById.X86c366a91393f3f8.Pure
       , Capnp.Gen.ById.Xbdf87d7bb8304e81.New
       , Capnp.Gen.ById.X8ef99297a43a5e34.New
       , Capnp.Gen.ById.Xb8630836983feed7.New
@@ -183,22 +144,13 @@
       , Capnp.Gen.ById.Xa184c7885cdaf2a1.New
       , Capnp.Gen.ById.Xa93fc509624c72d9.New
       , Capnp.Gen.ById.X86c366a91393f3f8.New
-      , Capnp.Gen.ById.Xbdf87d7bb8304e81
-      , Capnp.Gen.ById.X8ef99297a43a5e34
-      , Capnp.Gen.ById.Xb8630836983feed7
-      , Capnp.Gen.ById.Xb312981b2552a250
-      , Capnp.Gen.ById.Xa184c7885cdaf2a1
-      , Capnp.Gen.ById.Xa93fc509624c72d9
-      , Capnp.Gen.ById.X86c366a91393f3f8
       -- END GENERATED SCHEMA MODULES
     other-modules:
         Internal.AppendVec
       , Internal.SnocList
       , Internal.Rc
       , Internal.TCloseQ
-      , Internal.Gen.Instances
       , Internal.BuildPure
-      , Codec.Capnp
     -- other-extensions:
     build-depends:
         hashable                          >= 1.2.7 && <1.4
@@ -228,17 +180,11 @@
     , IR.Common
     , IR.Stage1
     , IR.Flat
-    , IR.Pure
-    , IR.Raw
     , IR.Haskell
     , Trans.CgrToStage1
     , Trans.Stage1ToFlat
-    , Trans.FlatToRaw
-    , Trans.FlatToPure
     , Trans.FlatToNew
     , Trans.ToHaskellCommon
-    , Trans.PureToHaskell
-    , Trans.RawToHaskell
     , Trans.NewToHaskell
     , Trans.HaskellToText
     , Check
@@ -272,35 +218,19 @@
       , Examples.Rpc.CalculatorServer
 
       -- Generated code for examples/calculator.capnp
-      , Capnp.Gen.Calculator
-      , Capnp.Gen.Calculator.Pure
       , Capnp.Gen.Calculator.New
-      , Capnp.Gen.ById.X85150b117366d14b
-      , Capnp.Gen.ById.X85150b117366d14b.Pure
       , Capnp.Gen.ById.X85150b117366d14b.New
 
       -- Generated code for examples/echo.capnp
-      , Capnp.Gen.Echo
-      , Capnp.Gen.Echo.Pure
       , Capnp.Gen.Echo.New
-      , Capnp.Gen.ById.Xd0a87f36fa0182f5
-      , Capnp.Gen.ById.Xd0a87f36fa0182f5.Pure
       , Capnp.Gen.ById.Xd0a87f36fa0182f5.New
 
       -- generated from tests/data/aircraft.capnp
-      , Capnp.Gen.Aircraft
-      , Capnp.Gen.Aircraft.Pure
       , Capnp.Gen.Aircraft.New
-      , Capnp.Gen.ById.X832bcc6686a26d56
-      , Capnp.Gen.ById.X832bcc6686a26d56.Pure
       , Capnp.Gen.ById.X832bcc6686a26d56.New
 
       -- generated from tests/data/generics.capnp
-      , Capnp.Gen.Generics
-      , Capnp.Gen.Generics.Pure
       , Capnp.Gen.Generics.New
-      , Capnp.Gen.ById.Xb6421fb8e478d144
-      , Capnp.Gen.ById.Xb6421fb8e478d144.Pure
       , Capnp.Gen.ById.Xb6421fb8e478d144.New
 
       -- Actual tests:
diff --git a/cmd/capnpc-haskell/IR/New.hs b/cmd/capnpc-haskell/IR/New.hs
--- a/cmd/capnpc-haskell/IR/New.hs
+++ b/cmd/capnpc-haskell/IR/New.hs
@@ -13,6 +13,7 @@
         { fileId   :: !Word64
         , decls    :: [Decl]
         , fileName :: FilePath
+        , usesRpc  :: !Bool
         }
 
 data Decl
diff --git a/cmd/capnpc-haskell/IR/Pure.hs b/cmd/capnpc-haskell/IR/Pure.hs
deleted file mode 100644
--- a/cmd/capnpc-haskell/IR/Pure.hs
+++ /dev/null
@@ -1,86 +0,0 @@
-{-# LANGUAGE DuplicateRecordFields #-}
-module IR.Pure where
-
-import Data.Word
-
-import qualified IR.Common as C
-import qualified IR.Name   as Name
-
-type Brand = C.ListBrand Name.CapnpQ
-
-data File = File
-    { fileId        :: !Word64
-    , fileName      :: FilePath
-    , decls         :: [Decl]
-    , reExportEnums :: [Name.LocalQ]
-    -- ^ A list of enums that we should re-export from this module.
-    , usesRpc       :: !Bool
-    -- ^ Whether or not the module uses rpc features. If not, we skip
-    -- the rpc related imports. This is mainly important to avoid a
-    -- cyclic dependency with rpc.capnp.
-    }
-
-data Decl
-    = DataDecl Data
-    | ConstDecl Constant
-    | IFaceDecl Interface
-
-data Data = Data
-    { typeName   :: Name.LocalQ
-    , typeParams :: [Name.UnQ]
-    , firstClass :: !Bool
-    -- ^ Whether this is a "first class" type, i.e. it is a type in the
-    -- capnproto sense, rather than an auxiliary type defined for a group
-    -- or an anonymous union.
-    --
-    -- Note that this *can* be set for unions, if they subsume the whole
-    -- struct, since in that case we collapse the two types in the
-    -- high-level API.
-    , cerialName :: Name.LocalQ
-    -- ^ The name of the type our 'Cerial' should be. This will only be
-    -- different from typeName if we're an anonymous union in a struct
-    -- that also has other fields; in this case our Cerial should be
-    -- the same as our parent struct.
-    , def        :: DataDef
-    }
-
-data DataDef
-    = Sum [Variant]
-    | Product [Field]
-
-data Constant = Constant
-    { name  :: Name.LocalQ
-    , value :: C.Value Brand Name.CapnpQ
-    }
-
-data Interface = IFace
-    { name        :: Name.CapnpQ
-    , typeParams  :: [C.TypeParamRef Name.CapnpQ]
-    , interfaceId :: !Word64
-    , methods     :: [Method]
-    , supers      :: [(Interface, Brand)]
-    -- ^ Immediate superclasses
-    , ancestors   :: [(Interface, Brand)]
-    -- ^ All ancestors, including 'supers'.
-    }
-
--- TODO(cleanup): this same type exists in IR.Flat; it doesn't make sense for
--- IR.Common, but we should factor this out.
-data Method = Method
-    { name       :: Name.UnQ
-    , paramType  :: C.CompositeType Brand Name.CapnpQ
-    , resultType :: C.CompositeType Brand Name.CapnpQ
-    }
-
-data Field = Field
-    { name  :: Name.UnQ
-    -- ^ The name of the field.
-
-    , type_ :: C.Type Brand Name.CapnpQ
-    -- ^ The type of the field.
-    }
-
-data Variant = Variant
-    { name :: Name.LocalQ
-    , arg  :: Maybe (C.Type Brand Name.CapnpQ)
-    }
diff --git a/cmd/capnpc-haskell/IR/Raw.hs b/cmd/capnpc-haskell/IR/Raw.hs
deleted file mode 100644
--- a/cmd/capnpc-haskell/IR/Raw.hs
+++ /dev/null
@@ -1,122 +0,0 @@
--- IR for a high-level representation of the low-level API modules.
---
--- This talks about things like getters, setters, wrapper types for structs,
--- etc. It's still not at the level of detail of actual Haskell, but encodes
--- the constructs to be generated, as opposed to the declarative description
--- of the schema.
-{-# LANGUAGE DuplicateRecordFields #-}
-module IR.Raw (File(..), Decl(..), Variant(..), TagSetter(..), NewFnType(..), tagOffsetToDataLoc) where
-
-import Data.Word
-
-import qualified IR.Common as Common
-import qualified IR.Name   as Name
-
-type Brand = Common.ListBrand Name.CapnpQ
-
-data File = File
-    { fileId   :: !Word64
-    , fileName :: FilePath
-    , decls    :: [Decl]
-    }
-    deriving(Show, Eq)
-
-data Decl
-    -- | Define a newtype wrapper around a struct. This also defines
-    -- some instances of type classes that exist for all such wrappers.
-    = StructWrapper
-        { typeCtor   :: Name.LocalQ
-        , typeParams :: [Name.UnQ]
-        }
-    -- | Define instances of several type classes which should only
-    -- exist for "real" structs, i.e. not groups.
-    | StructInstances
-        { typeCtor      :: Name.LocalQ
-        -- ^ The type constructor for the type to generate instances for.
-        , typeParams    :: [Name.UnQ]
-
-        -- Needed for some instances:
-        , dataWordCount :: !Word16
-        , pointerCount  :: !Word16
-        }
-    | InterfaceWrapper
-        { typeCtor   :: Name.LocalQ
-        , typeParams :: [Name.UnQ]
-        }
-    | UnionVariant
-        { parentTypeCtor :: Name.LocalQ
-        -- ^ The type constructor of the parent, i.e. the enclosing struct.
-        -- we can derive the type constructor for the union proper from this,
-        -- and it is useful to have for other things (like unknown' variants).
-        , tagOffset      :: !Word32
-        , typeParams     :: [Name.UnQ]
-        , unionDataCtors :: [Variant]
-        }
-    | Enum
-        { typeCtor  :: Name.LocalQ
-        , dataCtors :: [Name.LocalQ]
-        }
-    | Getter -- get_* function
-        { fieldName     :: Name.LocalQ
-        , containerType :: Name.LocalQ
-        , typeParams    :: [Name.UnQ]
-        , fieldLocType  :: Common.FieldLocType Brand Name.CapnpQ
-        }
-    | Setter -- set_* function
-        { fieldName     :: Name.LocalQ
-        , containerType :: Name.LocalQ
-        , typeParams    :: [Name.UnQ]
-        , fieldLocType  :: Common.FieldLocType Brand Name.CapnpQ
-
-        , tag           :: Maybe TagSetter
-        -- ^ Info for setting the tag, if this is a union.
-        }
-    | HasFn -- has_* function
-        { fieldName     :: Name.LocalQ
-        , containerType :: Name.LocalQ
-        , typeParams    :: [Name.UnQ]
-        , ptrIndex      :: !Word16
-        }
-    | NewFn -- new_* function
-        { fieldName     :: Name.LocalQ
-        , containerType :: Name.LocalQ
-        , typeParams    :: [Name.UnQ]
-        , fieldLocType  :: Common.FieldLocType Brand Name.CapnpQ
-
-        , newFnType     :: NewFnType
-        }
-    | Constant
-        { name  :: Name.LocalQ
-        , value :: Common.Value Brand Name.CapnpQ
-        }
-    deriving(Show, Eq)
-
-data NewFnType
-    = NewList
-    | NewText
-    | NewData
-    | NewStruct
-    deriving(Show, Eq)
-
-data TagSetter = TagSetter
-    { tagOffset :: !Word32
-    , tagValue  :: !Word16
-    }
-    deriving(Show, Eq)
-
--- | Convert a tag offset (as in the 'tagOffset' field of 'TagSetter') to a
--- corresponding 'Common.DataLoc', with the default value set to zero.
-tagOffsetToDataLoc :: Word32 -> Common.DataLoc
-tagOffsetToDataLoc tagOffset =
-    Common.DataLoc
-        { dataIdx = fromIntegral tagOffset `div` 4
-        , dataOff = (fromIntegral tagOffset `mod` 4) * 16
-        , dataDef = 0
-        }
-
-data Variant = Variant
-    { name     :: Name.LocalQ
-    , tagValue :: !Word16
-    , locType  :: Common.FieldLocType Brand Name.CapnpQ
-    }
-    deriving(Show, Eq)
diff --git a/cmd/capnpc-haskell/Main.hs b/cmd/capnpc-haskell/Main.hs
--- a/cmd/capnpc-haskell/Main.hs
+++ b/cmd/capnpc-haskell/Main.hs
@@ -10,21 +10,16 @@
 import qualified Data.Text.Lazy    as LT
 import qualified Data.Text.Lazy.IO as TIO
 
-import Capnp                      (defaultLimit, getParsed)
 import Capnp.Gen.Capnp.Schema.New (CodeGeneratorRequest)
-import Capnp.Repr.Parsed          (Parsed)
+import Capnp.New                  (Parsed, defaultLimit, getParsed)
 
 import qualified Check
 import qualified IR.Flat             as Flat
 import qualified IR.Haskell          as Haskell
 import qualified Trans.CgrToStage1
 import qualified Trans.FlatToNew
-import qualified Trans.FlatToPure
-import qualified Trans.FlatToRaw
 import qualified Trans.HaskellToText
 import qualified Trans.NewToHaskell
-import qualified Trans.PureToHaskell
-import qualified Trans.RawToHaskell
 import qualified Trans.Stage1ToFlat
 
 main :: IO ()
@@ -42,12 +37,7 @@
     let flat =
             Trans.Stage1ToFlat.cgrToCgr $
             Trans.CgrToStage1.cgrToCgr cgr
-        modules =
-            concatMap ($ flat)
-                [ handleFlatRaw
-                , handleFlatPure
-                , handleFlatNew
-                ]
+        modules = handleFlatNew flat
     in
     map
         (\mod ->
@@ -57,16 +47,7 @@
         )
         modules
 
-handleFlatPure, handleFlatRaw, handleFlatNew :: Flat.CodeGenReq -> [Haskell.Module]
-
-handleFlatPure =
-    concatMap Trans.PureToHaskell.fileToModules
-    . Trans.FlatToPure.cgrToFiles
-
-handleFlatRaw =
-    concatMap Trans.RawToHaskell.fileToModules
-    . Trans.FlatToRaw.cgrToFiles
-
+handleFlatNew :: Flat.CodeGenReq -> [Haskell.Module]
 handleFlatNew =
     concatMap Trans.NewToHaskell.fileToModules
     . Trans.FlatToNew.cgrToFiles
diff --git a/cmd/capnpc-haskell/Trans/CgrToStage1.hs b/cmd/capnpc-haskell/Trans/CgrToStage1.hs
--- a/cmd/capnpc-haskell/Trans/CgrToStage1.hs
+++ b/cmd/capnpc-haskell/Trans/CgrToStage1.hs
@@ -17,8 +17,8 @@
 import qualified Data.Text       as T
 import qualified Data.Vector     as V
 
-import Capnp.Classes     (toWord)
 import Capnp.Fields      (HasUnion(..))
+import Capnp.New.Classes (toWord)
 import Capnp.Repr.Parsed (Parsed)
 
 import qualified Capnp.Gen.Capnp.Schema.New as Schema
diff --git a/cmd/capnpc-haskell/Trans/FlatToNew.hs b/cmd/capnpc-haskell/Trans/FlatToNew.hs
--- a/cmd/capnpc-haskell/Trans/FlatToNew.hs
+++ b/cmd/capnpc-haskell/Trans/FlatToNew.hs
@@ -21,6 +21,7 @@
         { fileId
         , fileName
         , decls = concatMap nodeToDecls nodes
+        , usesRpc = not $ null [ () | Flat.Node{ union_ = Flat.Interface{} } <- nodes ]
         }
 
 mapTypes :: (Bifunctor p, Functor f) => p (f Flat.Node) Flat.Node -> p (f Name.CapnpQ) Name.CapnpQ
diff --git a/cmd/capnpc-haskell/Trans/FlatToPure.hs b/cmd/capnpc-haskell/Trans/FlatToPure.hs
deleted file mode 100644
--- a/cmd/capnpc-haskell/Trans/FlatToPure.hs
+++ /dev/null
@@ -1,227 +0,0 @@
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE NamedFieldPuns        #-}
-{-# LANGUAGE OverloadedStrings     #-}
-module Trans.FlatToPure (cgrToFiles) where
-
-import Data.Word
-
-import qualified Data.Map.Strict as M
-import qualified Data.Set        as S
-
-import qualified IR.Common as C
-import qualified IR.Flat   as Flat
-import qualified IR.Name   as Name
-import qualified IR.Pure   as Pure
-
-import Control.Monad.State (State, evalState, get, put)
-
-type IFaceMap = M.Map Word64 Pure.Interface
-
--- | Because of pervasive use of DuplicateRecordFields, we can't easily
--- just use the auto-generated `name` accessor function... so we define
--- this wrapper.
-nodeName :: Flat.Node -> Name.CapnpQ
-nodeName Flat.Node{name} = name
-
-cgrToFiles :: Flat.CodeGenReq -> [Pure.File]
-cgrToFiles Flat.CodeGenReq{allNodes, reqFiles} =
-    map oneFile reqFiles
-  where
-    allInterfaces = concatMap (convertInterface ifaceMap) allNodes
-    ifaceMap =
-        M.map
-            (\iface -> iface { Pure.ancestors = collectAncestors iface })
-            $ M.fromList
-                [ (interfaceId, iface)
-                | iface@Pure.IFace{interfaceId} <- allInterfaces
-                ]
-    oneFile Flat.File{nodes, fileId, fileName} =
-        Pure.File
-            { fileId
-            , fileName
-            , decls = concatMap (nodeToDecls ifaceMap) nodes
-            , reExportEnums = concatMap nodeToReExports nodes
-            , usesRpc = not $ null [ () | Flat.Node{ union_ = Flat.Interface{} } <- nodes ]
-            }
-
-convertInterface :: IFaceMap -> Flat.Node -> [Pure.Interface]
-convertInterface
-    ifaceMap
-    Flat.Node
-        { name
-        , typeParams
-        , nodeId
-        , union_ = Flat.Interface{ methods, supers }
-        }
-    =
-    let result =
-            Pure.IFace
-                { name
-                , typeParams = [ param { C.paramScope = name } | param <- typeParams ]
-                , interfaceId = nodeId
-                , methods =
-                    [ Pure.Method
-                        { name
-                        , paramType = C.bothMap nodeName paramType
-                        , resultType = C.bothMap nodeName resultType
-                        }
-                    | Flat.Method{name, paramType, resultType} <- methods ]
-                , supers =
-                    map
-                        (\(C.InterfaceType Flat.Node{nodeId} brand) ->
-                            ( ifaceMap M.! nodeId
-                            , fmap nodeName brand
-                            )
-                        )
-                        supers
-                , ancestors = collectAncestors result -- See Note [Ancestors]
-                }
-    in
-    [result]
-convertInterface _ _ = []
-
--- | Collect the of the ancestors of an interface, not including itself. Avoids using
--- the 'ancestors' field, as this is used to compute that field in the first place.
--- See Note [Ancestors]
-collectAncestors :: Pure.Interface -> [(Pure.Interface, Pure.Brand)]
-collectAncestors Pure.IFace{supers} =
-    concat $ evalState (traverse go supers) S.empty
-  where
-    go :: (Pure.Interface, Pure.Brand) -> State (S.Set Word64) [(Pure.Interface, Pure.Brand)]
-    go (iface@Pure.IFace{interfaceId, supers}, brand) = do
-        seen <- get
-        if interfaceId `S.member` seen then
-            pure []
-            else (do
-                put (S.insert interfaceId seen)
-                xs <- concat <$> traverse go supers
-                pure $ (iface, brand) : xs
-            )
-
-nodeToReExports :: Flat.Node -> [Name.LocalQ]
-nodeToReExports Flat.Node{name=Name.CapnpQ{local}, union_=Flat.Enum _} = [ local ]
-nodeToReExports _ = []
-
-unionToDecl :: Bool -> Name.LocalQ -> Name.LocalQ -> [Name.UnQ] -> [Flat.Variant] -> Pure.Decl
-unionToDecl firstClass cerialName local typeParams variants =
-    Pure.DataDecl Pure.Data
-        { typeName = local
-        , typeParams
-        , cerialName
-        , def = Pure.Sum
-            [ Pure.Variant
-                { name = variantName
-                , arg = case fieldLocType of
-                    C.VoidField ->
-                        -- If the argument is void, just have no argument.
-                        Nothing
-                    _ ->
-                        Just (Pure.type_ (fieldToField field))
-                }
-            | Flat.Variant
-                { field=field@Flat.Field
-                    { fieldName=Name.CapnpQ{local=variantName}
-                    , fieldLocType
-                    }
-                } <- variants
-            ]
-        , firstClass
-        }
-
-nodeToDecls :: IFaceMap -> Flat.Node -> [Pure.Decl]
-nodeToDecls ifaceMap Flat.Node{name=name@Name.CapnpQ{local}, nodeId, union_, typeParams} =
-  let typeParams' = map C.paramName typeParams in
-  case union_ of
-    Flat.Enum _ ->
-        -- Don't need to do anything here, since we're just re-exporting the
-        -- stuff from the raw module.
-        []
-    Flat.Interface{} ->
-        [ Pure.IFaceDecl (ifaceMap M.! nodeId) ]
-    Flat.Struct{ isGroup, fields=[], union=Just Flat.Union{variants}} ->
-        -- It's just one big union; skip the outer struct wrapper and make it
-        -- a top-level sum type.
-        [ unionToDecl (not isGroup) local local typeParams' variants ]
-    -- Flat.Struct{ isGroup=True, union=Nothing } -> [] -- See Note [Collapsing Groups]
-    Flat.Struct{ isGroup, fields, union } ->
-        Pure.DataDecl Pure.Data
-            { typeName = local
-            , typeParams = typeParams'
-            , cerialName = local
-            , def = Pure.Product $
-                map fieldToField fields
-                ++ case union of
-                    Nothing ->
-                        []
-                    Just _ ->
-                        [ Pure.Field
-                            { name = "union'"
-                            , type_ = C.CompositeType $ C.StructType
-                                (Name.mkSub name "")
-                                (C.ListBrand $
-                                    map
-                                        (C.PtrParam . fmap nodeName)
-                                        typeParams
-                                )
-                            }
-                        ]
-            , firstClass = not isGroup
-            }
-        : case union of
-            Just Flat.Union{variants} ->
-                -- Also make a type that's just the union, but give it the
-                -- same cerialName:
-                [ unionToDecl False local (Name.mkSub local "") typeParams' variants ]
-            Nothing ->
-                []
-    Flat.Constant { value } ->
-        [ Pure.ConstDecl Pure.Constant
-            { name = local
-            , value = C.bothMap nodeName value
-            }
-        ]
-    Flat.Other -> []
-
-fieldToField :: Flat.Field -> Pure.Field
-fieldToField Flat.Field{fieldName, fieldLocType} = Pure.Field
-    { name = Name.getUnQ fieldName
-    , type_ = C.bothMap nodeName (C.fieldType fieldLocType)
-    }
-
--- Note [Collapsing Groups]
--- ========================
---
--- If the argument to a union data constructor is a group, then the fields
--- never exist on their own, so it makes for a nicer API to just collapse
--- the fields directly into the variant, rather than creating an auxiliary
--- struct type.
---
--- However, this is only safe to do if the group does not itself have an
--- anonymous union. The reason for this is that otherwise we could end up
--- with two variants with a field "union'" but different types, which the
--- compiler will reject.
---
--- So the rule is, if a Field.Struct node is a group, and it does not itself
--- have an anonymous union:
---
--- 1. Don't generate a type for it.
--- 2. Collapse its fields into the data constructor for the union.
---
--- Note that we actually depend on (1) to avoid name collisions, since
--- otherwise both the data constructor for the anonymous union and the
--- data constructor for the group will be the same.
-
-
--- Note [Ancestors]
--- ================
---
--- When constructing a Pure.Interface, we need to fill in both the immediate
--- superclasses and the full transitive list of ancestors. Strictly speaking
--- the latter is redundant and can be computed from the former -- which is
--- what we do, but we store it so that the PureToHaskell phase doesn't need to
--- worry about it.
---
--- The way we compute this is a bit subtle, in that it involves tying the knot;
--- The 'collectAncestors' function expects the interface as an argument, and
--- computes the correct value of ancestors field without reading it. We then
--- use this function when creating the interface value in the first place.
diff --git a/cmd/capnpc-haskell/Trans/FlatToRaw.hs b/cmd/capnpc-haskell/Trans/FlatToRaw.hs
deleted file mode 100644
--- a/cmd/capnpc-haskell/Trans/FlatToRaw.hs
+++ /dev/null
@@ -1,217 +0,0 @@
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE NamedFieldPuns        #-}
-{-# LANGUAGE OverloadedStrings     #-}
-module Trans.FlatToRaw (cgrToFiles) where
-
-import qualified IR.Common as C
-import qualified IR.Flat   as Flat
-import qualified IR.Name   as Name
-import qualified IR.Raw    as Raw
-
-cgrToFiles :: Flat.CodeGenReq -> [Raw.File]
-cgrToFiles Flat.CodeGenReq{reqFiles} = map fileToFile reqFiles
-
-fileToFile :: Flat.File -> Raw.File
-fileToFile Flat.File{nodes, fileId, fileName} =
-    Raw.File
-        { fileName
-        , fileId
-        , decls = concatMap nodeToDecls nodes
-        }
-
-nodeToDecls :: Flat.Node -> [Raw.Decl]
-nodeToDecls Flat.Node{name=Name.CapnpQ{fileId, local}, union_, typeParams} =
-  let typeParams' = map C.paramName typeParams in
-  case union_ of
-    Flat.Enum variants ->
-        [ Raw.Enum
-            { typeCtor = local
-            , dataCtors = map (Name.mkSub local) variants
-            }
-        ]
-    Flat.Struct{fields, isGroup, dataWordCount, pointerCount, union} ->
-        concat
-            [ [ Raw.StructWrapper { typeCtor = local, typeParams = typeParams' } ]
-            , if isGroup
-                then
-                    []
-                else
-                    [ Raw.StructInstances
-                        { typeCtor = local
-                        , typeParams = typeParams'
-                        , dataWordCount
-                        , pointerCount
-                        }
-                    ]
-            , concatMap (fieldToDecls local typeParams') fields
-            , case union of
-                Nothing -> []
-                Just Flat.Union{variants, tagOffset} ->
-                    let local' = Name.mkSub local "" in
-                    [ Raw.UnionVariant
-                        { parentTypeCtor = local
-                        , typeParams = typeParams'
-                        , tagOffset
-                        , unionDataCtors =
-                            [ Raw.Variant
-                                { name = local
-                                , tagValue
-                                , locType = C.bothMap (\Flat.Node{name} -> name) fieldLocType
-                                }
-                            | Flat.Variant
-                                { field = Flat.Field
-                                    { fieldName = Name.CapnpQ{local}
-                                    , fieldLocType
-                                    }
-                                , tagValue
-                                } <- variants
-                            ]
-                        }
-                    , Raw.Getter
-                        { fieldName = local'
-                        , typeParams = typeParams'
-                        , containerType = local
-                        , fieldLocType = C.HereField $ C.StructType Name.CapnpQ
-                            { fileId
-                            , local = local'
-                            }
-                            (C.ListBrand
-                                [ C.PtrParam C.TypeParamRef
-                                    { paramName
-                                    , paramIndex
-                                    , paramScope = scopeName
-                                    }
-                                | C.TypeParamRef
-                                    { paramName
-                                    , paramIndex
-                                    , paramScope=Flat.Node{name=scopeName}
-                                    } <- typeParams
-                                ]
-                            )
-                        }
-                    ] ++
-                    [ Raw.Setter
-                        { fieldName
-                        , typeParams = typeParams'
-                        , containerType = local
-                        , fieldLocType = C.bothMap (\Flat.Node{name} -> name) fieldLocType
-                        , tag = Just Raw.TagSetter
-                            { tagOffset
-                            , tagValue
-                            }
-                        }
-                    | Flat.Variant
-                        { field = Flat.Field
-                            { fieldName = Name.CapnpQ { local = fieldName }
-                            , fieldLocType
-                            }
-                        , tagValue
-                        } <- variants
-                    ] ++
-                    -- This is kindof another tag setter, but it has to work a bit
-                    -- differently for the unknown' variant, because it takes an
-                    -- argument for what the tag should be, but also doesn't need to
-                    -- set any other values. We can treat is as just a setter for a
-                    -- uint16 field in the same spot:
-                    [ Raw.Setter
-                        { fieldName = Name.mkSub local "unknown'"
-                        , typeParams = typeParams'
-                        , containerType = local
-                        , fieldLocType = C.DataField
-                            (Raw.tagOffsetToDataLoc tagOffset)
-                            (C.PrimWord $ C.PrimInt $ C.IntType C.Unsigned C.Sz16)
-                        , tag = Nothing
-                        }
-                    ]
-        ]
-    Flat.Interface{} ->
-        [ Raw.InterfaceWrapper
-            { typeCtor = local
-            , typeParams = typeParams'
-            }
-        ]
-    Flat.Constant{ value } ->
-        [ Raw.Constant
-            { name = local
-            , value = C.bothMap (\Flat.Node{name} -> name) value
-            }
-        ]
-    Flat.Other -> []
-
-fieldToDecls :: Name.LocalQ -> [Name.UnQ] -> Flat.Field -> [Raw.Decl]
-fieldToDecls
-    containerType
-    typeParams
-    Flat.Field{fieldName=Name.CapnpQ{local=fieldName}, fieldLocType}
-    =
-    [ Raw.Getter
-        { fieldName
-        , typeParams
-        , containerType
-        , fieldLocType = C.bothMap (\Flat.Node{name} -> name) fieldLocType
-        }
-    ]
-    ++
-    case fieldLocType of
-         C.HereField _ -> []
-         _ ->
-            [ Raw.Setter
-                { fieldName
-                , containerType
-                , typeParams
-                , fieldLocType = C.bothMap (\Flat.Node{name} -> name) fieldLocType
-                , tag = Nothing
-                }
-            ]
-    ++
-    case fieldLocType of
-        C.PtrField ptrIndex _ ->
-            [ Raw.HasFn
-                { fieldName
-                , typeParams
-                , containerType
-                , ptrIndex
-                }
-            ]
-        _ ->
-            []
-    ++
-    case fieldLocType of
-        C.PtrField _ (C.ListOf _) ->
-            [ Raw.NewFn
-                { fieldName
-                , typeParams
-                , containerType
-                , fieldLocType = C.bothMap (\Flat.Node{name} -> name) fieldLocType
-                , newFnType = Raw.NewList
-                }
-            ]
-        C.PtrField _ (C.PrimPtr C.PrimText) ->
-            [ Raw.NewFn
-                { fieldName
-                , typeParams
-                , containerType
-                , fieldLocType = C.bothMap (\Flat.Node{name} -> name) fieldLocType
-                , newFnType = Raw.NewText
-                }
-            ]
-        C.PtrField _ (C.PrimPtr C.PrimData) ->
-            [ Raw.NewFn
-                { fieldName
-                , typeParams
-                , containerType
-                , fieldLocType = C.bothMap (\Flat.Node{name} -> name) fieldLocType
-                , newFnType = Raw.NewData
-                }
-            ]
-        C.PtrField _ (C.PtrComposite _) ->
-            [ Raw.NewFn
-                { fieldName
-                , typeParams
-                , containerType
-                , fieldLocType = C.bothMap (\Flat.Node{name} -> name) fieldLocType
-                , newFnType = Raw.NewStruct
-                }
-            ]
-        _ ->
-            []
diff --git a/cmd/capnpc-haskell/Trans/NewToHaskell.hs b/cmd/capnpc-haskell/Trans/NewToHaskell.hs
--- a/cmd/capnpc-haskell/Trans/NewToHaskell.hs
+++ b/cmd/capnpc-haskell/Trans/NewToHaskell.hs
@@ -7,6 +7,7 @@
     ) where
 
 import qualified Capnp.Repr            as R
+import           Control.Monad         (guard)
 import           Data.String           (IsString(fromString))
 import           Data.Word
 import qualified IR.Common             as C
@@ -15,6 +16,7 @@
 import qualified IR.New                as New
 import           Trans.ToHaskellCommon
 
+-- | Modules imported by all generated modules.
 imports :: [Hs.Import]
 imports =
     [ Hs.ImportAs { importAs = "R", parts = ["Capnp", "Repr"] }
@@ -24,9 +26,17 @@
     , Hs.ImportAs { importAs = "GH", parts = ["Capnp", "GenHelpers", "New"] }
     , Hs.ImportAs { importAs = "C", parts = ["Capnp", "New", "Classes"] }
     , Hs.ImportAs { importAs = "Generics", parts = ["GHC", "Generics"] }
-    , Hs.ImportAs { importAs = "BS", parts = ["Capnp", "GenHelpers", "ReExports", "Data", "ByteString"] }
     ]
 
+-- | Modules imported by generated modules that use rpc. We separate these out to
+-- avoid a circular import when generating code for rpc.capnp -- which does not
+-- contain interfaces, so does not need to import the rpc system -- but which
+-- must be imported *by* the rpc system.
+rpcImports :: [Hs.Import]
+rpcImports =
+    [ Hs.ImportAs { importAs = "GH", parts = ["Capnp", "GenHelpers", "New", "Rpc"] }
+    ]
+
 fileToModules :: New.File -> [Hs.Module]
 fileToModules file =
     [ fileToMainModule file
@@ -34,7 +44,7 @@
     ]
 
 fileToMainModule :: New.File -> Hs.Module
-fileToMainModule file@New.File{fileName} =
+fileToMainModule file@New.File{fileName, usesRpc} =
     fixImports $ Hs.Module
         { modName = ["Capnp", "Gen"] ++ makeModName fileName ++ ["New"]
         , modLangPragmas =
@@ -55,7 +65,7 @@
             , "ScopedTypeVariables"
             ]
         , modExports = Nothing
-        , modImports = imports
+        , modImports = imports ++ (guard usesRpc >> rpcImports)
         , modDecls = fileToDecls file
         }
 
@@ -401,7 +411,7 @@
                     , params = []
                     , value = Hs.EApp
                         (egName ["GH"] "getPtrConst")
-                        [Hs.ETypeAnno (Hs.EBytes (makePtrBytes v)) (tgName ["BS"] "ByteString")]
+                        [Hs.ETypeAnno (Hs.EBytes (makePtrBytes v)) (tgName ["GH"] "ByteString")]
                     }
                 }
             ]
diff --git a/cmd/capnpc-haskell/Trans/PureToHaskell.hs b/cmd/capnpc-haskell/Trans/PureToHaskell.hs
deleted file mode 100644
--- a/cmd/capnpc-haskell/Trans/PureToHaskell.hs
+++ /dev/null
@@ -1,840 +0,0 @@
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE LambdaCase            #-}
-{-# LANGUAGE NamedFieldPuns        #-}
-{-# LANGUAGE OverloadedStrings     #-}
-module Trans.PureToHaskell (fileToModules) where
-
-import Data.Word
-
-import Control.Monad (guard)
-import Text.Printf   (printf)
-
-import qualified Data.Text as T
-
-import IR.Haskell
-import Trans.ToHaskellCommon
-
-import qualified IR.Common as C
-import qualified IR.Name   as Name
-import qualified IR.Pure   as P
-
-
--- | Modules imported by all generated modules.
-commonImports :: [Import]
-commonImports =
-    [ ImportAs { importAs = "V", parts = reExp ["Data", "Vector"] }
-    , ImportAs { importAs = "T", parts = reExp ["Data", "Text"] }
-    , ImportAs { importAs = "BS", parts = reExp ["Data", "ByteString"] }
-    , ImportAs { importAs = "Default", parts = reExp ["Data", "Default"] }
-    , ImportAs { importAs = "Generics", parts = ["GHC", "Generics"] }
-    , ImportAs { importAs = "MonadIO", parts = ["Control", "Monad", "IO", "Class"] }
-    , ImportAs { importAs = "UntypedPure", parts = ["Capnp", "Untyped", "Pure"] }
-    , ImportAs { importAs = "Untyped", parts = ["Capnp", "Untyped"] }
-    , ImportAs { importAs = "Message", parts = ["Capnp", "Message"] }
-    , ImportAs { importAs = "Classes", parts = ["Capnp", "Classes"] }
-    , ImportAs { importAs = "BasicsPure", parts = ["Capnp", "Basics", "Pure" ] }
-    , ImportAs { importAs = "GenHelpersPure", parts = ["Capnp", "GenHelpers", "Pure"] }
-    ]
-
-
--- | Modules imported by generated modules that use rpc.
-rpcImports :: [Import]
-rpcImports =
-    [ ImportAs { importAs = "Rpc", parts = ["Capnp", "Rpc", "Untyped"] }
-    , ImportAs { importAs = "Server", parts = ["Capnp", "Rpc", "Server"] }
-    , ImportAs { importAs = "RpcHelpers", parts = ["Capnp", "GenHelpers", "Rpc"] }
-    , ImportAs { importAs = "STM", parts = reExp ["Control", "Concurrent", "STM"] }
-    , ImportAs { importAs = "STM", parts = reExp [ "Control", "Monad", "STM", "Class"] }
-    , ImportAs { importAs = "Supervisors", parts = reExp ["Supervisors"] }
-    ]
-
-reExp :: [Name.UnQ] -> [Name.UnQ]
-reExp parts = ["Capnp", "GenHelpers", "ReExports"] ++ parts
-
--- | Whether the serialized and unserialized forms of this type
--- are the same. If not, there is a marshalling step, if so, the
--- accessors work with the decerialized form directly.
---
--- For example, this is True for Enums, basic integers, etc. but
--- False for structs, interfaces, etc.
-cerialEq :: C.Type b r -> Bool
-cerialEq C.VoidType          = True
-cerialEq (C.WordType _)      = True
-cerialEq (C.CompositeType _) = False
-cerialEq (C.PtrType _)       = False
-
-fileToModules :: P.File -> [Module]
-fileToModules file =
-    [ fileToMainModule file
-    , fileToModuleAlias file
-    ]
-
-fileToModuleAlias :: P.File -> Module
-fileToModuleAlias P.File{fileName, fileId} =
-    let reExport = ["Capnp", "Gen"] ++ makeModName fileName ++ ["Pure"]
-    in Module
-        { modName = idToModule fileId ++ ["Pure"]
-        , modLangPragmas = []
-        , modExports = Just [ExportMod reExport]
-        , modImports = [ ImportAll { parts = reExport } ]
-        , modDecls = []
-        }
-
-fileToMainModule :: P.File -> Module
-fileToMainModule P.File{fileName, fileId, decls, reExportEnums, usesRpc} =
-    fixImports $ Module
-        { modName = ["Capnp", "Gen"] ++ makeModName fileName ++ ["Pure"]
-        , modLangPragmas =
-            [ "DataKinds"
-            , "DeriveGeneric"
-            , "DuplicateRecordFields"
-            , "FlexibleContexts"
-            , "FlexibleInstances"
-            , "FunctionalDependencies"
-            , "RecordWildCards"
-            , "MultiParamTypeClasses"
-            , "TypeFamilies"
-            , "UndecidableInstances"
-            ]
-        , modExports = Just $
-            [ExportGCtors (gName (rawModule fileId) name) | name <- reExportEnums]
-            ++ concatMap (declToExport fileId) decls
-        , modImports =
-            commonImports ++ (guard usesRpc >> rpcImports)
-        , modDecls =
-            concatMap (declToDecls fileId) decls
-            ++ concatMap (enumInstances fileId) reExportEnums
-        }
-
-
--- | Convert a declaration into the list of related exports we need.
--- The first argument is the id for this module.
-declToExport :: Word64 -> P.Decl -> [Export]
-declToExport fileId = \case
-    P.DataDecl P.Data{typeName} ->
-        [ ExportLCtors typeName ]
-    P.ConstDecl P.Constant { name, value=C.WordValue _ _ } ->
-        [ ExportGName $ gName (rawModule fileId) name ]
-    P.ConstDecl P.Constant { name, value=C.VoidValue } ->
-        [ ExportGName $ gName (rawModule fileId) name ]
-    P.ConstDecl P.Constant { name, value=C.PtrValue _ _ } ->
-        [ ExportLName name ]
-    P.IFaceDecl P.IFace{ name=Name.CapnpQ{local} } ->
-        [ ExportLCtors local
-        , ExportLCtors (Name.mkSub local "server_")
-        , ExportLName (Name.unQToLocal $ Name.UnQ $ "export_" <> Name.renderLocalQ local)
-        ]
-
--- | enumInstances' generates some type class instances an enum data type.
-enumInstances :: Word64 -> Name.LocalQ -> [Decl]
-enumInstances thisMod name =
-    let rawName = gName (rawModule thisMod) name in
-    instance_ [] ["Classes"] "Decerialize" [TGName rawName]
-        [ iType "Cerial" [tuName "msg", TGName rawName] (TGName rawName)
-        , iValue "decerialize" [] (eStd_ "pure")
-        ]
-    : instance_ [] ["Classes"] "Cerialize" [tuName "s", TGName rawName]
-        [ iValue "cerialize" [PVar "_"] (eStd_ "pure")
-        ]
-    : [ instance_ [] ["Classes"] "Cerialize" [tuName "s", t]
-        [ iValue "cerialize" [] (egName ["Classes"] "cerializeBasicVec")
-        ]
-      | t <- take 6 $ drop 1 $ iterate
-            (\t -> TApp (tgName ["V"] "Vector") [t])
-            (TGName rawName)
-      ]
-
--- | Convert an 'IR.Pure.Decl' into a series of Haskell declarations.
-declToDecls :: Word64 -> P.Decl -> [Decl]
-declToDecls thisMod (P.DataDecl data_)     = dataToDecls thisMod data_
-declToDecls thisMod (P.ConstDecl constant) = constToDecls thisMod constant
-declToDecls thisMod (P.IFaceDecl iface)    = ifaceToDecls thisMod iface
-
-dataToDecls :: Word64 -> P.Data -> [Decl]
-dataToDecls thisMod data_@P.Data{firstClass} = concat $
-    [ dataToDataDecl thisMod data_
-    , dataToSimpleInstances thisMod data_
-    , dataToDecerialize thisMod data_
-    , dataToMarshal thisMod data_
-    ]
-    ++
-    [ firstClassInstances thisMod data_ | firstClass ]
-
--- | Get the name of a data constructor for a product type. Arguments are the
--- name of the type constructor and whether or not the type is "first class".
-productVariantName :: Name.LocalQ -> Bool -> Name.LocalQ
-productVariantName typeName firstClass
-    | firstClass = typeName
-    | otherwise = Name.mkSub typeName ""
-    -- ^ This is a group. If it's part of a union, then the union
-    -- will have a data constructor that is the same as typeName,
-    -- so we appent a ' to avoid a colision.
-
-dataToDataDecl :: Word64 -> P.Data -> [Decl]
-dataToDataDecl thisMod P.Data
-        { typeName
-        , typeParams
-        , cerialName
-        , firstClass
-        , def
-        } =
-    let unknownCtor = Name.mkSub cerialName "unknown'" in
-    [ DcData Data
-        { dataName = Name.localToUnQ typeName
-        , typeArgs = map (TVar . Name.typeVarName) typeParams
-        , derives =
-            ["Std_.Show", "Std_.Eq", "Generics.Generic"]
-        , dataNewtype = False
-        , dataInstance = False
-        , dataVariants =
-            case def of
-                P.Product fields ->
-                    [ DataVariant
-                        { dvCtorName = Name.localToUnQ $ productVariantName typeName firstClass
-                        , dvArgs = ARec (map (fieldToField thisMod) fields)
-                        }
-                    ]
-                P.Sum variants ->
-                    [ DataVariant
-                        { dvCtorName = Name.localToUnQ name
-                        , dvArgs = case arg of
-                            Nothing -> APos []
-                            Just ty -> APos [typeToType thisMod ty]
-                        }
-                    | P.Variant{name, arg} <- variants
-                    ]
-                    ++
-                    [ DataVariant
-                        { dvCtorName = Name.localToUnQ unknownCtor
-                        , dvArgs = APos [TPrim $ C.PrimInt $ C.IntType C.Unsigned C.Sz16]
-                        }
-                    ]
-        }
-    ]
-
-typeParamsDecerializeCtx :: [Name.UnQ] -> [Type]
-typeParamsDecerializeCtx typeParams =
-    let
-        vars = typeParamVars typeParams
-        tConst = tgName ["Message"] "Const"
-        cerial msg v = TApp (tgName ["Classes"] "Cerial") [msg, v]
-    in
-    concat
-        [ [ TApp (tgName ["Classes"] "Decerialize") [v]
-          , TApp
-            (tgName ["Classes"] "FromPtr")
-            [ tConst
-            , cerial tConst v
-            ]
-          ]
-        | v <- vars
-        ]
-
-typeParamsCerializeCtx :: [Name.UnQ] -> [Type]
-typeParamsCerializeCtx typeParams =
-    typeParamsDecerializeCtx typeParams ++ concat
-        [ [ TApp (tgName ["Classes"] "Cerialize") [tuName "s", v]
-          , TApp (tgName ["Classes"] "ToPtr")
-               [ tuName "s"
-               , TApp (tgName ["Classes"] "Cerial")
-                   [ TApp (tgName ["Message"] "Mut") [tuName "s"]
-                   , v
-                   ]
-               ]
-           ]
-        | v <- typeParamVars typeParams
-        ]
-
-dataToSimpleInstances :: Word64 -> P.Data -> [Decl]
-dataToSimpleInstances _thisMod P.Data{ typeName, typeParams } =
-    let typ = typeWithParams typeName typeParams
-        ctx = typeParamsDecerializeCtx typeParams
-    in
-    [ instance_ ctx ["Default"] "Default" [typ]
-        [ iValue "def" [] (egName ["GenHelpersPure"] "defaultStruct")
-        ]
-    , instance_ ctx ["Classes"] "FromStruct" [tgName ["Message"] "Const", typ]
-        [ iValue "fromStruct" [PVar "struct"] $ EBind
-            (EApp (egName ["Classes"] "fromStruct") [euName "struct"])
-            (egName ["Classes"] "decerialize")
-        ]
-    ]
-
-dataToDecerialize :: Word64 -> P.Data -> [Decl]
-dataToDecerialize thisMod P.Data
-        { typeName
-        , typeParams
-        , cerialName
-        , firstClass
-        , def
-        } =
-    let typ = typeWithParams typeName typeParams
-        ctx = typeParamsDecerializeCtx typeParams
-    in
-    [ instance_ ctx ["Classes"] "Decerialize" [typ]
-        [ iType "Cerial" [tuName "msg", typ] $
-            TApp (tgName (rawModule thisMod) cerialName) $
-                [ TApp (tgName ["Classes"] "Cerial") [tuName "msg", v]
-                | v <- typeParamVars typeParams
-                ]
-                ++ [tuName "msg"]
-        , iValue "decerialize" [PVar "raw"] $
-            case def of
-                P.Sum variants ->
-                    variantsToDecerialize thisMod cerialName variants
-                P.Product fields ->
-                    fieldsToDecerialize thisMod typeName firstClass fields
-        ]
-    ]
-
-variantsToDecerialize :: Word64 -> Name.LocalQ -> [P.Variant] -> Exp
-variantsToDecerialize thisMod cerialName variants =
-    let unknownCtor = Name.mkSub cerialName "unknown'"
-        fieldGetter parentName name = egName
-            (rawModule thisMod)
-            (Name.unQToLocal $ Name.getterName $ Name.mkSub parentName name)
-    in
-    EDo
-        [DoBind "raw" $ EApp (fieldGetter cerialName "") [euName "raw"]
-        ]
-        (ECase (ELName "raw") $
-            [ case arg of
-                Nothing ->
-                    ( pgName (rawModule thisMod) name []
-                    , EApp (eStd_ "pure") [ELName name]
-                    )
-                Just type_ | cerialEq type_ ->
-                    ( pgName (rawModule thisMod) name [PVar "raw"]
-                    , EApp (eStd_ "pure") [EApp (ELName name) [euName "raw"]]
-                    )
-                Just _ ->
-                    ( pgName (rawModule thisMod) name [PVar "raw"]
-                    , EFApp
-                        (ELName name)
-                        [EApp (egName ["Classes"] "decerialize") [euName "raw"]]
-                    )
-            | P.Variant{name, arg} <- variants
-            ]
-            ++
-            [ ( pgName (rawModule thisMod) unknownCtor [PVar "tag"]
-              , EApp
-                  (eStd_ "pure")
-                  [EApp (ELName unknownCtor) [euName "tag"]]
-              )
-            ]
-        )
-
-fieldsToDecerialize :: Word64 -> Name.LocalQ -> Bool -> [P.Field] -> Exp
-fieldsToDecerialize thisMod typeName firstClass fields =
-    let fieldGetter parentName name = egName
-            (rawModule thisMod)
-            (Name.unQToLocal $ Name.getterName $ Name.mkSub parentName name)
-        variantName = productVariantName typeName firstClass
-    in
-    case fields of
-        [] ->
-            EApp (eStd_ "pure") [ELName variantName]
-        _ ->
-            EFApp
-                (ELName variantName)
-                [
-                    let getter = EApp (fieldGetter typeName name) [euName "raw"] in
-                    if name == "union'" then
-                        -- unions decerialize from the same type as their parents. Don't
-                        -- do anything but pass it off.
-                        EApp (egName ["Classes"] "decerialize") [euName "raw"]
-                    else if cerialEq type_ then
-                        getter
-                    else
-                        EBind getter (egName ["Classes"] "decerialize")
-                | P.Field{name, type_} <- fields
-                ]
-
-
-dataToMarshal :: Word64 -> P.Data -> [Decl]
-dataToMarshal thisMod P.Data
-        { typeName
-        , typeParams
-        , cerialName
-        , firstClass
-        , def
-        } =
-    let typ = typeWithParams typeName typeParams in
-    [ instance_ (typeParamsCerializeCtx typeParams) ["Classes"] "Marshal" [TVar "s", typ]
-        [ iValue "marshalInto" [PVar "raw_", PVar "value_"] $
-            case def of
-                P.Sum variants ->
-                    variantsToMarshal thisMod cerialName variants
-                P.Product fields ->
-                    fieldsToMarshal thisMod typeName firstClass fields
-        ]
-    ]
-
-variantsToMarshal :: Word64 -> Name.LocalQ -> [P.Variant] -> Exp
-variantsToMarshal thisMod cerialName variants =
-    let unknownCtor = Name.mkSub cerialName "unknown'" in
-    ECase (euName "value_") $
-        [ let setter = Name.unQToLocal $ Name.setterName variantName
-              setExp = EApp (egName (rawModule thisMod) setter) [euName "raw_"]
-          in case arg of
-            Nothing ->
-                ( PLCtor variantName []
-                , setExp
-                )
-            Just type_ ->
-                ( PLCtor variantName [PVar "arg_"]
-                , marshalField MarshalField
-                    { thisMod
-                    , into = "raw_"
-                    , localQField = variantName
-                    , from = "arg_"
-                    , type_
-                    , inUnion = True
-                    }
-                )
-        | P.Variant{name=variantName, arg} <- variants
-        ]
-        ++
-        let setter = Name.unQToLocal $ Name.setterName unknownCtor in
-        [ ( PLCtor unknownCtor [PVar "tag"]
-          , EApp (egName (rawModule thisMod) setter) [euName "raw_", euName "tag"]
-          )
-        ]
-
-fieldsToMarshal :: Word64 -> Name.LocalQ -> Bool -> [P.Field] -> Exp
-fieldsToMarshal thisMod typeName firstClass fields =
-    let variantName = productVariantName typeName firstClass in
-    ECase (euName "value_")
-        [ ( case fields of
-              -- If there are no fields, use of RecordWildCards will
-              -- cause an error:
-              [] -> PLCtor variantName []
-              _  -> PLRecordWildCard variantName
-          , EDo
-              [ DoE $ marshalField MarshalField
-                  { thisMod
-                  , into = "raw_"
-                  , localQField = Name.mkSub typeName fieldName
-                  , from = fieldName
-                  , type_
-                  , inUnion = False
-                  }
-              | P.Field{name=fieldName, type_} <- fields
-              ]
-              ePureUnit
-          )
-        ]
-
-firstClassInstances :: Word64 -> P.Data -> [Decl]
-firstClassInstances _thisMod P.Data{ typeName, typeParams } =
-    let typ = typeWithParams typeName typeParams
-        ctx = typeParamsCerializeCtx typeParams
-    in
-    [ instance_ ctx ["Classes"] "Cerialize" [tuName "s", typ] []
-    , instance_ ctx ["Classes"] "Cerialize" [tuName "s", TApp (tgName ["V"] "Vector") [typ]]
-        [ iValue "cerialize" [] (egName ["GenHelpersPure"] "cerializeCompositeVec")
-        ]
-    ] ++
-    -- Generate instances of Cerialize s (Vector (Vector ... t)) up to some reasonable
-    -- nesting level. I(zenhack) can't figure out how to get a general case
-    -- Cerialize s (Vector a) => Cerialize s (Vector (Vector a)) to type check, so this
-    -- will have to do for now.
-    [ instance_ ctx ["Classes"] "Cerialize" [tuName "s", t]
-        [ iValue "cerialize" [] (egName ["GenHelpersPure"] "cerializeBasicVec")
-        ]
-    | t <- take 6 $ drop 2 $ iterate
-            (\t -> TApp (tgName ["V"] "Vector") [t])
-            typ
-    ]
-
-ifaceToDecls :: Word64 -> P.Interface -> [Decl]
-ifaceToDecls thisMod iface =
-    [ ifaceClientDecl thisMod iface
-    , ifaceClassDecl thisMod iface
-    , ifaceExportFn thisMod iface
-    ]
-    ++
-    ifaceInstances thisMod iface
-
--- | Declare the newtype wrapper for clients of this interface.
-ifaceClientDecl :: Word64 -> P.Interface -> Decl
-ifaceClientDecl _thisMod P.IFace{ name=Name.CapnpQ{local=name}, typeParams } =
-    DcData Data
-        { dataName = Name.localToUnQ name
-        , dataNewtype = True
-        , dataInstance = False
-        , dataVariants =
-            [ DataVariant
-                { dvCtorName = Name.localToUnQ name
-                , dvArgs = APos [tgName ["Message"] "Client"]
-                }
-            ]
-        , typeArgs = map (TVar . Name.typeVarName . C.paramName) typeParams
-        , derives =
-            [ "Std_.Show"
-            , "Std_.Eq"
-            , "Generics.Generic"
-            ]
-        }
-
--- | define the *'server_ class for the interface.
-ifaceClassDecl :: Word64 -> P.Interface -> Decl
-ifaceClassDecl thisMod P.IFace { name=Name.CapnpQ{local=name}, methods, supers, typeParams } =
-    let typeParamNames = map (Name.typeVarName . C.paramName) typeParams in
-    DcClass
-        { ctx =
-            let superConstraints =
-                    -- Add class constraints for superclasses:
-                    [ let superClass = pureTName thisMod fileId (Name.mkSub local "server_")
-                      in TApp superClass $
-                            [tuName "m", tuName "cap"]
-                            ++ map (typeToType thisMod . C.PtrType) types
-                    | (P.IFace{name=Name.CapnpQ{local, fileId}}, C.ListBrand types) <- supers
-                    ]
-            in
-            TApp (tgName ["MonadIO"] "MonadIO") [tuName "m"]
-            : case superConstraints of
-                -- If this interface doesn't have any superclasses, then we need to
-                -- specify a constraint for the 'Server' class. Otherwise, it's
-                -- implied by the supers.
-                [] -> [ TApp (tgName ["Server"] "Server") [tuName "m", tuName "cap"] ]
-                _ -> superConstraints
-        , name = Name.mkSub name "server_"
-        , params = map Name.UnQ $ ["m", "cap"] ++ typeParamNames
-        , funDeps = [ ("cap", v) | v <- typeParamNames ]
-        , decls =
-            let mkName = mkMethodName name in
-            CdMinimal [ mkName name | P.Method{name} <- methods ]
-            : concat
-                [ [ CdValueDecl
-                        (mkName methodName)
-                        (TFn
-                            [ tuName "cap"
-                            , TApp
-                                (tgName ["Server"] "MethodHandler")
-                                [ tuName "m"
-                                , typeToType thisMod $ C.CompositeType paramType
-                                , typeToType thisMod $ C.CompositeType resultType
-                                ]
-                            ]
-                        )
-                    , CdValueDef DfValue
-                        { name = mkName methodName
-                        , params = [PVar "_"]
-                        , value = egName ["Server"] "methodUnimplemented"
-                        }
-                    ]
-                | P.Method
-                    { name=methodName
-                    , paramType
-                    , resultType
-                    }
-                <- methods
-                ]
-        }
-
-
--- | Define the export_Foo function for the interface.
-ifaceExportFn :: Word64 -> P.Interface -> Decl
-ifaceExportFn thisMod iface@P.IFace { name=Name.CapnpQ{ local }, typeParams, ancestors } =
-    let typeParamVars = map (TVar . Name.typeVarName . C.paramName) typeParams in
-    DcValue
-        { typ = TCtx
-            [ TApp (tgName ["STM"] "MonadSTM") [tuName "m"]
-            , TApp
-                (TLName (Name.mkSub local "server_"))
-                $ [tStd_ "IO", tuName "cap"] ++ typeParamVars
-            ]
-            (TFn
-                [ tgName ["Supervisors"] "Supervisor"
-                , tuName "cap"
-                , TApp (tuName "m") [TApp (TLName local) typeParamVars]
-                ]
-            )
-        , def = DfValue
-            { name = Name.UnQ $ "export_" <> Name.renderLocalQ local
-            , params = [PVar "sup_", PVar "server_"]
-            , value = EApp (egName ["STM"] "liftSTM") $ pure $ EFApp (ELName local)
-                [ EApp (egName ["Rpc"] "export")
-                    [ euName "sup_"
-                    , ERecord (egName ["Server"] "ServerOps")
-                        [ ( "handleCast"
-                          , EApp (egName ["Server"] "unwrap") [ELName "server_"]
-                          )
-                        , ( "handleStop"
-                          , EApp (egName ["Server"] "shutdown") [ELName "server_"]
-                          )
-                        , ( "handleCall"
-                          , ELambda [PVar "interfaceId_", PVar "methodId_"] $
-                                ECase (euName "interfaceId_") $
-                                    [ ( PInt (fromIntegral interfaceId)
-                                      , ECase (euName "methodId_") $
-                                            [ ( PInt i
-                                              , EApp
-                                                    (egName ["Server"] "toUntypedHandler")
-                                                    [ let methodName = mkMethodName ifaceName mname in
-                                                      EApp
-                                                        (if thisMod == ifaceMod
-                                                            then euName methodName
-                                                            else egName (pureModule ifaceMod) (Name.unQToLocal methodName)
-                                                        )
-                                                        [euName "server_"]
-                                                    ]
-                                              )
-                                            | (i, P.Method{name=mname}) <- zip [0..] methods
-                                            ]
-                                            ++
-                                            [ ( PVar "_"
-                                              , egName ["Server"] "methodUnimplemented"
-                                              )
-                                            ]
-                                      )
-                                    | P.IFace
-                                        { name = Name.CapnpQ{local=ifaceName, fileId=ifaceMod}
-                                        , interfaceId
-                                        , methods
-                                        }
-                                    <- iface : map fst ancestors
-                                    ]
-                                    ++
-                                    [ ( PVar "_"
-                                      , egName ["Server"] "methodUnimplemented"
-                                      )
-                                    ]
-                          )
-                        ]
-                    ]
-                ]
-            }
-        }
-
--- | Declare instances for clients for this interface.
-ifaceInstances :: Word64 -> P.Interface -> [Decl]
-ifaceInstances thisMod iface@P.IFace{ name=Name.CapnpQ{local=name}, typeParams } =
-    let typ = typeWithParams name (map C.paramName typeParams) in
-    [ instance_ [] ["Rpc"] "IsClient" [typ]
-        [ iValue "fromClient" [] (ELName name)
-        , iValue "toClient" [PLCtor name [PVar "client"]] (euName "client")
-        ]
-    , instance_ [] ["Classes"] "FromPtr" [tuName "msg", typ]
-        [ iValue "fromPtr" [] (egName ["RpcHelpers"] "isClientFromPtr")
-        ]
-    , instance_ [] ["Classes"] "ToPtr" [tuName "s", typ]
-        [ iValue "toPtr" [] (egName ["RpcHelpers"] "isClientToPtr")
-        ]
-    , instance_ [] ["Classes"] "Decerialize" [typ]
-        [ iType "Cerial" [tuName "msg", typ] $
-            TApp (tgName (rawModule thisMod) name) $
-                [ TApp (tgName ["Classes"] "Cerial")
-                    [ tuName "msg"
-                    , TVar (Name.typeVarName (C.paramName t))
-                    ]
-                | t <- typeParams
-                ]
-                ++ [tuName "msg"]
-        , iValue "decerialize"
-            [ pgName (rawModule thisMod) (Name.mkSub name "newtype_") [PVar "maybeCap"]
-            ]
-            (ECase (euName "maybeCap")
-                [ (PGCtor (std_ "Nothing") []
-                  , EApp
-                        (eStd_ "pure")
-                        [ EApp (ELName name) [egName ["Message"] "nullClient"]
-                        ]
-                  )
-                , (PGCtor (std_ "Just") [PVar "cap"]
-                  , EFApp
-                        (ELName name)
-                        [ EApp (egName ["Untyped"] "getClient") [euName "cap"]]
-                  )
-                ]
-            )
-        ]
-    , instance_ [] ["Classes"] "Cerialize" [tuName "s", typ]
-        [ iValue "cerialize" [PVar "msg", PLCtor name [PVar "client"]] $
-            EFApp
-                (egName (rawModule thisMod) (Name.mkSub name "newtype_"))
-                [ EFApp
-                    (eStd_ "Just")
-                    [EApp (egName ["Untyped"] "appendCap") [euName "msg", euName "client"]]
-                ]
-        ]
-    ]
-    ++
-    ifaceServerInstances thisMod iface
-
--- | Generate a reference to a type defined in a pure module given:
---
--- * The id of the module we're in (thisMod)
--- * The id of the module in which the type is defined (targetMod)
--- * The local name of the type.
-pureTName :: Word64 -> Word64 -> Name.LocalQ -> Type
-pureTName thisMod targetMod local
-    | thisMod == targetMod = TLName local
-    | otherwise = tgName (pureModule targetMod) local
-
--- | Instance declarations for this interface's client for its *'server_ class
--- and those of its ancestors.
-ifaceServerInstances :: Word64 -> P.Interface -> [Decl]
-ifaceServerInstances thisMod iface@P.IFace{ name=Name.CapnpQ{local=name}, typeParams, ancestors } =
-    DcInstance
-        { ctx = []
-        , typ = TApp (tgName ["Server"] "Server") [tStd_ "IO", typ]
-        , defs = []
-        }
-    : map go ((iface, C.ListBrand (map C.PtrParam typeParams)):ancestors)
-  where
-    typ = typeWithParams name (map C.paramName typeParams)
-    go (P.IFace { name=Name.CapnpQ{local, fileId}, interfaceId, methods }, C.ListBrand types) =
-        let className = Name.mkSub local "server_"
-            classType = pureTName thisMod fileId className
-            classArgs = map (typeToType thisMod . C.PtrType) types
-        in
-        -- Can't use 'instance_' here, because we don't know ahead of time what
-        -- module the class is in.
-        DcInstance
-            { ctx = []
-            , typ = TApp classType $ [tStd_ "IO", typ] ++ classArgs
-            , defs =
-                [ let methodName = mkMethodName local mname in
-                  iValue methodName [PLCtor name [PVar "client"]] $
-                    EApp
-                        (egName ["Rpc"] "clientMethodHandler")
-                        [ EInt $ fromIntegral interfaceId
-                        , EInt i
-                        , euName "client"
-                        ]
-                | (i, P.Method{name=mname}) <- zip [0..] methods
-                ]
-            }
-
--- | Generate declarations for a constant.
-constToDecls :: Word64 -> P.Constant -> [Decl]
-constToDecls thisMod P.Constant { name, value } = case value of
-    C.PtrValue ty _ ->
-        -- Generated code parses the corresponding constant from the raw
-        -- module.
-        [ DcValue
-            { typ = typeToType thisMod (C.PtrType ty)
-            , def = DfValue
-                { name = Name.localToUnQ name
-                , params = []
-                , value = EApp
-                    (egName ["GenHelpersPure"] "toPurePtrConst")
-                    [egName (rawModule thisMod) name]
-                }
-            }
-        ]
-    -- For these two we just re-export the constant from the raw module, so no
-    -- need to do anything here:
-    C.WordValue _ _ -> []
-    C.VoidValue -> []
-
-mkMethodName :: Name.LocalQ -> Name.UnQ -> Name.UnQ
-mkMethodName typeName methodName = Name.valueName $ Name.mkSub typeName methodName
-
--- | Arguments to 'marshalField'
-data MarshalField = MarshalField
-    { thisMod     :: !Word64
-    -- ^ The id for the module we're generating
-    , into        :: Name.UnQ
-    -- ^ An variable holding the destination for the marshalled data.
-    , localQField :: Name.LocalQ
-    -- ^ The name of the field to marshal, qualified within the current module.
-    , from        :: Name.UnQ
-    -- ^ A variable holding the value to marshal
-    , type_       :: C.Type (C.ListBrand Name.CapnpQ) Name.CapnpQ
-    , inUnion     :: !Bool
-    -- ^ whether the parent of this field is a union
-    }
-
-marshalField :: MarshalField -> Exp
-marshalField MarshalField{thisMod, into, localQField, from, type_, inUnion} =
-    let setter = egName (rawModule thisMod) $ Name.unQToLocal (Name.setterName localQField)
-        getter = egName (rawModule thisMod) $ Name.unQToLocal (Name.getterName localQField)
-    in case type_ of
-        C.PtrType _ ->
-            EBind
-                (EApp
-                    (egName ["Classes"] "cerialize")
-                    [ EApp (egName ["Untyped"] "message") [euName "raw_"]
-                    , euName from
-                    ]
-                )
-                (EApp setter [euName into])
-        C.VoidType ->
-            ePureUnit
-        C.WordType _ ->
-            EApp setter [euName into, euName from]
-        C.CompositeType _ -> EDo
-            (if Name.getUnQ localQField == "union'" then
-                -- Anonymous union; has the same Cerial as us. Just delegate.
-                []
-            else if inUnion then
-                [ DoBind into $ EApp setter [euName into] ]
-            else
-                [ DoBind into $ EApp getter [euName into] ]
-            )
-            (EApp (egName ["Classes"] "marshalInto") [euName into, euName from])
-
-fieldToField :: Word64 -> P.Field -> (Name.UnQ, Type)
-fieldToField thisMod P.Field{name, type_} = (name, typeToType thisMod type_)
-
-typeToType :: Word64 -> C.Type (C.ListBrand Name.CapnpQ) Name.CapnpQ -> Type
-typeToType _thisMod C.VoidType =
-    TUnit
-typeToType _thisMod (C.WordType (C.PrimWord ty)) =
-    TPrim ty
-typeToType thisMod (C.WordType (C.EnumType Name.CapnpQ{local, fileId})) =
-    -- Enums are just re-exported from the raw module, so we have a choice as to
-    -- how to refer to them. Using their 'Pure' module makes sure we pull in any
-    -- type class instances in those modules, but we have to make an exception
-    -- if the enum is defined in the file we're generating code for, since otherwise
-    -- we'd introduce a cyclic dependency. In that case we use the raw name; the
-    -- instances are defined in this same module so we don't need to worry about those.
-    if thisMod == fileId then
-        tgName (rawModule fileId) local
-    else
-        tgName (pureModule fileId) local
-typeToType thisMod (C.CompositeType (C.StructType n b)) =
-    nameToType thisMod n b
-typeToType thisMod (C.PtrType (C.PtrComposite (C.StructType n b))) =
-    nameToType thisMod n b
-typeToType thisMod (C.PtrType (C.ListOf ty)) =
-    TApp (tgName ["V"] "Vector") [typeToType thisMod ty]
-typeToType _thisMod (C.PtrType (C.PrimPtr C.PrimText)) =
-    tgName ["T"] "Text"
-typeToType _thisMod (C.PtrType (C.PrimPtr C.PrimData)) =
-    tgName ["BS"] "ByteString"
-typeToType _thisMod (C.PtrType (C.PrimPtr (C.PrimAnyPtr _))) =
-    -- TODO: distinguish different pointer types.
-    TApp (tStd_ "Maybe") [tgName ["UntypedPure"] "Ptr"]
-typeToType thisMod (C.PtrType (C.PtrInterface (C.InterfaceType n b))) =
-    nameToType thisMod n b
-typeToType _thisMod (C.PtrType (C.PtrParam C.TypeParamRef{paramName})) =
-    TVar (Name.typeVarName paramName)
-
-typeParamVars :: [Name.UnQ] -> [Type]
-typeParamVars = map (TVar . Name.typeVarName)
-
-typeWithParams :: Name.LocalQ -> [Name.UnQ] -> Type
-typeWithParams f xs =
-    TApp (TLName f) $ typeParamVars xs
-
-nameToType :: Word64 -> Name.CapnpQ -> C.ListBrand Name.CapnpQ -> Type
-nameToType thisMod Name.CapnpQ{local, fileId} (C.ListBrand args) =
-    let head
-            | thisMod == fileId = TLName local
-            | otherwise = tgName (pureModule fileId) local
-    in
-    case args of
-        [] -> head
-        _  -> TApp head (map (typeToType thisMod . C.PtrType) args)
-
-rawModule :: Word64 -> [T.Text]
-rawModule modId =
-    ["Capnp", "Gen", "ById", T.pack $ printf "X%x" modId]
-
-pureModule :: Word64 -> [T.Text]
-pureModule modId =
-    rawModule modId ++ ["Pure"]
diff --git a/cmd/capnpc-haskell/Trans/RawToHaskell.hs b/cmd/capnpc-haskell/Trans/RawToHaskell.hs
deleted file mode 100644
--- a/cmd/capnpc-haskell/Trans/RawToHaskell.hs
+++ /dev/null
@@ -1,882 +0,0 @@
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE LambdaCase            #-}
-{-# LANGUAGE NamedFieldPuns        #-}
-{-# LANGUAGE OverloadedStrings     #-}
-module Trans.RawToHaskell (fileToModules) where
-
-import Data.Word
-
-import Data.String (fromString)
-
-import qualified Data.Text as T
-
-import IR.Haskell
-import Trans.ToHaskellCommon
-
-import qualified IR.Common as C
-import qualified IR.Name   as Name
-import qualified IR.Raw    as Raw
-
-tMut :: Type
-tMut = TApp (tgName ["Message"] "Mut") [TVar "s"]
-
-tConst :: Type
-tConst = tgName ["Message"] "Const"
-
-fileToModules :: Raw.File -> [Module]
-fileToModules file =
-    [ fileToMainModule file
-    , fileToModuleAlias file
-    ]
-
-fileToModuleAlias :: Raw.File -> Module
-fileToModuleAlias Raw.File{fileName, fileId} =
-    let reExport = ["Capnp", "Gen"] ++ makeModName fileName
-    in Module
-        { modName = idToModule fileId
-        , modLangPragmas = []
-        , modExports = Just [ExportMod reExport]
-        , modImports = [ ImportAll { parts = reExport } ]
-        , modDecls = []
-        }
-
-fileToMainModule :: Raw.File -> Module
-fileToMainModule Raw.File{fileName, fileId, decls} =
-    fixImports $ Module
-        { modName = ["Capnp", "Gen"] ++ makeModName fileName
-        , modLangPragmas =
-            [ "FlexibleContexts"
-            , "FlexibleInstances"
-            , "MultiParamTypeClasses"
-            , "TypeFamilies"
-            , "DeriveGeneric"
-            , "DataKinds"
-            , "OverloadedStrings"
-            ]
-        , modExports = Nothing
-        , modImports =
-            [ imp ["Capnp", "Message"] "Message"
-            , imp ["Capnp", "Untyped"] "Untyped"
-            , imp ["Capnp", "Basics"] "Basics"
-            , imp ["Capnp", "GenHelpers"] "GenHelpers"
-            , imp ["Capnp", "Classes"] "Classes"
-            , imp ["GHC", "Generics"] "Generics"
-
-            -- So we can treat 'Word1' the same as 'Word16' etc.
-            , imp ["Capnp", "Bits"] "Std_"
-
-            , imp ["Data", "Maybe"] "Std_"
-            , imp ["Capnp", "GenHelpers", "ReExports", "Data", "ByteString"] "BS"
-            ]
-        , modDecls = concatMap (declToDecls fileId) decls
-        }
-  where
-    imp parts importAs = ImportAs {parts, importAs}
-
-declToDecls :: Word64 -> Raw.Decl -> [Decl]
-declToDecls thisMod Raw.UnionVariant{parentTypeCtor, typeParams, tagOffset, unionDataCtors} =
-    let unknownCtor = Name.mkSub parentTypeCtor "unknown'"
-        typeCtor = Name.mkSub parentTypeCtor ""
-        containerTypeType = containerTypeToType typeCtor typeParams
-        typeParamNames = map (TVar . Name.typeVarName) typeParams
-    in
-    [ DcData Data
-        { dataName = Name.localToUnQ typeCtor
-        , dataNewtype = False
-        , dataInstance = False
-        , typeArgs = typeParamNames ++ [TKindAnnotated (TVar "mut") (tgName ["Message"] "Mutability")]
-        , dataVariants =
-            [ DataVariant
-                { dvCtorName = Name.localToUnQ dataCtor
-                , dvArgs = APos $
-                    case locType of
-                        C.VoidField ->
-                            []
-                        _ ->
-                            [ typeToType thisMod (C.fieldType locType) (TVar "mut") ]
-                }
-            | Raw.Variant{name=dataCtor, locType} <- unionDataCtors
-            ]
-            ++
-            [ DataVariant
-                { dvCtorName = Name.localToUnQ unknownCtor
-                , dvArgs = APos [ TPrim $ C.PrimInt $ C.IntType C.Unsigned C.Sz16 ]
-                }
-            ]
-        , derives = []
-        }
-    , let ctx =
-            [ TApp (tgName ["Classes"] "FromPtr") [TVar "mut", v]
-            | v <- typeParamNames
-            ]
-      in
-      instance_ ctx ["Classes"] "FromStruct" [TVar "mut", containerTypeType (TVar "mut")]
-        [ iValue "fromStruct" [PVar "struct"] $ EDo
-            [ DoBind "tag"
-                (EApp
-                    (egName ["GenHelpers"] "getTag")
-                    [ ELName "struct"
-                    , EInt (fromIntegral tagOffset)
-                    ]
-                )
-            ]
-            (ECase (ELName "tag") $
-                [ ( PInt $ fromIntegral tagValue
-                  , case locType of
-                        C.VoidField ->
-                            EApp (eStd_ "pure") [ELName name]
-                        C.HereField _ ->
-                            EFApp
-                                (ELName name)
-                                [ EApp
-                                    (egName ["Classes"] "fromStruct")
-                                    [ELName "struct"]
-                                ]
-                        C.DataField loc _ ->
-                            EFApp
-                                (ELName name)
-                                [eGetWordField (ELName "struct") loc]
-                        C.PtrField idx _ ->
-                            EFApp
-                                (ELName name)
-                                [ EDo
-                                    [DoBind "ptr" $ EApp
-                                        (egName ["Untyped"] "getPtr")
-                                        [ EInt $ fromIntegral idx
-                                        , ELName "struct"
-                                        ]
-                                    ]
-                                    (EApp
-                                        (egName ["Classes"] "fromPtr")
-                                        [ EApp
-                                            (egName ["Untyped"] "message")
-                                            [ELName "struct"]
-                                        , ELName "ptr"
-                                        ]
-                                    )
-                                ]
-                  )
-                | Raw.Variant{name, tagValue, locType} <- unionDataCtors
-                ] ++
-                [ ( PVar "_"
-                  , EApp
-                        (eStd_ "pure")
-                        [ EApp
-                            (ELName unknownCtor)
-                            [ EApp
-                                (eStd_ "fromIntegral")
-                                [ELName "tag"]
-                            ]
-                        ]
-                  )
-                ]
-            )
-        ]
-    ]
-declToDecls _thisMod Raw.Enum{typeCtor, dataCtors} =
-    let listCtor = Name.mkSub typeCtor "List_"
-        unknownCtor = Name.mkSub typeCtor "unknown'"
-    in
-    [ DcData Data
-        { dataName = Name.localToUnQ typeCtor
-        , dataNewtype = False
-        , dataInstance = False
-        , typeArgs = []
-        , dataVariants =
-            map enumerantToVariant dataCtors
-            ++
-            [ DataVariant
-                { dvCtorName = Name.localToUnQ unknownCtor
-                , dvArgs = APos
-                    [ TPrim $ C.PrimInt $ C.IntType C.Unsigned C.Sz16 ]
-                }
-            ]
-        , derives =
-            [ "Std_.Show"
-            , "Std_.Read"
-            , "Std_.Eq"
-            , "Generics.Generic"
-            ]
-        }
-    , mkIsWordInstance typeCtor dataCtors unknownCtor
-    -- An Enum instance that just wraps the IsWord instance:
-    , instance_ [] ["Std_"] "Enum" [TLName typeCtor]
-        [ iValue "fromEnum" [PVar "x"] $
-            EApp
-                (eStd_ "fromIntegral")
-                [ EApp
-                    (egName ["Classes"] "toWord")
-                    [ELName "x"]
-                ]
-        , iValue "toEnum" [PVar "x"] $
-            EApp
-                (egName ["Classes"] "fromWord")
-                [ EApp
-                    (eStd_ "fromIntegral")
-                    [ELName "x"]
-                ]
-        ]
-    -- lists:
-    , instance_ [] ["Basics"] "ListElem" [TVar "mut", TLName typeCtor]
-        [ IdData Data
-            { dataName = "List"
-            , typeArgs =
-                [ TVar "mut"
-                , TLName typeCtor
-                ]
-            , dataVariants =
-                [ DataVariant
-                    { dvCtorName = Name.localToUnQ listCtor
-                    , dvArgs = APos
-                        [ TApp
-                            (tgName ["Untyped"] "ListOf")
-                            [ TVar "mut"
-                            , tStd_ "Word16"
-                            ]
-                        ]
-                    }
-                ]
-            , derives = []
-            , dataNewtype = True
-            , dataInstance = False
-            }
-        , iValue "index" [PVar "i", PLCtor listCtor [PVar "l"]] $ EFApp
-            (egName ["Classes"] "fromWord")
-            [ EFApp
-                (eStd_ "fromIntegral")
-                [ EApp
-                    (egName ["Untyped"] "index")
-                    [ ELName "i"
-                    , ELName "l"
-                    ]
-                ]
-            ]
-        , iValue "listFromPtr" [PVar "msg", PVar "ptr"] $ EFApp
-            (ELName listCtor)
-            [ EApp
-                (egName ["Classes"] "fromPtr")
-                [ ELName "msg"
-                , ELName "ptr"
-                ]
-            ]
-        , iValue "toUntypedList" [PLCtor listCtor [PVar "l"]] $ EApp
-            (egName ["Untyped"] "List16")
-            [ELName "l"]
-        , iValue "length" [PLCtor listCtor [PVar "l"]] $ EApp
-            (egName ["Untyped"] "length")
-            [ELName "l"]
-        ]
-    , instance_ [] ["Classes"] "MutListElem" [TVar "s", TLName typeCtor]
-        [ iValue
-            "setIndex"
-            [PVar "elt", PVar "i", PLCtor listCtor [PVar "l"]] $
-            EApp
-                (egName ["Untyped"] "setIndex")
-                [ EApp
-                    (eStd_ "fromIntegral")
-                    [ EApp (egName ["Classes"] "toWord") [ELName "elt"]
-                    ]
-                , ELName "i"
-                , ELName "l"
-                ]
-        , iValue "newList" [PVar "msg", PVar "size"] $ EFApp
-            (ELName listCtor)
-            [ EApp
-                (egName ["Untyped"] "allocList16")
-                [ ELName "msg"
-                , ELName "size"
-                ]
-            ]
-        ]
-    ]
-  where
-    enumerantToVariant variantName =
-        DataVariant
-            { dvCtorName =
-                Name.localToUnQ variantName
-            , dvArgs = APos []
-            }
-declToDecls _thisMod Raw.InterfaceWrapper{typeCtor, typeParams} =
-    let dataCtor = Name.mkSub typeCtor "newtype_" in
-    [ newtypeWrapper typeCtor (map Name.typeVarName typeParams ++ ["msg"]) $ TApp
-        (tStd_ "Maybe")
-        [ TApp
-            (tgName ["Untyped"] "Cap")
-            [TVar "msg"]
-        ]
-    , wrapperFromPtr typeCtor typeParams dataCtor
-    , instance_ [] ["Classes"] "ToPtr"
-        [ TVar "s"
-        , containerTypeToType typeCtor typeParams tMut
-        ]
-        [ iValue "toPtr" [PVar "msg", PLCtor dataCtor [PGCtor (std_ "Nothing") []]]
-            (EApp (eStd_ "pure") [eStd_ "Nothing"])
-        , iValue "toPtr" [PVar "msg", PLCtor dataCtor [PGCtor (std_ "Just") [PVar "cap"]]]
-            (EApp
-                (eStd_ "pure")
-                [ EApp
-                    (eStd_ "Just")
-                    [ EApp
-                        (egName ["Untyped"] "PtrCap")
-                        [ELName "cap"]
-                    ]
-                ]
-            )
-        ]
-    ]
-declToDecls _thisMod Raw.StructWrapper{typeCtor, typeParams} =
-    let dataCtor = Name.mkSub typeCtor "newtype_"
-        containerTypeType = containerTypeToType typeCtor typeParams
-    in
-    [ newtypeWrapper typeCtor (map Name.typeVarName typeParams ++ ["msg"]) $ TApp
-        (tgName ["Untyped"] "Struct")
-        [TVar "msg"]
-
-    -- There are several type classes that are defined for all structs:
-    , instance_ [] ["Classes"] "FromStruct" [TVar "msg", containerTypeType (TVar "msg")]
-        [ iValue "fromStruct" [PVar "struct"] $ EApp
-            (eStd_ "pure")
-            [EApp (ELName dataCtor) [ELName "struct"]]
-        ]
-    , instance_ [] ["Classes"] "ToStruct" [TVar "msg", containerTypeType (TVar "msg")]
-        [ iValue "toStruct" [PLCtor dataCtor [PVar "struct"]]
-            (ELName "struct")
-        ]
-    , instance_ [] ["Untyped"] "HasMessage" [containerTypeType (TVar "mut"), TVar "mut"]
-        [ iValue "message" [PLCtor dataCtor [PVar "struct"]]
-            (EApp (egName ["Untyped"] "message") [ELName "struct"])
-        ]
-    , instance_ [] ["Untyped"] "MessageDefault" [containerTypeType (TVar "mut"), TVar "mut"]
-        [ iValue "messageDefault" [PVar "msg"] $ EFApp
-            (ELName dataCtor)
-            [ EApp
-                (egName ["Untyped"] "messageDefault")
-                [ELName "msg"]
-            ]
-        ]
-    ]
-declToDecls _thisMod Raw.StructInstances{typeCtor, typeParams, dataWordCount, pointerCount} =
-    let listCtor = Name.mkSub typeCtor "List_"
-        dataCtor = Name.mkSub typeCtor "newtype_"
-        containerTypeType = containerTypeToType typeCtor typeParams
-    in
-    [ wrapperFromPtr typeCtor typeParams dataCtor
-    , instance_ [] ["Classes"] "ToPtr"
-        [ TVar "s"
-        , containerTypeType tMut
-        ]
-        [ iValue
-            "toPtr"
-            [PVar "msg", PLCtor dataCtor [PVar "struct"]]
-            (EApp
-                (egName ["Classes"] "toPtr")
-                [ ELName "msg"
-                , ELName "struct"
-                ]
-            )
-        ]
-    , instance_ [] ["Classes"] "Allocate"
-        [ TVar "s"
-        , containerTypeType tMut
-        ]
-        [ iValue "new" [PVar "msg"] $ EFApp
-            (ELName dataCtor)
-            [ EApp
-                (egName ["Untyped"] "allocStruct")
-                [ ELName "msg"
-                , EInt $ fromIntegral dataWordCount
-                , EInt $ fromIntegral pointerCount
-                ]
-            ]
-        ]
-    , instance_ [] ["Basics"] "ListElem"
-        [ TVar "mut"
-        , containerTypeType $ TVar "mut"
-        ]
-        [ IdData Data
-            { dataName = "List"
-            , typeArgs =
-                [ TVar "mut"
-                , containerTypeType (TVar "mut")
-                ]
-            , dataVariants =
-                [ DataVariant
-                    { dvCtorName = Name.localToUnQ listCtor
-                    , dvArgs = APos
-                        [ TApp
-                            (tgName ["Untyped"] "ListOf")
-                            [ TVar "mut"
-                            , TApp
-                                (tgName ["Untyped"] "Struct")
-                                [TVar "mut"]
-                            ]
-                        ]
-                    }
-                ]
-            , derives = []
-            , dataNewtype = True
-            , dataInstance = False
-            }
-        , iValue "listFromPtr" [PVar "msg", PVar "ptr"] $ EFApp
-            (ELName listCtor)
-            [ EApp
-                (egName ["Classes"] "fromPtr")
-                [ELName "msg", ELName "ptr"]
-            ]
-        , iValue "toUntypedList" [PLCtor listCtor [PVar "l"]] $ EApp
-            (egName ["Untyped"] "ListStruct")
-            [ELName "l"]
-        , iValue "length" [PLCtor listCtor [PVar "l"]] $ EApp
-            (egName ["Untyped"] "length")
-            [ELName "l"]
-        , iValue "index" [PVar "i", PLCtor listCtor [PVar "l"]] $ EDo
-            [ DoBind "elt" $ EApp
-                (egName ["Untyped"] "index")
-                [ ELName "i"
-                , ELName "l"
-                ]
-            ]
-            ( EApp
-                (egName ["Classes"] "fromStruct")
-                [ELName "elt"]
-            )
-        ]
-    , instance_ [] ["Basics"] "MutListElem"
-        [ TVar "s"
-        , containerTypeType tMut
-        ]
-        [ iValue "setIndex"
-            [ PLCtor dataCtor [PVar "elt"]
-            , PVar "i"
-            , PLCtor listCtor [PVar "l"]
-            ]
-            (EApp
-                (egName ["Untyped"] "setIndex")
-                [ ELName "elt"
-                , ELName "i"
-                , ELName "l"
-                ]
-            )
-        , iValue "newList" [PVar "msg", PVar "len"] $ EFApp
-            (ELName listCtor)
-            [ EApp
-                (egName ["Untyped"] "allocCompositeList")
-                [ ELName "msg"
-                , EInt $ fromIntegral dataWordCount
-                , EInt $ fromIntegral pointerCount
-                , ELName "len"
-                ]
-            ]
-        ]
-    ]
-declToDecls thisMod Raw.Getter{fieldName, fieldLocType, containerType, typeParams} =
-    let containerDataCtor = Name.mkSub containerType "newtype_"
-        fieldType = typeToType thisMod (C.fieldType fieldLocType) (TVar "msg")
-        isPtrType = case C.fieldType fieldLocType of
-            C.PtrType _       -> True
-            C.CompositeType _ -> True
-            _                 -> False
-    in
-    [ DcValue
-        { typ = TCtx
-            (readCtx "m" "msg"
-                : if isPtrType
-                    then
-                        [ case fieldLocType of
-                            C.HereField _ ->
-                                TApp (tgName ["Classes"] "FromStruct") [TVar "msg", fieldType]
-                            _ ->
-                                TApp (tgName ["Classes"] "FromPtr") [TVar "msg", fieldType]
-                        ]
-                    else []
-            )
-            (TFn
-                [ containerTypeToType containerType typeParams (TVar "msg")
-                , TApp (TVar "m") [fieldType]
-                ]
-            )
-        , def = DfValue
-            { name = Name.getterName fieldName
-            , params = [PLCtor containerDataCtor [PVar "struct"]]
-            , value = case fieldLocType of
-                C.DataField dataLoc  _ ->
-                    eGetWordField (ELName "struct") dataLoc
-                C.PtrField idx _ -> EDo
-                    [ DoBind "ptr" $ EApp
-                        (egName ["Untyped"] "getPtr")
-                        [ EInt (fromIntegral idx)
-                        , ELName "struct"
-                        ]
-                    ]
-                    (EApp
-                        (egName ["Classes"] "fromPtr")
-                        [ EApp
-                            (egName ["Untyped"] "message")
-                            [ELName "struct"]
-                        , ELName "ptr"
-                        ]
-                    )
-                C.HereField _ ->
-                    EApp
-                        (egName ["Classes"] "fromStruct")
-                        [ELName "struct"]
-                C.VoidField ->
-                    EApp
-                        (eStd_ "pure")
-                        [ETup []]
-            }
-        }
-    ]
-declToDecls thisMod Raw.Setter{fieldName, fieldLocType, containerType, typeParams, tag} =
-    -- XXX: the way this is organized is a little gross; conceptually we have
-    -- two kinds of setters:
-    --
-    -- * Those that actually take an argument, and return unit.
-    -- * Those that are groups, in which case they don't take an argument,
-    --   and return the value.
-    --
-    -- The latter are only actually useful if the group is a union member,
-    -- but we generate them regardless.
-    --
-    -- The below is a little ugly in that there's a bit to much conditional
-    -- logic strewn about because of the above.
-    let containerDataCtor = Name.mkSub containerType "newtype_"
-        fieldType = typeToType
-            thisMod
-            (C.fieldType fieldLocType)
-            tMut
-        isPtrType = case C.fieldType fieldLocType of
-            C.PtrType _       -> True
-            C.CompositeType _ -> True
-            _                 -> False
-        containerTypeType = containerTypeToType containerType typeParams tMut
-    in
-    [ DcValue
-        { typ = TCtx
-            (rwCtx "m" "s"
-                : if isPtrType
-                    then
-                        [ case fieldLocType of
-                            C.HereField _ ->
-                                TApp (tgName ["Classes"] "FromStruct") [tMut, fieldType]
-                            _ ->
-                                TApp (tgName ["Classes"] "ToPtr") [TVar "s", fieldType]
-                        ]
-                    else
-                        []
-            )
-            (case fieldLocType of
-                C.HereField _ -> TFn
-                    [ containerTypeType
-                    , TApp (TVar "m") [fieldType]
-                    ]
-                C.VoidField -> TFn
-                    -- We don't need to pass in the redundant () value.
-                    [ containerTypeType
-                    , TApp (TVar "m") [fieldType]
-                    ]
-                _ -> TFn
-                    [ containerTypeType
-                    , fieldType
-                    , TApp (TVar "m") [TUnit]
-                    ]
-            )
-        , def = DfValue
-            { name = Name.setterName fieldName
-            , params =
-                case fieldLocType of
-                    C.HereField _ ->
-                        [ PLCtor containerDataCtor [PVar "struct"] ]
-                    C.VoidField ->
-                        [ PLCtor containerDataCtor [PVar "struct"] ]
-                    _ ->
-                        [ PLCtor containerDataCtor [PVar "struct"]
-                        , PVar "value"
-                        ]
-            , value =
-                case tag of
-                    Just tagSetter ->
-                        EDo
-                            [DoE $ eSetTag tagSetter]
-                            (eSetValue fieldLocType)
-                    Nothing ->
-                        eSetValue fieldLocType
-            }
-        }
-    ]
-declToDecls _thisMod Raw.HasFn{fieldName, containerType, typeParams, ptrIndex} =
-    let containerDataCtor = Name.mkSub containerType "newtype_"
-        containerTypeType = containerTypeToType containerType typeParams (TVar "msg")
-    in
-    [ DcValue
-        { typ = TCtx
-            [readCtx "m" "msg"]
-            (TFn
-                [ containerTypeType
-                , TApp (TVar "m") [tStd_ "Bool"]
-                ]
-            )
-        , def = DfValue
-            { name = Name.hasFnName fieldName
-            , params = [PLCtor containerDataCtor [PVar "struct"]]
-            , value = EFApp (eStd_ "isJust")
-                [ EApp
-                    (egName ["Untyped"] "getPtr")
-                    [ EInt $ fromIntegral ptrIndex
-                    , ELName "struct"
-                    ]
-                ]
-            }
-        }
-    ]
-declToDecls thisMod Raw.NewFn{fieldName, containerType, typeParams, fieldLocType, newFnType} =
-    -- TODO(cleanup): I(zenhack) am a little unhappy with having several case
-    -- expressions to distinguish struct vs non-struct; we should refactor.
-    let fieldType = typeToType
-            thisMod
-            (C.fieldType fieldLocType)
-            tMut
-        containerTypeType = containerTypeToType containerType typeParams tMut
-    in
-    [ DcValue
-        { typ = TCtx
-            [rwCtx "m" "s"]
-            (TFn $ concat
-                [ case newFnType of
-                    -- length
-                    Raw.NewStruct -> []
-                    _             -> [tStd_ "Int"]
-                , [containerTypeType]
-                , [TApp (TVar "m") [fieldType]]
-                ]
-            )
-        , def = DfValue
-            { name = Name.newFnName fieldName
-            , params =
-                case newFnType of
-                    Raw.NewStruct -> [PVar "struct"]
-                    _             -> [PVar "len", PVar "struct"]
-            , value = EDo
-                [ DoBind "result" $
-                    let message = EApp (egName ["Untyped"] "message") [ELName "struct"]
-                    in case newFnType of
-                        Raw.NewStruct -> EApp (egName ["Classes"] "new") [message]
-                        Raw.NewList -> EApp (egName ["Classes"] "newList") [message, ELName "len"]
-                        Raw.NewText -> EApp (egName ["Basics"] "newText") [message, ELName "len"]
-                        Raw.NewData -> EApp (egName ["Basics"] "newData") [message, ELName "len"]
-                , DoE $ EApp
-                    (ELName $ Name.mkLocal Name.emptyNS (Name.setterName fieldName))
-                    [ ELName "struct"
-                    , ELName "result"
-                    ]
-                ]
-                (EApp (eStd_ "pure") [ELName "result"])
-            }
-        }
-    ]
-declToDecls _thisMod Raw.Constant{ name, value=C.VoidValue } =
-    [ DcValue
-        { typ = TUnit
-        , def = DfValue
-            { name = Name.localToUnQ name
-            , params = []
-            , value = ETup []
-            }
-        }
-    ]
-declToDecls thisMod Raw.Constant{ name, value=C.WordValue ty val } =
-    [ DcValue
-        { typ = typeToType thisMod (C.WordType ty) tConst
-        , def = DfValue
-            { name = Name.localToUnQ name
-            , params = []
-            , value = EApp
-                (egName ["Classes"] "fromWord")
-                [EInt $ fromIntegral val]
-            }
-        }
-    ]
-declToDecls thisMod Raw.Constant{ name, value=C.PtrValue ty val } =
-    [ DcValue
-        { typ = typeToType thisMod (C.PtrType ty) tConst
-        , def = DfValue
-            { name = Name.localToUnQ name
-            , params = []
-            , value = EApp
-                (egName ["GenHelpers"] "getPtrConst")
-                [ETypeAnno (EBytes (makePtrBytes val)) (tgName ["BS"] "ByteString")]
-            }
-        }
-    ]
-
-containerTypeToType :: Name.LocalQ -> [Name.UnQ] -> Type -> Type
-containerTypeToType name params msgTy =
-    TApp (TLName name) $ [ TVar (Name.typeVarName p) | p <- params ] ++ [msgTy]
-
-
-eSetValue :: C.FieldLocType (C.ListBrand Name.CapnpQ) Name.CapnpQ -> Exp
-eSetValue = \case
-    C.DataField dataLoc ty ->
-        eSetWordField
-            (ELName "struct")
-            (ETypeAnno
-                (EApp
-                    (eStd_ "fromIntegral")
-                    [EApp
-                        (egName ["Classes"] "toWord")
-                        [ELName "value"]
-                    ]
-                )
-                (tStd_ $ fromString $ "Word" <> show (C.dataFieldSize ty))
-            )
-            dataLoc
-    C.PtrField idx _ -> EDo
-        [ DoBind "ptr" $ EApp
-            (egName ["Classes"] "toPtr")
-            [ EApp
-                (egName ["Untyped"] "message")
-                [ELName "struct"]
-            , ELName "value"
-            ]
-        ]
-        (EApp
-            (egName ["Untyped"] "setPtr")
-            [ ELName "ptr"
-            , EInt (fromIntegral idx)
-            , ELName "struct"
-            ]
-        )
-    C.HereField _ ->
-        -- We actually just fetch the field in this case; this only happens for
-        -- groups (and unions, but the tag is handled separately in that case).
-        EApp
-            (egName ["Classes"] "fromStruct")
-            [ELName "struct"]
-    C.VoidField ->
-        EApp
-            (eStd_ "pure")
-            [ETup []]
-
-eSetTag :: Raw.TagSetter -> Exp
-eSetTag Raw.TagSetter{tagOffset, tagValue} =
-    eSetWordField
-        (ELName "struct")
-        (ETypeAnno
-            (EInt $ fromIntegral tagValue)
-            (TPrim $ C.PrimInt $ C.IntType C.Unsigned C.Sz16)
-        )
-        (Raw.tagOffsetToDataLoc tagOffset)
-
-eSetWordField :: Exp -> Exp -> C.DataLoc -> Exp
-eSetWordField struct value C.DataLoc{dataIdx, dataOff, dataDef} =
-    EApp
-        (egName ["GenHelpers"] "setWordField")
-        [ struct
-        , value
-        , EInt $ fromIntegral dataIdx
-        , EInt $ fromIntegral dataOff
-        , EInt $ fromIntegral dataDef
-        ]
-
--- | Make an instance of the IsWord type class for an enum.
-mkIsWordInstance :: Name.LocalQ -> [Name.LocalQ] -> Name.LocalQ -> Decl
-mkIsWordInstance typeCtor dataCtors unknownCtor =
-    instance_ [] ["Classes"] "IsWord" [TLName typeCtor] $
-        [ iValue "fromWord" [PVar "n"] $
-            ECase
-                (ETypeAnno
-                    (EApp (eStd_ "fromIntegral") [euName "n"])
-                    (TPrim $ C.PrimInt $ C.IntType C.Unsigned C.Sz16)
-                ) $
-                [ (PInt i, ELName ctor) | (i, ctor) <- zip [0..] dataCtors]
-                ++
-                [ (PVar "tag", EApp (ELName unknownCtor) [euName "tag"]) ]
-        ] ++
-        [ IdValue $ DfValue
-            { name = "toWord"
-            , params = [PLCtor ctor []]
-            , value = EInt i
-            }
-        | (i, ctor) <- zip [0..] dataCtors
-        ] ++
-        [ IdValue $ DfValue
-            { name = "toWord"
-            , params =
-                [ PLCtor unknownCtor [PVar "tag"] ]
-            , value =
-                EApp
-                    (eStd_ "fromIntegral")
-                    [ELName "tag"]
-            }
-        ]
-
-newtypeWrapper :: Name.LocalQ -> [T.Text] -> Type -> Decl
-newtypeWrapper typeCtor typeArgs wrappedType =
-    DcData Data
-        { dataName = Name.localToUnQ typeCtor
-        , dataNewtype = True
-        , dataInstance = False
-        , typeArgs = map TVar typeArgs
-        , dataVariants =
-            [ DataVariant
-                { dvCtorName = Name.localToUnQ $ Name.mkSub typeCtor "newtype_"
-                , dvArgs = APos [ wrappedType ]
-                }
-            ]
-        , derives = []
-        }
-
-wrapperFromPtr :: Name.LocalQ -> [Name.UnQ] -> Name.LocalQ -> Decl
-wrapperFromPtr typeCtor typeParams dataCtor =
-    instance_ [] ["Classes"] "FromPtr"
-        [ TVar "msg", containerTypeToType typeCtor typeParams (TVar "msg") ]
-        [ iValue "fromPtr" [PVar "msg", PVar "ptr"] $ EFApp
-            (ELName dataCtor)
-            [ EApp
-                (egName ["Classes"] "fromPtr")
-                [ ELName "msg"
-                , ELName "ptr"
-                ]
-            ]
-        ]
-
-nameToType :: Word64 -> Name.CapnpQ -> Type
-nameToType thisMod Name.CapnpQ{local, fileId} =
-    if fileId == thisMod
-        then TLName local
-        else tgName
-            (map Name.renderUnQ $ idToModule fileId)
-            local
-
-typeToType :: Word64 -> C.Type (C.ListBrand Name.CapnpQ) Name.CapnpQ -> Type -> Type
-typeToType thisMod ty msgTy = case ty of
-    C.VoidType -> TUnit
-    C.WordType (C.PrimWord ty) -> TPrim ty
-    C.WordType (C.EnumType typeId) -> nameToType thisMod typeId
-    C.PtrType (C.ListOf elt) ->
-        TApp (tgName ["Basics"] "List")
-            [ msgTy
-            , typeToType thisMod elt msgTy
-            ]
-    C.PtrType (C.PrimPtr C.PrimText) ->
-        appV $ tgName ["Basics"] "Text"
-    C.PtrType (C.PrimPtr C.PrimData) ->
-        appV $ tgName ["Basics"] "Data"
-    C.PtrType (C.PtrComposite (C.StructType typeId typeParams)) ->
-        namedType typeId typeParams
-    C.PtrType (C.PtrInterface (C.InterfaceType typeId typeParams)) ->
-        namedType typeId typeParams
-    C.PtrType (C.PrimPtr (C.PrimAnyPtr _)) ->
-        TApp (tStd_ "Maybe") [appV $ tgName ["Untyped"] "Ptr"]
-    C.PtrType (C.PtrParam C.TypeParamRef{paramName}) ->
-        TVar (Name.typeVarName paramName)
-    C.CompositeType (C.StructType typeId typeParams) ->
-        namedType typeId typeParams
-  where
-    appV t = TApp t [msgTy]
-    namedType :: Name.CapnpQ -> C.ListBrand Name.CapnpQ -> Type
-    namedType name (C.ListBrand [])     = appV $ nameToType thisMod name
-    namedType name (C.ListBrand args) =
-        TApp
-            (nameToType thisMod name)
-            (map (\t -> typeToType thisMod (C.PtrType t) msgTy) args ++ [msgTy])
diff --git a/cmd/capnpc-haskell/Trans/ToHaskellCommon.hs b/cmd/capnpc-haskell/Trans/ToHaskellCommon.hs
--- a/cmd/capnpc-haskell/Trans/ToHaskellCommon.hs
+++ b/cmd/capnpc-haskell/Trans/ToHaskellCommon.hs
@@ -21,7 +21,7 @@
 import Capnp.New.Classes (encode)
 import Capnp.Repr.Parsed (Parsed)
 
-import qualified Capnp
+import qualified Capnp.New        as Capnp
 import qualified Capnp.New.Basics as B
 import qualified IR.Common        as C
 import qualified IR.Name          as Name
diff --git a/examples/gen/lib/Capnp/Gen/ById/X85150b117366d14b.hs b/examples/gen/lib/Capnp/Gen/ById/X85150b117366d14b.hs
deleted file mode 100644
--- a/examples/gen/lib/Capnp/Gen/ById/X85150b117366d14b.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.X85150b117366d14b(module Capnp.Gen.Calculator) where
-import Capnp.Gen.Calculator
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/examples/gen/lib/Capnp/Gen/ById/X85150b117366d14b/Pure.hs b/examples/gen/lib/Capnp/Gen/ById/X85150b117366d14b/Pure.hs
deleted file mode 100644
--- a/examples/gen/lib/Capnp/Gen/ById/X85150b117366d14b/Pure.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.X85150b117366d14b.Pure(module Capnp.Gen.Calculator.Pure) where
-import Capnp.Gen.Calculator.Pure
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/examples/gen/lib/Capnp/Gen/ById/Xd0a87f36fa0182f5.hs b/examples/gen/lib/Capnp/Gen/ById/Xd0a87f36fa0182f5.hs
deleted file mode 100644
--- a/examples/gen/lib/Capnp/Gen/ById/Xd0a87f36fa0182f5.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.Xd0a87f36fa0182f5(module Capnp.Gen.Echo) where
-import Capnp.Gen.Echo
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/examples/gen/lib/Capnp/Gen/ById/Xd0a87f36fa0182f5/Pure.hs b/examples/gen/lib/Capnp/Gen/ById/Xd0a87f36fa0182f5/Pure.hs
deleted file mode 100644
--- a/examples/gen/lib/Capnp/Gen/ById/Xd0a87f36fa0182f5/Pure.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.Xd0a87f36fa0182f5.Pure(module Capnp.Gen.Echo.Pure) where
-import Capnp.Gen.Echo.Pure
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/examples/gen/lib/Capnp/Gen/Calculator.hs b/examples/gen/lib/Capnp/Gen/Calculator.hs
deleted file mode 100644
--- a/examples/gen/lib/Capnp/Gen/Calculator.hs
+++ /dev/null
@@ -1,623 +0,0 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Calculator where
-import qualified Capnp.Message as Message
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Basics as Basics
-import qualified Capnp.GenHelpers as GenHelpers
-import qualified Capnp.Classes as Classes
-import qualified GHC.Generics as Generics
-import qualified Capnp.Bits as Std_
-import qualified Data.Maybe as Std_
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-newtype Calculator msg
-    = Calculator'newtype_ (Std_.Maybe (Untyped.Cap msg))
-instance (Classes.FromPtr msg (Calculator msg)) where
-    fromPtr msg ptr = (Calculator'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Calculator (Message.Mut s))) where
-    toPtr msg (Calculator'newtype_ (Std_.Nothing)) = (Std_.pure Std_.Nothing)
-    toPtr msg (Calculator'newtype_ (Std_.Just cap)) = (Std_.pure (Std_.Just (Untyped.PtrCap cap)))
-newtype Calculator'evaluate'params msg
-    = Calculator'evaluate'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Calculator'evaluate'params msg)) where
-    fromStruct struct = (Std_.pure (Calculator'evaluate'params'newtype_ struct))
-instance (Classes.ToStruct msg (Calculator'evaluate'params msg)) where
-    toStruct (Calculator'evaluate'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (Calculator'evaluate'params mut) mut) where
-    message (Calculator'evaluate'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Calculator'evaluate'params mut) mut) where
-    messageDefault msg = (Calculator'evaluate'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Calculator'evaluate'params msg)) where
-    fromPtr msg ptr = (Calculator'evaluate'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Calculator'evaluate'params (Message.Mut s))) where
-    toPtr msg (Calculator'evaluate'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Calculator'evaluate'params (Message.Mut s))) where
-    new msg = (Calculator'evaluate'params'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Calculator'evaluate'params mut)) where
-    newtype List mut (Calculator'evaluate'params mut)
-        = Calculator'evaluate'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Calculator'evaluate'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Calculator'evaluate'params'List_ l) = (Untyped.ListStruct l)
-    length (Calculator'evaluate'params'List_ l) = (Untyped.length l)
-    index i (Calculator'evaluate'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Calculator'evaluate'params (Message.Mut s))) where
-    setIndex (Calculator'evaluate'params'newtype_ elt) i (Calculator'evaluate'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Calculator'evaluate'params'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Calculator'evaluate'params'expression :: ((Untyped.ReadCtx m msg)
-                                             ,(Classes.FromPtr msg (Expression msg))) => (Calculator'evaluate'params msg) -> (m (Expression msg))
-get_Calculator'evaluate'params'expression (Calculator'evaluate'params'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Calculator'evaluate'params'expression :: ((Untyped.RWCtx m s)
-                                             ,(Classes.ToPtr s (Expression (Message.Mut s)))) => (Calculator'evaluate'params (Message.Mut s)) -> (Expression (Message.Mut s)) -> (m ())
-set_Calculator'evaluate'params'expression (Calculator'evaluate'params'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Calculator'evaluate'params'expression :: ((Untyped.ReadCtx m msg)) => (Calculator'evaluate'params msg) -> (m Std_.Bool)
-has_Calculator'evaluate'params'expression (Calculator'evaluate'params'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Calculator'evaluate'params'expression :: ((Untyped.RWCtx m s)) => (Calculator'evaluate'params (Message.Mut s)) -> (m (Expression (Message.Mut s)))
-new_Calculator'evaluate'params'expression struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Calculator'evaluate'params'expression struct result)
-    (Std_.pure result)
-    )
-newtype Calculator'evaluate'results msg
-    = Calculator'evaluate'results'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Calculator'evaluate'results msg)) where
-    fromStruct struct = (Std_.pure (Calculator'evaluate'results'newtype_ struct))
-instance (Classes.ToStruct msg (Calculator'evaluate'results msg)) where
-    toStruct (Calculator'evaluate'results'newtype_ struct) = struct
-instance (Untyped.HasMessage (Calculator'evaluate'results mut) mut) where
-    message (Calculator'evaluate'results'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Calculator'evaluate'results mut) mut) where
-    messageDefault msg = (Calculator'evaluate'results'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Calculator'evaluate'results msg)) where
-    fromPtr msg ptr = (Calculator'evaluate'results'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Calculator'evaluate'results (Message.Mut s))) where
-    toPtr msg (Calculator'evaluate'results'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Calculator'evaluate'results (Message.Mut s))) where
-    new msg = (Calculator'evaluate'results'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Calculator'evaluate'results mut)) where
-    newtype List mut (Calculator'evaluate'results mut)
-        = Calculator'evaluate'results'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Calculator'evaluate'results'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Calculator'evaluate'results'List_ l) = (Untyped.ListStruct l)
-    length (Calculator'evaluate'results'List_ l) = (Untyped.length l)
-    index i (Calculator'evaluate'results'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Calculator'evaluate'results (Message.Mut s))) where
-    setIndex (Calculator'evaluate'results'newtype_ elt) i (Calculator'evaluate'results'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Calculator'evaluate'results'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Calculator'evaluate'results'value :: ((Untyped.ReadCtx m msg)
-                                         ,(Classes.FromPtr msg (Value msg))) => (Calculator'evaluate'results msg) -> (m (Value msg))
-get_Calculator'evaluate'results'value (Calculator'evaluate'results'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Calculator'evaluate'results'value :: ((Untyped.RWCtx m s)
-                                         ,(Classes.ToPtr s (Value (Message.Mut s)))) => (Calculator'evaluate'results (Message.Mut s)) -> (Value (Message.Mut s)) -> (m ())
-set_Calculator'evaluate'results'value (Calculator'evaluate'results'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Calculator'evaluate'results'value :: ((Untyped.ReadCtx m msg)) => (Calculator'evaluate'results msg) -> (m Std_.Bool)
-has_Calculator'evaluate'results'value (Calculator'evaluate'results'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-newtype Calculator'defFunction'params msg
-    = Calculator'defFunction'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Calculator'defFunction'params msg)) where
-    fromStruct struct = (Std_.pure (Calculator'defFunction'params'newtype_ struct))
-instance (Classes.ToStruct msg (Calculator'defFunction'params msg)) where
-    toStruct (Calculator'defFunction'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (Calculator'defFunction'params mut) mut) where
-    message (Calculator'defFunction'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Calculator'defFunction'params mut) mut) where
-    messageDefault msg = (Calculator'defFunction'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Calculator'defFunction'params msg)) where
-    fromPtr msg ptr = (Calculator'defFunction'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Calculator'defFunction'params (Message.Mut s))) where
-    toPtr msg (Calculator'defFunction'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Calculator'defFunction'params (Message.Mut s))) where
-    new msg = (Calculator'defFunction'params'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (Calculator'defFunction'params mut)) where
-    newtype List mut (Calculator'defFunction'params mut)
-        = Calculator'defFunction'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Calculator'defFunction'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Calculator'defFunction'params'List_ l) = (Untyped.ListStruct l)
-    length (Calculator'defFunction'params'List_ l) = (Untyped.length l)
-    index i (Calculator'defFunction'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Calculator'defFunction'params (Message.Mut s))) where
-    setIndex (Calculator'defFunction'params'newtype_ elt) i (Calculator'defFunction'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Calculator'defFunction'params'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-get_Calculator'defFunction'params'paramCount :: ((Untyped.ReadCtx m msg)) => (Calculator'defFunction'params msg) -> (m Std_.Int32)
-get_Calculator'defFunction'params'paramCount (Calculator'defFunction'params'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Calculator'defFunction'params'paramCount :: ((Untyped.RWCtx m s)) => (Calculator'defFunction'params (Message.Mut s)) -> Std_.Int32 -> (m ())
-set_Calculator'defFunction'params'paramCount (Calculator'defFunction'params'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-get_Calculator'defFunction'params'body :: ((Untyped.ReadCtx m msg)
-                                          ,(Classes.FromPtr msg (Expression msg))) => (Calculator'defFunction'params msg) -> (m (Expression msg))
-get_Calculator'defFunction'params'body (Calculator'defFunction'params'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Calculator'defFunction'params'body :: ((Untyped.RWCtx m s)
-                                          ,(Classes.ToPtr s (Expression (Message.Mut s)))) => (Calculator'defFunction'params (Message.Mut s)) -> (Expression (Message.Mut s)) -> (m ())
-set_Calculator'defFunction'params'body (Calculator'defFunction'params'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Calculator'defFunction'params'body :: ((Untyped.ReadCtx m msg)) => (Calculator'defFunction'params msg) -> (m Std_.Bool)
-has_Calculator'defFunction'params'body (Calculator'defFunction'params'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Calculator'defFunction'params'body :: ((Untyped.RWCtx m s)) => (Calculator'defFunction'params (Message.Mut s)) -> (m (Expression (Message.Mut s)))
-new_Calculator'defFunction'params'body struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Calculator'defFunction'params'body struct result)
-    (Std_.pure result)
-    )
-newtype Calculator'defFunction'results msg
-    = Calculator'defFunction'results'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Calculator'defFunction'results msg)) where
-    fromStruct struct = (Std_.pure (Calculator'defFunction'results'newtype_ struct))
-instance (Classes.ToStruct msg (Calculator'defFunction'results msg)) where
-    toStruct (Calculator'defFunction'results'newtype_ struct) = struct
-instance (Untyped.HasMessage (Calculator'defFunction'results mut) mut) where
-    message (Calculator'defFunction'results'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Calculator'defFunction'results mut) mut) where
-    messageDefault msg = (Calculator'defFunction'results'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Calculator'defFunction'results msg)) where
-    fromPtr msg ptr = (Calculator'defFunction'results'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Calculator'defFunction'results (Message.Mut s))) where
-    toPtr msg (Calculator'defFunction'results'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Calculator'defFunction'results (Message.Mut s))) where
-    new msg = (Calculator'defFunction'results'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Calculator'defFunction'results mut)) where
-    newtype List mut (Calculator'defFunction'results mut)
-        = Calculator'defFunction'results'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Calculator'defFunction'results'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Calculator'defFunction'results'List_ l) = (Untyped.ListStruct l)
-    length (Calculator'defFunction'results'List_ l) = (Untyped.length l)
-    index i (Calculator'defFunction'results'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Calculator'defFunction'results (Message.Mut s))) where
-    setIndex (Calculator'defFunction'results'newtype_ elt) i (Calculator'defFunction'results'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Calculator'defFunction'results'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Calculator'defFunction'results'func :: ((Untyped.ReadCtx m msg)
-                                           ,(Classes.FromPtr msg (Function msg))) => (Calculator'defFunction'results msg) -> (m (Function msg))
-get_Calculator'defFunction'results'func (Calculator'defFunction'results'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Calculator'defFunction'results'func :: ((Untyped.RWCtx m s)
-                                           ,(Classes.ToPtr s (Function (Message.Mut s)))) => (Calculator'defFunction'results (Message.Mut s)) -> (Function (Message.Mut s)) -> (m ())
-set_Calculator'defFunction'results'func (Calculator'defFunction'results'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Calculator'defFunction'results'func :: ((Untyped.ReadCtx m msg)) => (Calculator'defFunction'results msg) -> (m Std_.Bool)
-has_Calculator'defFunction'results'func (Calculator'defFunction'results'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-newtype Calculator'getOperator'params msg
-    = Calculator'getOperator'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Calculator'getOperator'params msg)) where
-    fromStruct struct = (Std_.pure (Calculator'getOperator'params'newtype_ struct))
-instance (Classes.ToStruct msg (Calculator'getOperator'params msg)) where
-    toStruct (Calculator'getOperator'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (Calculator'getOperator'params mut) mut) where
-    message (Calculator'getOperator'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Calculator'getOperator'params mut) mut) where
-    messageDefault msg = (Calculator'getOperator'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Calculator'getOperator'params msg)) where
-    fromPtr msg ptr = (Calculator'getOperator'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Calculator'getOperator'params (Message.Mut s))) where
-    toPtr msg (Calculator'getOperator'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Calculator'getOperator'params (Message.Mut s))) where
-    new msg = (Calculator'getOperator'params'newtype_ <$> (Untyped.allocStruct msg 1 0))
-instance (Basics.ListElem mut (Calculator'getOperator'params mut)) where
-    newtype List mut (Calculator'getOperator'params mut)
-        = Calculator'getOperator'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Calculator'getOperator'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Calculator'getOperator'params'List_ l) = (Untyped.ListStruct l)
-    length (Calculator'getOperator'params'List_ l) = (Untyped.length l)
-    index i (Calculator'getOperator'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Calculator'getOperator'params (Message.Mut s))) where
-    setIndex (Calculator'getOperator'params'newtype_ elt) i (Calculator'getOperator'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Calculator'getOperator'params'List_ <$> (Untyped.allocCompositeList msg 1 0 len))
-get_Calculator'getOperator'params'op :: ((Untyped.ReadCtx m msg)) => (Calculator'getOperator'params msg) -> (m Operator)
-get_Calculator'getOperator'params'op (Calculator'getOperator'params'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Calculator'getOperator'params'op :: ((Untyped.RWCtx m s)) => (Calculator'getOperator'params (Message.Mut s)) -> Operator -> (m ())
-set_Calculator'getOperator'params'op (Calculator'getOperator'params'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-newtype Calculator'getOperator'results msg
-    = Calculator'getOperator'results'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Calculator'getOperator'results msg)) where
-    fromStruct struct = (Std_.pure (Calculator'getOperator'results'newtype_ struct))
-instance (Classes.ToStruct msg (Calculator'getOperator'results msg)) where
-    toStruct (Calculator'getOperator'results'newtype_ struct) = struct
-instance (Untyped.HasMessage (Calculator'getOperator'results mut) mut) where
-    message (Calculator'getOperator'results'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Calculator'getOperator'results mut) mut) where
-    messageDefault msg = (Calculator'getOperator'results'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Calculator'getOperator'results msg)) where
-    fromPtr msg ptr = (Calculator'getOperator'results'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Calculator'getOperator'results (Message.Mut s))) where
-    toPtr msg (Calculator'getOperator'results'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Calculator'getOperator'results (Message.Mut s))) where
-    new msg = (Calculator'getOperator'results'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Calculator'getOperator'results mut)) where
-    newtype List mut (Calculator'getOperator'results mut)
-        = Calculator'getOperator'results'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Calculator'getOperator'results'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Calculator'getOperator'results'List_ l) = (Untyped.ListStruct l)
-    length (Calculator'getOperator'results'List_ l) = (Untyped.length l)
-    index i (Calculator'getOperator'results'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Calculator'getOperator'results (Message.Mut s))) where
-    setIndex (Calculator'getOperator'results'newtype_ elt) i (Calculator'getOperator'results'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Calculator'getOperator'results'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Calculator'getOperator'results'func :: ((Untyped.ReadCtx m msg)
-                                           ,(Classes.FromPtr msg (Function msg))) => (Calculator'getOperator'results msg) -> (m (Function msg))
-get_Calculator'getOperator'results'func (Calculator'getOperator'results'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Calculator'getOperator'results'func :: ((Untyped.RWCtx m s)
-                                           ,(Classes.ToPtr s (Function (Message.Mut s)))) => (Calculator'getOperator'results (Message.Mut s)) -> (Function (Message.Mut s)) -> (m ())
-set_Calculator'getOperator'results'func (Calculator'getOperator'results'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Calculator'getOperator'results'func :: ((Untyped.ReadCtx m msg)) => (Calculator'getOperator'results msg) -> (m Std_.Bool)
-has_Calculator'getOperator'results'func (Calculator'getOperator'results'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-newtype Expression msg
-    = Expression'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Expression msg)) where
-    fromStruct struct = (Std_.pure (Expression'newtype_ struct))
-instance (Classes.ToStruct msg (Expression msg)) where
-    toStruct (Expression'newtype_ struct) = struct
-instance (Untyped.HasMessage (Expression mut) mut) where
-    message (Expression'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Expression mut) mut) where
-    messageDefault msg = (Expression'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Expression msg)) where
-    fromPtr msg ptr = (Expression'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Expression (Message.Mut s))) where
-    toPtr msg (Expression'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Expression (Message.Mut s))) where
-    new msg = (Expression'newtype_ <$> (Untyped.allocStruct msg 2 2))
-instance (Basics.ListElem mut (Expression mut)) where
-    newtype List mut (Expression mut)
-        = Expression'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Expression'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Expression'List_ l) = (Untyped.ListStruct l)
-    length (Expression'List_ l) = (Untyped.length l)
-    index i (Expression'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Expression (Message.Mut s))) where
-    setIndex (Expression'newtype_ elt) i (Expression'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Expression'List_ <$> (Untyped.allocCompositeList msg 2 2 len))
-data Expression' (mut :: Message.Mutability)
-    = Expression'literal Std_.Double
-    | Expression'previousResult (Value mut)
-    | Expression'parameter Std_.Word32
-    | Expression'call (Expression'call mut)
-    | Expression'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Expression' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 4)
-        case tag of
-            0 ->
-                (Expression'literal <$> (GenHelpers.getWordField struct 0 0 0))
-            1 ->
-                (Expression'previousResult <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            2 ->
-                (Expression'parameter <$> (GenHelpers.getWordField struct 0 0 0))
-            3 ->
-                (Expression'call <$> (Classes.fromStruct struct))
-            _ ->
-                (Std_.pure (Expression'unknown' (Std_.fromIntegral tag)))
-        )
-get_Expression' :: ((Untyped.ReadCtx m msg)
-                   ,(Classes.FromStruct msg (Expression' msg))) => (Expression msg) -> (m (Expression' msg))
-get_Expression' (Expression'newtype_ struct) = (Classes.fromStruct struct)
-set_Expression'literal :: ((Untyped.RWCtx m s)) => (Expression (Message.Mut s)) -> Std_.Double -> (m ())
-set_Expression'literal (Expression'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 1 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 0 0 0)
-    )
-set_Expression'previousResult :: ((Untyped.RWCtx m s)
-                                 ,(Classes.ToPtr s (Value (Message.Mut s)))) => (Expression (Message.Mut s)) -> (Value (Message.Mut s)) -> (m ())
-set_Expression'previousResult (Expression'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 1 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Expression'parameter :: ((Untyped.RWCtx m s)) => (Expression (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Expression'parameter (Expression'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (2 :: Std_.Word16) 1 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-    )
-set_Expression'call :: ((Untyped.RWCtx m s)
-                       ,(Classes.FromStruct (Message.Mut s) (Expression'call (Message.Mut s)))) => (Expression (Message.Mut s)) -> (m (Expression'call (Message.Mut s)))
-set_Expression'call (Expression'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (3 :: Std_.Word16) 1 0 0)
-    (Classes.fromStruct struct)
-    )
-set_Expression'unknown' :: ((Untyped.RWCtx m s)) => (Expression (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Expression'unknown' (Expression'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 1 0 0)
-newtype Expression'call msg
-    = Expression'call'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Expression'call msg)) where
-    fromStruct struct = (Std_.pure (Expression'call'newtype_ struct))
-instance (Classes.ToStruct msg (Expression'call msg)) where
-    toStruct (Expression'call'newtype_ struct) = struct
-instance (Untyped.HasMessage (Expression'call mut) mut) where
-    message (Expression'call'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Expression'call mut) mut) where
-    messageDefault msg = (Expression'call'newtype_ <$> (Untyped.messageDefault msg))
-get_Expression'call'function :: ((Untyped.ReadCtx m msg)
-                                ,(Classes.FromPtr msg (Function msg))) => (Expression'call msg) -> (m (Function msg))
-get_Expression'call'function (Expression'call'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Expression'call'function :: ((Untyped.RWCtx m s)
-                                ,(Classes.ToPtr s (Function (Message.Mut s)))) => (Expression'call (Message.Mut s)) -> (Function (Message.Mut s)) -> (m ())
-set_Expression'call'function (Expression'call'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Expression'call'function :: ((Untyped.ReadCtx m msg)) => (Expression'call msg) -> (m Std_.Bool)
-has_Expression'call'function (Expression'call'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-get_Expression'call'params :: ((Untyped.ReadCtx m msg)
-                              ,(Classes.FromPtr msg (Basics.List msg (Expression msg)))) => (Expression'call msg) -> (m (Basics.List msg (Expression msg)))
-get_Expression'call'params (Expression'call'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Expression'call'params :: ((Untyped.RWCtx m s)
-                              ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Expression (Message.Mut s))))) => (Expression'call (Message.Mut s)) -> (Basics.List (Message.Mut s) (Expression (Message.Mut s))) -> (m ())
-set_Expression'call'params (Expression'call'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Expression'call'params :: ((Untyped.ReadCtx m msg)) => (Expression'call msg) -> (m Std_.Bool)
-has_Expression'call'params (Expression'call'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_Expression'call'params :: ((Untyped.RWCtx m s)) => Std_.Int -> (Expression'call (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Expression (Message.Mut s))))
-new_Expression'call'params len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Expression'call'params struct result)
-    (Std_.pure result)
-    )
-newtype Value msg
-    = Value'newtype_ (Std_.Maybe (Untyped.Cap msg))
-instance (Classes.FromPtr msg (Value msg)) where
-    fromPtr msg ptr = (Value'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Value (Message.Mut s))) where
-    toPtr msg (Value'newtype_ (Std_.Nothing)) = (Std_.pure Std_.Nothing)
-    toPtr msg (Value'newtype_ (Std_.Just cap)) = (Std_.pure (Std_.Just (Untyped.PtrCap cap)))
-newtype Value'read'params msg
-    = Value'read'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Value'read'params msg)) where
-    fromStruct struct = (Std_.pure (Value'read'params'newtype_ struct))
-instance (Classes.ToStruct msg (Value'read'params msg)) where
-    toStruct (Value'read'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (Value'read'params mut) mut) where
-    message (Value'read'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Value'read'params mut) mut) where
-    messageDefault msg = (Value'read'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Value'read'params msg)) where
-    fromPtr msg ptr = (Value'read'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Value'read'params (Message.Mut s))) where
-    toPtr msg (Value'read'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Value'read'params (Message.Mut s))) where
-    new msg = (Value'read'params'newtype_ <$> (Untyped.allocStruct msg 0 0))
-instance (Basics.ListElem mut (Value'read'params mut)) where
-    newtype List mut (Value'read'params mut)
-        = Value'read'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Value'read'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Value'read'params'List_ l) = (Untyped.ListStruct l)
-    length (Value'read'params'List_ l) = (Untyped.length l)
-    index i (Value'read'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Value'read'params (Message.Mut s))) where
-    setIndex (Value'read'params'newtype_ elt) i (Value'read'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Value'read'params'List_ <$> (Untyped.allocCompositeList msg 0 0 len))
-newtype Value'read'results msg
-    = Value'read'results'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Value'read'results msg)) where
-    fromStruct struct = (Std_.pure (Value'read'results'newtype_ struct))
-instance (Classes.ToStruct msg (Value'read'results msg)) where
-    toStruct (Value'read'results'newtype_ struct) = struct
-instance (Untyped.HasMessage (Value'read'results mut) mut) where
-    message (Value'read'results'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Value'read'results mut) mut) where
-    messageDefault msg = (Value'read'results'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Value'read'results msg)) where
-    fromPtr msg ptr = (Value'read'results'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Value'read'results (Message.Mut s))) where
-    toPtr msg (Value'read'results'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Value'read'results (Message.Mut s))) where
-    new msg = (Value'read'results'newtype_ <$> (Untyped.allocStruct msg 1 0))
-instance (Basics.ListElem mut (Value'read'results mut)) where
-    newtype List mut (Value'read'results mut)
-        = Value'read'results'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Value'read'results'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Value'read'results'List_ l) = (Untyped.ListStruct l)
-    length (Value'read'results'List_ l) = (Untyped.length l)
-    index i (Value'read'results'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Value'read'results (Message.Mut s))) where
-    setIndex (Value'read'results'newtype_ elt) i (Value'read'results'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Value'read'results'List_ <$> (Untyped.allocCompositeList msg 1 0 len))
-get_Value'read'results'value :: ((Untyped.ReadCtx m msg)) => (Value'read'results msg) -> (m Std_.Double)
-get_Value'read'results'value (Value'read'results'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Value'read'results'value :: ((Untyped.RWCtx m s)) => (Value'read'results (Message.Mut s)) -> Std_.Double -> (m ())
-set_Value'read'results'value (Value'read'results'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 0 0 0)
-newtype Function msg
-    = Function'newtype_ (Std_.Maybe (Untyped.Cap msg))
-instance (Classes.FromPtr msg (Function msg)) where
-    fromPtr msg ptr = (Function'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Function (Message.Mut s))) where
-    toPtr msg (Function'newtype_ (Std_.Nothing)) = (Std_.pure Std_.Nothing)
-    toPtr msg (Function'newtype_ (Std_.Just cap)) = (Std_.pure (Std_.Just (Untyped.PtrCap cap)))
-newtype Function'call'params msg
-    = Function'call'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Function'call'params msg)) where
-    fromStruct struct = (Std_.pure (Function'call'params'newtype_ struct))
-instance (Classes.ToStruct msg (Function'call'params msg)) where
-    toStruct (Function'call'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (Function'call'params mut) mut) where
-    message (Function'call'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Function'call'params mut) mut) where
-    messageDefault msg = (Function'call'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Function'call'params msg)) where
-    fromPtr msg ptr = (Function'call'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Function'call'params (Message.Mut s))) where
-    toPtr msg (Function'call'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Function'call'params (Message.Mut s))) where
-    new msg = (Function'call'params'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Function'call'params mut)) where
-    newtype List mut (Function'call'params mut)
-        = Function'call'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Function'call'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Function'call'params'List_ l) = (Untyped.ListStruct l)
-    length (Function'call'params'List_ l) = (Untyped.length l)
-    index i (Function'call'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Function'call'params (Message.Mut s))) where
-    setIndex (Function'call'params'newtype_ elt) i (Function'call'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Function'call'params'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Function'call'params'params :: ((Untyped.ReadCtx m msg)
-                                   ,(Classes.FromPtr msg (Basics.List msg Std_.Double))) => (Function'call'params msg) -> (m (Basics.List msg Std_.Double))
-get_Function'call'params'params (Function'call'params'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Function'call'params'params :: ((Untyped.RWCtx m s)
-                                   ,(Classes.ToPtr s (Basics.List (Message.Mut s) Std_.Double))) => (Function'call'params (Message.Mut s)) -> (Basics.List (Message.Mut s) Std_.Double) -> (m ())
-set_Function'call'params'params (Function'call'params'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Function'call'params'params :: ((Untyped.ReadCtx m msg)) => (Function'call'params msg) -> (m Std_.Bool)
-has_Function'call'params'params (Function'call'params'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Function'call'params'params :: ((Untyped.RWCtx m s)) => Std_.Int -> (Function'call'params (Message.Mut s)) -> (m (Basics.List (Message.Mut s) Std_.Double))
-new_Function'call'params'params len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Function'call'params'params struct result)
-    (Std_.pure result)
-    )
-newtype Function'call'results msg
-    = Function'call'results'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Function'call'results msg)) where
-    fromStruct struct = (Std_.pure (Function'call'results'newtype_ struct))
-instance (Classes.ToStruct msg (Function'call'results msg)) where
-    toStruct (Function'call'results'newtype_ struct) = struct
-instance (Untyped.HasMessage (Function'call'results mut) mut) where
-    message (Function'call'results'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Function'call'results mut) mut) where
-    messageDefault msg = (Function'call'results'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Function'call'results msg)) where
-    fromPtr msg ptr = (Function'call'results'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Function'call'results (Message.Mut s))) where
-    toPtr msg (Function'call'results'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Function'call'results (Message.Mut s))) where
-    new msg = (Function'call'results'newtype_ <$> (Untyped.allocStruct msg 1 0))
-instance (Basics.ListElem mut (Function'call'results mut)) where
-    newtype List mut (Function'call'results mut)
-        = Function'call'results'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Function'call'results'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Function'call'results'List_ l) = (Untyped.ListStruct l)
-    length (Function'call'results'List_ l) = (Untyped.length l)
-    index i (Function'call'results'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Function'call'results (Message.Mut s))) where
-    setIndex (Function'call'results'newtype_ elt) i (Function'call'results'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Function'call'results'List_ <$> (Untyped.allocCompositeList msg 1 0 len))
-get_Function'call'results'value :: ((Untyped.ReadCtx m msg)) => (Function'call'results msg) -> (m Std_.Double)
-get_Function'call'results'value (Function'call'results'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Function'call'results'value :: ((Untyped.RWCtx m s)) => (Function'call'results (Message.Mut s)) -> Std_.Double -> (m ())
-set_Function'call'results'value (Function'call'results'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 0 0 0)
-data Operator 
-    = Operator'add 
-    | Operator'subtract 
-    | Operator'multiply 
-    | Operator'divide 
-    | Operator'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Read
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Classes.IsWord Operator) where
-    fromWord n = case ((Std_.fromIntegral n) :: Std_.Word16) of
-        0 ->
-            Operator'add
-        1 ->
-            Operator'subtract
-        2 ->
-            Operator'multiply
-        3 ->
-            Operator'divide
-        tag ->
-            (Operator'unknown' tag)
-    toWord (Operator'add) = 0
-    toWord (Operator'subtract) = 1
-    toWord (Operator'multiply) = 2
-    toWord (Operator'divide) = 3
-    toWord (Operator'unknown' tag) = (Std_.fromIntegral tag)
-instance (Std_.Enum Operator) where
-    fromEnum x = (Std_.fromIntegral (Classes.toWord x))
-    toEnum x = (Classes.fromWord (Std_.fromIntegral x))
-instance (Basics.ListElem mut Operator) where
-    newtype List mut Operator
-        = Operator'List_ (Untyped.ListOf mut Std_.Word16)
-    index i (Operator'List_ l) = (Classes.fromWord <$> (Std_.fromIntegral <$> (Untyped.index i l)))
-    listFromPtr msg ptr = (Operator'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Operator'List_ l) = (Untyped.List16 l)
-    length (Operator'List_ l) = (Untyped.length l)
-instance (Classes.MutListElem s Operator) where
-    setIndex elt i (Operator'List_ l) = (Untyped.setIndex (Std_.fromIntegral (Classes.toWord elt)) i l)
-    newList msg size = (Operator'List_ <$> (Untyped.allocList16 msg size))
diff --git a/examples/gen/lib/Capnp/Gen/Calculator/New.hs b/examples/gen/lib/Capnp/Gen/Calculator/New.hs
--- a/examples/gen/lib/Capnp/Gen/Calculator/New.hs
+++ b/examples/gen/lib/Capnp/Gen/Calculator/New.hs
@@ -27,7 +27,7 @@
 import qualified Capnp.GenHelpers.New as GH
 import qualified Capnp.New.Classes as C
 import qualified GHC.Generics as Generics
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
+import qualified Capnp.GenHelpers.New.Rpc as GH
 import qualified Prelude as Std_
 import qualified Data.Word as Std_
 import qualified Data.Int as Std_
diff --git a/examples/gen/lib/Capnp/Gen/Calculator/Pure.hs b/examples/gen/lib/Capnp/Gen/Calculator/Pure.hs
deleted file mode 100644
--- a/examples/gen/lib/Capnp/Gen/Calculator/Pure.hs
+++ /dev/null
@@ -1,648 +0,0 @@
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE RecordWildCards #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Calculator.Pure(Capnp.Gen.ById.X85150b117366d14b.Operator(..)
-                                ,Calculator(..)
-                                ,Calculator'server_(..)
-                                ,export_Calculator
-                                ,Calculator'evaluate'params(..)
-                                ,Calculator'evaluate'results(..)
-                                ,Calculator'defFunction'params(..)
-                                ,Calculator'defFunction'results(..)
-                                ,Calculator'getOperator'params(..)
-                                ,Calculator'getOperator'results(..)
-                                ,Expression(..)
-                                ,Expression'call(..)
-                                ,Value(..)
-                                ,Value'server_(..)
-                                ,export_Value
-                                ,Value'read'params(..)
-                                ,Value'read'results(..)
-                                ,Function(..)
-                                ,Function'server_(..)
-                                ,export_Function
-                                ,Function'call'params(..)
-                                ,Function'call'results(..)) where
-import qualified Capnp.GenHelpers.ReExports.Data.Vector as V
-import qualified Capnp.GenHelpers.ReExports.Data.Text as T
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Capnp.GenHelpers.ReExports.Data.Default as Default
-import qualified GHC.Generics as Generics
-import qualified Control.Monad.IO.Class as MonadIO
-import qualified Capnp.Untyped.Pure as UntypedPure
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Message as Message
-import qualified Capnp.Classes as Classes
-import qualified Capnp.Basics.Pure as BasicsPure
-import qualified Capnp.GenHelpers.Pure as GenHelpersPure
-import qualified Capnp.Rpc.Untyped as Rpc
-import qualified Capnp.Rpc.Server as Server
-import qualified Capnp.GenHelpers.Rpc as RpcHelpers
-import qualified Capnp.GenHelpers.ReExports.Control.Concurrent.STM as STM
-import qualified Capnp.GenHelpers.ReExports.Control.Monad.STM.Class as STM
-import qualified Capnp.GenHelpers.ReExports.Supervisors as Supervisors
-import qualified Capnp.Gen.ById.X85150b117366d14b
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-newtype Calculator 
-    = Calculator Message.Client
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-class ((MonadIO.MonadIO m)
-      ,(Server.Server m cap)) => (Calculator'server_ m cap) where
-    {-# MINIMAL calculator'evaluate,calculator'defFunction,calculator'getOperator #-}
-    calculator'evaluate :: cap -> (Server.MethodHandler m Calculator'evaluate'params Calculator'evaluate'results)
-    calculator'evaluate _ = Server.methodUnimplemented
-    calculator'defFunction :: cap -> (Server.MethodHandler m Calculator'defFunction'params Calculator'defFunction'results)
-    calculator'defFunction _ = Server.methodUnimplemented
-    calculator'getOperator :: cap -> (Server.MethodHandler m Calculator'getOperator'params Calculator'getOperator'results)
-    calculator'getOperator _ = Server.methodUnimplemented
-export_Calculator :: ((STM.MonadSTM m)
-                     ,(Calculator'server_ Std_.IO cap)) => Supervisors.Supervisor -> cap -> (m Calculator)
-export_Calculator sup_ server_ = (STM.liftSTM (Calculator <$> (Rpc.export sup_ Server.ServerOps{handleCast = (Server.unwrap server_)
-                                                                                               ,handleStop = (Server.shutdown server_)
-                                                                                               ,handleCall = (\interfaceId_ methodId_ -> case interfaceId_ of
-                                                                                                   10923537602090224694 ->
-                                                                                                       case methodId_ of
-                                                                                                           0 ->
-                                                                                                               (Server.toUntypedHandler (calculator'evaluate server_))
-                                                                                                           1 ->
-                                                                                                               (Server.toUntypedHandler (calculator'defFunction server_))
-                                                                                                           2 ->
-                                                                                                               (Server.toUntypedHandler (calculator'getOperator server_))
-                                                                                                           _ ->
-                                                                                                               Server.methodUnimplemented
-                                                                                                   _ ->
-                                                                                                       Server.methodUnimplemented)})))
-instance (Rpc.IsClient Calculator) where
-    fromClient  = Calculator
-    toClient (Calculator client) = client
-instance (Classes.FromPtr msg Calculator) where
-    fromPtr  = RpcHelpers.isClientFromPtr
-instance (Classes.ToPtr s Calculator) where
-    toPtr  = RpcHelpers.isClientToPtr
-instance (Classes.Decerialize Calculator) where
-    type Cerial msg Calculator = (Capnp.Gen.ById.X85150b117366d14b.Calculator msg)
-    decerialize (Capnp.Gen.ById.X85150b117366d14b.Calculator'newtype_ maybeCap) = case maybeCap of
-        (Std_.Nothing) ->
-            (Std_.pure (Calculator Message.nullClient))
-        (Std_.Just cap) ->
-            (Calculator <$> (Untyped.getClient cap))
-instance (Classes.Cerialize s Calculator) where
-    cerialize msg (Calculator client) = (Capnp.Gen.ById.X85150b117366d14b.Calculator'newtype_ <$> (Std_.Just <$> (Untyped.appendCap msg client)))
-instance (Server.Server Std_.IO Calculator)
-instance (Calculator'server_ Std_.IO Calculator) where
-    calculator'evaluate (Calculator client) = (Rpc.clientMethodHandler 10923537602090224694 0 client)
-    calculator'defFunction (Calculator client) = (Rpc.clientMethodHandler 10923537602090224694 1 client)
-    calculator'getOperator (Calculator client) = (Rpc.clientMethodHandler 10923537602090224694 2 client)
-data Calculator'evaluate'params 
-    = Calculator'evaluate'params 
-        {expression :: Expression}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Calculator'evaluate'params) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Calculator'evaluate'params) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Calculator'evaluate'params) where
-    type Cerial msg Calculator'evaluate'params = (Capnp.Gen.ById.X85150b117366d14b.Calculator'evaluate'params msg)
-    decerialize raw = (Calculator'evaluate'params <$> ((Capnp.Gen.ById.X85150b117366d14b.get_Calculator'evaluate'params'expression raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Calculator'evaluate'params) where
-    marshalInto raw_ value_ = case value_ of
-        Calculator'evaluate'params{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) expression) >>= (Capnp.Gen.ById.X85150b117366d14b.set_Calculator'evaluate'params'expression raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Calculator'evaluate'params)
-instance (Classes.Cerialize s (V.Vector Calculator'evaluate'params)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Calculator'evaluate'params))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Calculator'evaluate'params)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Calculator'evaluate'params))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'evaluate'params)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'evaluate'params))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'evaluate'params)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Calculator'evaluate'results 
-    = Calculator'evaluate'results 
-        {value :: Value}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Calculator'evaluate'results) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Calculator'evaluate'results) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Calculator'evaluate'results) where
-    type Cerial msg Calculator'evaluate'results = (Capnp.Gen.ById.X85150b117366d14b.Calculator'evaluate'results msg)
-    decerialize raw = (Calculator'evaluate'results <$> ((Capnp.Gen.ById.X85150b117366d14b.get_Calculator'evaluate'results'value raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Calculator'evaluate'results) where
-    marshalInto raw_ value_ = case value_ of
-        Calculator'evaluate'results{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) value) >>= (Capnp.Gen.ById.X85150b117366d14b.set_Calculator'evaluate'results'value raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Calculator'evaluate'results)
-instance (Classes.Cerialize s (V.Vector Calculator'evaluate'results)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Calculator'evaluate'results))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Calculator'evaluate'results)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Calculator'evaluate'results))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'evaluate'results)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'evaluate'results))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'evaluate'results)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Calculator'defFunction'params 
-    = Calculator'defFunction'params 
-        {paramCount :: Std_.Int32
-        ,body :: Expression}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Calculator'defFunction'params) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Calculator'defFunction'params) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Calculator'defFunction'params) where
-    type Cerial msg Calculator'defFunction'params = (Capnp.Gen.ById.X85150b117366d14b.Calculator'defFunction'params msg)
-    decerialize raw = (Calculator'defFunction'params <$> (Capnp.Gen.ById.X85150b117366d14b.get_Calculator'defFunction'params'paramCount raw)
-                                                     <*> ((Capnp.Gen.ById.X85150b117366d14b.get_Calculator'defFunction'params'body raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Calculator'defFunction'params) where
-    marshalInto raw_ value_ = case value_ of
-        Calculator'defFunction'params{..} ->
-            (do
-                (Capnp.Gen.ById.X85150b117366d14b.set_Calculator'defFunction'params'paramCount raw_ paramCount)
-                ((Classes.cerialize (Untyped.message raw_) body) >>= (Capnp.Gen.ById.X85150b117366d14b.set_Calculator'defFunction'params'body raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Calculator'defFunction'params)
-instance (Classes.Cerialize s (V.Vector Calculator'defFunction'params)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Calculator'defFunction'params))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Calculator'defFunction'params)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Calculator'defFunction'params))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'defFunction'params)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'defFunction'params))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'defFunction'params)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Calculator'defFunction'results 
-    = Calculator'defFunction'results 
-        {func :: Function}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Calculator'defFunction'results) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Calculator'defFunction'results) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Calculator'defFunction'results) where
-    type Cerial msg Calculator'defFunction'results = (Capnp.Gen.ById.X85150b117366d14b.Calculator'defFunction'results msg)
-    decerialize raw = (Calculator'defFunction'results <$> ((Capnp.Gen.ById.X85150b117366d14b.get_Calculator'defFunction'results'func raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Calculator'defFunction'results) where
-    marshalInto raw_ value_ = case value_ of
-        Calculator'defFunction'results{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) func) >>= (Capnp.Gen.ById.X85150b117366d14b.set_Calculator'defFunction'results'func raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Calculator'defFunction'results)
-instance (Classes.Cerialize s (V.Vector Calculator'defFunction'results)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Calculator'defFunction'results))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Calculator'defFunction'results)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Calculator'defFunction'results))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'defFunction'results)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'defFunction'results))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'defFunction'results)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Calculator'getOperator'params 
-    = Calculator'getOperator'params 
-        {op :: Capnp.Gen.ById.X85150b117366d14b.Operator}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Calculator'getOperator'params) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Calculator'getOperator'params) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Calculator'getOperator'params) where
-    type Cerial msg Calculator'getOperator'params = (Capnp.Gen.ById.X85150b117366d14b.Calculator'getOperator'params msg)
-    decerialize raw = (Calculator'getOperator'params <$> (Capnp.Gen.ById.X85150b117366d14b.get_Calculator'getOperator'params'op raw))
-instance (Classes.Marshal s Calculator'getOperator'params) where
-    marshalInto raw_ value_ = case value_ of
-        Calculator'getOperator'params{..} ->
-            (do
-                (Capnp.Gen.ById.X85150b117366d14b.set_Calculator'getOperator'params'op raw_ op)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Calculator'getOperator'params)
-instance (Classes.Cerialize s (V.Vector Calculator'getOperator'params)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Calculator'getOperator'params))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Calculator'getOperator'params)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Calculator'getOperator'params))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'getOperator'params)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'getOperator'params))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'getOperator'params)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Calculator'getOperator'results 
-    = Calculator'getOperator'results 
-        {func :: Function}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Calculator'getOperator'results) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Calculator'getOperator'results) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Calculator'getOperator'results) where
-    type Cerial msg Calculator'getOperator'results = (Capnp.Gen.ById.X85150b117366d14b.Calculator'getOperator'results msg)
-    decerialize raw = (Calculator'getOperator'results <$> ((Capnp.Gen.ById.X85150b117366d14b.get_Calculator'getOperator'results'func raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Calculator'getOperator'results) where
-    marshalInto raw_ value_ = case value_ of
-        Calculator'getOperator'results{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) func) >>= (Capnp.Gen.ById.X85150b117366d14b.set_Calculator'getOperator'results'func raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Calculator'getOperator'results)
-instance (Classes.Cerialize s (V.Vector Calculator'getOperator'results)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Calculator'getOperator'results))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Calculator'getOperator'results)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Calculator'getOperator'results))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'getOperator'results)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'getOperator'results))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Calculator'getOperator'results)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Expression 
-    = Expression'literal Std_.Double
-    | Expression'previousResult Value
-    | Expression'parameter Std_.Word32
-    | Expression'call Expression'call
-    | Expression'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Expression) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Expression) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Expression) where
-    type Cerial msg Expression = (Capnp.Gen.ById.X85150b117366d14b.Expression msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.X85150b117366d14b.get_Expression' raw)
-        case raw of
-            (Capnp.Gen.ById.X85150b117366d14b.Expression'literal raw) ->
-                (Std_.pure (Expression'literal raw))
-            (Capnp.Gen.ById.X85150b117366d14b.Expression'previousResult raw) ->
-                (Expression'previousResult <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X85150b117366d14b.Expression'parameter raw) ->
-                (Std_.pure (Expression'parameter raw))
-            (Capnp.Gen.ById.X85150b117366d14b.Expression'call raw) ->
-                (Expression'call <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X85150b117366d14b.Expression'unknown' tag) ->
-                (Std_.pure (Expression'unknown' tag))
-        )
-instance (Classes.Marshal s Expression) where
-    marshalInto raw_ value_ = case value_ of
-        (Expression'literal arg_) ->
-            (Capnp.Gen.ById.X85150b117366d14b.set_Expression'literal raw_ arg_)
-        (Expression'previousResult arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X85150b117366d14b.set_Expression'previousResult raw_))
-        (Expression'parameter arg_) ->
-            (Capnp.Gen.ById.X85150b117366d14b.set_Expression'parameter raw_ arg_)
-        (Expression'call arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.X85150b117366d14b.set_Expression'call raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Expression'unknown' tag) ->
-            (Capnp.Gen.ById.X85150b117366d14b.set_Expression'unknown' raw_ tag)
-instance (Classes.Cerialize s Expression)
-instance (Classes.Cerialize s (V.Vector Expression)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Expression))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Expression)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Expression))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Expression)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Expression))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Expression)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Expression'call 
-    = Expression'call' 
-        {function :: Function
-        ,params :: (V.Vector Expression)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Expression'call) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Expression'call) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Expression'call) where
-    type Cerial msg Expression'call = (Capnp.Gen.ById.X85150b117366d14b.Expression'call msg)
-    decerialize raw = (Expression'call' <$> ((Capnp.Gen.ById.X85150b117366d14b.get_Expression'call'function raw) >>= Classes.decerialize)
-                                        <*> ((Capnp.Gen.ById.X85150b117366d14b.get_Expression'call'params raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Expression'call) where
-    marshalInto raw_ value_ = case value_ of
-        Expression'call'{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) function) >>= (Capnp.Gen.ById.X85150b117366d14b.set_Expression'call'function raw_))
-                ((Classes.cerialize (Untyped.message raw_) params) >>= (Capnp.Gen.ById.X85150b117366d14b.set_Expression'call'params raw_))
-                (Std_.pure ())
-                )
-newtype Value 
-    = Value Message.Client
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-class ((MonadIO.MonadIO m)
-      ,(Server.Server m cap)) => (Value'server_ m cap) where
-    {-# MINIMAL value'read #-}
-    value'read :: cap -> (Server.MethodHandler m Value'read'params Value'read'results)
-    value'read _ = Server.methodUnimplemented
-export_Value :: ((STM.MonadSTM m)
-                ,(Value'server_ Std_.IO cap)) => Supervisors.Supervisor -> cap -> (m Value)
-export_Value sup_ server_ = (STM.liftSTM (Value <$> (Rpc.export sup_ Server.ServerOps{handleCast = (Server.unwrap server_)
-                                                                                     ,handleStop = (Server.shutdown server_)
-                                                                                     ,handleCall = (\interfaceId_ methodId_ -> case interfaceId_ of
-                                                                                         14116142932258867410 ->
-                                                                                             case methodId_ of
-                                                                                                 0 ->
-                                                                                                     (Server.toUntypedHandler (value'read server_))
-                                                                                                 _ ->
-                                                                                                     Server.methodUnimplemented
-                                                                                         _ ->
-                                                                                             Server.methodUnimplemented)})))
-instance (Rpc.IsClient Value) where
-    fromClient  = Value
-    toClient (Value client) = client
-instance (Classes.FromPtr msg Value) where
-    fromPtr  = RpcHelpers.isClientFromPtr
-instance (Classes.ToPtr s Value) where
-    toPtr  = RpcHelpers.isClientToPtr
-instance (Classes.Decerialize Value) where
-    type Cerial msg Value = (Capnp.Gen.ById.X85150b117366d14b.Value msg)
-    decerialize (Capnp.Gen.ById.X85150b117366d14b.Value'newtype_ maybeCap) = case maybeCap of
-        (Std_.Nothing) ->
-            (Std_.pure (Value Message.nullClient))
-        (Std_.Just cap) ->
-            (Value <$> (Untyped.getClient cap))
-instance (Classes.Cerialize s Value) where
-    cerialize msg (Value client) = (Capnp.Gen.ById.X85150b117366d14b.Value'newtype_ <$> (Std_.Just <$> (Untyped.appendCap msg client)))
-instance (Server.Server Std_.IO Value)
-instance (Value'server_ Std_.IO Value) where
-    value'read (Value client) = (Rpc.clientMethodHandler 14116142932258867410 0 client)
-data Value'read'params 
-    = Value'read'params 
-        {}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Value'read'params) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Value'read'params) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Value'read'params) where
-    type Cerial msg Value'read'params = (Capnp.Gen.ById.X85150b117366d14b.Value'read'params msg)
-    decerialize raw = (Std_.pure Value'read'params)
-instance (Classes.Marshal s Value'read'params) where
-    marshalInto raw_ value_ = case value_ of
-        (Value'read'params) ->
-            (do
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Value'read'params)
-instance (Classes.Cerialize s (V.Vector Value'read'params)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Value'read'params))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Value'read'params)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Value'read'params))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value'read'params)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value'read'params))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value'read'params)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Value'read'results 
-    = Value'read'results 
-        {value :: Std_.Double}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Value'read'results) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Value'read'results) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Value'read'results) where
-    type Cerial msg Value'read'results = (Capnp.Gen.ById.X85150b117366d14b.Value'read'results msg)
-    decerialize raw = (Value'read'results <$> (Capnp.Gen.ById.X85150b117366d14b.get_Value'read'results'value raw))
-instance (Classes.Marshal s Value'read'results) where
-    marshalInto raw_ value_ = case value_ of
-        Value'read'results{..} ->
-            (do
-                (Capnp.Gen.ById.X85150b117366d14b.set_Value'read'results'value raw_ value)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Value'read'results)
-instance (Classes.Cerialize s (V.Vector Value'read'results)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Value'read'results))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Value'read'results)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Value'read'results))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value'read'results)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value'read'results))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value'read'results)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-newtype Function 
-    = Function Message.Client
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-class ((MonadIO.MonadIO m)
-      ,(Server.Server m cap)) => (Function'server_ m cap) where
-    {-# MINIMAL function'call #-}
-    function'call :: cap -> (Server.MethodHandler m Function'call'params Function'call'results)
-    function'call _ = Server.methodUnimplemented
-export_Function :: ((STM.MonadSTM m)
-                   ,(Function'server_ Std_.IO cap)) => Supervisors.Supervisor -> cap -> (m Function)
-export_Function sup_ server_ = (STM.liftSTM (Function <$> (Rpc.export sup_ Server.ServerOps{handleCast = (Server.unwrap server_)
-                                                                                           ,handleStop = (Server.shutdown server_)
-                                                                                           ,handleCall = (\interfaceId_ methodId_ -> case interfaceId_ of
-                                                                                               17143016017778443156 ->
-                                                                                                   case methodId_ of
-                                                                                                       0 ->
-                                                                                                           (Server.toUntypedHandler (function'call server_))
-                                                                                                       _ ->
-                                                                                                           Server.methodUnimplemented
-                                                                                               _ ->
-                                                                                                   Server.methodUnimplemented)})))
-instance (Rpc.IsClient Function) where
-    fromClient  = Function
-    toClient (Function client) = client
-instance (Classes.FromPtr msg Function) where
-    fromPtr  = RpcHelpers.isClientFromPtr
-instance (Classes.ToPtr s Function) where
-    toPtr  = RpcHelpers.isClientToPtr
-instance (Classes.Decerialize Function) where
-    type Cerial msg Function = (Capnp.Gen.ById.X85150b117366d14b.Function msg)
-    decerialize (Capnp.Gen.ById.X85150b117366d14b.Function'newtype_ maybeCap) = case maybeCap of
-        (Std_.Nothing) ->
-            (Std_.pure (Function Message.nullClient))
-        (Std_.Just cap) ->
-            (Function <$> (Untyped.getClient cap))
-instance (Classes.Cerialize s Function) where
-    cerialize msg (Function client) = (Capnp.Gen.ById.X85150b117366d14b.Function'newtype_ <$> (Std_.Just <$> (Untyped.appendCap msg client)))
-instance (Server.Server Std_.IO Function)
-instance (Function'server_ Std_.IO Function) where
-    function'call (Function client) = (Rpc.clientMethodHandler 17143016017778443156 0 client)
-data Function'call'params 
-    = Function'call'params 
-        {params :: (V.Vector Std_.Double)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Function'call'params) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Function'call'params) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Function'call'params) where
-    type Cerial msg Function'call'params = (Capnp.Gen.ById.X85150b117366d14b.Function'call'params msg)
-    decerialize raw = (Function'call'params <$> ((Capnp.Gen.ById.X85150b117366d14b.get_Function'call'params'params raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Function'call'params) where
-    marshalInto raw_ value_ = case value_ of
-        Function'call'params{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) params) >>= (Capnp.Gen.ById.X85150b117366d14b.set_Function'call'params'params raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Function'call'params)
-instance (Classes.Cerialize s (V.Vector Function'call'params)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Function'call'params))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Function'call'params)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Function'call'params))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Function'call'params)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Function'call'params))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Function'call'params)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Function'call'results 
-    = Function'call'results 
-        {value :: Std_.Double}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Function'call'results) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Function'call'results) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Function'call'results) where
-    type Cerial msg Function'call'results = (Capnp.Gen.ById.X85150b117366d14b.Function'call'results msg)
-    decerialize raw = (Function'call'results <$> (Capnp.Gen.ById.X85150b117366d14b.get_Function'call'results'value raw))
-instance (Classes.Marshal s Function'call'results) where
-    marshalInto raw_ value_ = case value_ of
-        Function'call'results{..} ->
-            (do
-                (Capnp.Gen.ById.X85150b117366d14b.set_Function'call'results'value raw_ value)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Function'call'results)
-instance (Classes.Cerialize s (V.Vector Function'call'results)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Function'call'results))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Function'call'results)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Function'call'results))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Function'call'results)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Function'call'results))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Function'call'results)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Decerialize Capnp.Gen.ById.X85150b117366d14b.Operator) where
-    type Cerial msg Capnp.Gen.ById.X85150b117366d14b.Operator = Capnp.Gen.ById.X85150b117366d14b.Operator
-    decerialize  = Std_.pure
-instance (Classes.Cerialize s Capnp.Gen.ById.X85150b117366d14b.Operator) where
-    cerialize _ = Std_.pure
-instance (Classes.Cerialize s (V.Vector Capnp.Gen.ById.X85150b117366d14b.Operator)) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Capnp.Gen.ById.X85150b117366d14b.Operator))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.X85150b117366d14b.Operator)))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.X85150b117366d14b.Operator))))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.X85150b117366d14b.Operator)))))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.X85150b117366d14b.Operator))))))) where
-    cerialize  = Classes.cerializeBasicVec
diff --git a/examples/gen/lib/Capnp/Gen/Echo.hs b/examples/gen/lib/Capnp/Gen/Echo.hs
deleted file mode 100644
--- a/examples/gen/lib/Capnp/Gen/Echo.hs
+++ /dev/null
@@ -1,132 +0,0 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Echo where
-import qualified Capnp.Message as Message
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Basics as Basics
-import qualified Capnp.GenHelpers as GenHelpers
-import qualified Capnp.Classes as Classes
-import qualified GHC.Generics as Generics
-import qualified Capnp.Bits as Std_
-import qualified Data.Maybe as Std_
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-newtype Echo msg
-    = Echo'newtype_ (Std_.Maybe (Untyped.Cap msg))
-instance (Classes.FromPtr msg (Echo msg)) where
-    fromPtr msg ptr = (Echo'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Echo (Message.Mut s))) where
-    toPtr msg (Echo'newtype_ (Std_.Nothing)) = (Std_.pure Std_.Nothing)
-    toPtr msg (Echo'newtype_ (Std_.Just cap)) = (Std_.pure (Std_.Just (Untyped.PtrCap cap)))
-newtype Echo'echo'params msg
-    = Echo'echo'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Echo'echo'params msg)) where
-    fromStruct struct = (Std_.pure (Echo'echo'params'newtype_ struct))
-instance (Classes.ToStruct msg (Echo'echo'params msg)) where
-    toStruct (Echo'echo'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (Echo'echo'params mut) mut) where
-    message (Echo'echo'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Echo'echo'params mut) mut) where
-    messageDefault msg = (Echo'echo'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Echo'echo'params msg)) where
-    fromPtr msg ptr = (Echo'echo'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Echo'echo'params (Message.Mut s))) where
-    toPtr msg (Echo'echo'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Echo'echo'params (Message.Mut s))) where
-    new msg = (Echo'echo'params'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Echo'echo'params mut)) where
-    newtype List mut (Echo'echo'params mut)
-        = Echo'echo'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Echo'echo'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Echo'echo'params'List_ l) = (Untyped.ListStruct l)
-    length (Echo'echo'params'List_ l) = (Untyped.length l)
-    index i (Echo'echo'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Echo'echo'params (Message.Mut s))) where
-    setIndex (Echo'echo'params'newtype_ elt) i (Echo'echo'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Echo'echo'params'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Echo'echo'params'query :: ((Untyped.ReadCtx m msg)
-                              ,(Classes.FromPtr msg (Basics.Text msg))) => (Echo'echo'params msg) -> (m (Basics.Text msg))
-get_Echo'echo'params'query (Echo'echo'params'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Echo'echo'params'query :: ((Untyped.RWCtx m s)
-                              ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Echo'echo'params (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Echo'echo'params'query (Echo'echo'params'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Echo'echo'params'query :: ((Untyped.ReadCtx m msg)) => (Echo'echo'params msg) -> (m Std_.Bool)
-has_Echo'echo'params'query (Echo'echo'params'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Echo'echo'params'query :: ((Untyped.RWCtx m s)) => Std_.Int -> (Echo'echo'params (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Echo'echo'params'query len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Echo'echo'params'query struct result)
-    (Std_.pure result)
-    )
-newtype Echo'echo'results msg
-    = Echo'echo'results'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Echo'echo'results msg)) where
-    fromStruct struct = (Std_.pure (Echo'echo'results'newtype_ struct))
-instance (Classes.ToStruct msg (Echo'echo'results msg)) where
-    toStruct (Echo'echo'results'newtype_ struct) = struct
-instance (Untyped.HasMessage (Echo'echo'results mut) mut) where
-    message (Echo'echo'results'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Echo'echo'results mut) mut) where
-    messageDefault msg = (Echo'echo'results'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Echo'echo'results msg)) where
-    fromPtr msg ptr = (Echo'echo'results'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Echo'echo'results (Message.Mut s))) where
-    toPtr msg (Echo'echo'results'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Echo'echo'results (Message.Mut s))) where
-    new msg = (Echo'echo'results'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Echo'echo'results mut)) where
-    newtype List mut (Echo'echo'results mut)
-        = Echo'echo'results'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Echo'echo'results'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Echo'echo'results'List_ l) = (Untyped.ListStruct l)
-    length (Echo'echo'results'List_ l) = (Untyped.length l)
-    index i (Echo'echo'results'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Echo'echo'results (Message.Mut s))) where
-    setIndex (Echo'echo'results'newtype_ elt) i (Echo'echo'results'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Echo'echo'results'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Echo'echo'results'reply :: ((Untyped.ReadCtx m msg)
-                               ,(Classes.FromPtr msg (Basics.Text msg))) => (Echo'echo'results msg) -> (m (Basics.Text msg))
-get_Echo'echo'results'reply (Echo'echo'results'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Echo'echo'results'reply :: ((Untyped.RWCtx m s)
-                               ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Echo'echo'results (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Echo'echo'results'reply (Echo'echo'results'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Echo'echo'results'reply :: ((Untyped.ReadCtx m msg)) => (Echo'echo'results msg) -> (m Std_.Bool)
-has_Echo'echo'results'reply (Echo'echo'results'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Echo'echo'results'reply :: ((Untyped.RWCtx m s)) => Std_.Int -> (Echo'echo'results (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Echo'echo'results'reply len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Echo'echo'results'reply struct result)
-    (Std_.pure result)
-    )
diff --git a/examples/gen/lib/Capnp/Gen/Echo/New.hs b/examples/gen/lib/Capnp/Gen/Echo/New.hs
--- a/examples/gen/lib/Capnp/Gen/Echo/New.hs
+++ b/examples/gen/lib/Capnp/Gen/Echo/New.hs
@@ -27,7 +27,7 @@
 import qualified Capnp.GenHelpers.New as GH
 import qualified Capnp.New.Classes as C
 import qualified GHC.Generics as Generics
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
+import qualified Capnp.GenHelpers.New.Rpc as GH
 import qualified Prelude as Std_
 import qualified Data.Word as Std_
 import qualified Data.Int as Std_
diff --git a/examples/gen/lib/Capnp/Gen/Echo/Pure.hs b/examples/gen/lib/Capnp/Gen/Echo/Pure.hs
deleted file mode 100644
--- a/examples/gen/lib/Capnp/Gen/Echo/Pure.hs
+++ /dev/null
@@ -1,156 +0,0 @@
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE RecordWildCards #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Echo.Pure(Echo(..)
-                          ,Echo'server_(..)
-                          ,export_Echo
-                          ,Echo'echo'params(..)
-                          ,Echo'echo'results(..)) where
-import qualified Capnp.GenHelpers.ReExports.Data.Vector as V
-import qualified Capnp.GenHelpers.ReExports.Data.Text as T
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Capnp.GenHelpers.ReExports.Data.Default as Default
-import qualified GHC.Generics as Generics
-import qualified Control.Monad.IO.Class as MonadIO
-import qualified Capnp.Untyped.Pure as UntypedPure
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Message as Message
-import qualified Capnp.Classes as Classes
-import qualified Capnp.Basics.Pure as BasicsPure
-import qualified Capnp.GenHelpers.Pure as GenHelpersPure
-import qualified Capnp.Rpc.Untyped as Rpc
-import qualified Capnp.Rpc.Server as Server
-import qualified Capnp.GenHelpers.Rpc as RpcHelpers
-import qualified Capnp.GenHelpers.ReExports.Control.Concurrent.STM as STM
-import qualified Capnp.GenHelpers.ReExports.Control.Monad.STM.Class as STM
-import qualified Capnp.GenHelpers.ReExports.Supervisors as Supervisors
-import qualified Capnp.Gen.ById.Xd0a87f36fa0182f5
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-newtype Echo 
-    = Echo Message.Client
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-class ((MonadIO.MonadIO m)
-      ,(Server.Server m cap)) => (Echo'server_ m cap) where
-    {-# MINIMAL echo'echo #-}
-    echo'echo :: cap -> (Server.MethodHandler m Echo'echo'params Echo'echo'results)
-    echo'echo _ = Server.methodUnimplemented
-export_Echo :: ((STM.MonadSTM m)
-               ,(Echo'server_ Std_.IO cap)) => Supervisors.Supervisor -> cap -> (m Echo)
-export_Echo sup_ server_ = (STM.liftSTM (Echo <$> (Rpc.export sup_ Server.ServerOps{handleCast = (Server.unwrap server_)
-                                                                                   ,handleStop = (Server.shutdown server_)
-                                                                                   ,handleCall = (\interfaceId_ methodId_ -> case interfaceId_ of
-                                                                                       16940812395455687611 ->
-                                                                                           case methodId_ of
-                                                                                               0 ->
-                                                                                                   (Server.toUntypedHandler (echo'echo server_))
-                                                                                               _ ->
-                                                                                                   Server.methodUnimplemented
-                                                                                       _ ->
-                                                                                           Server.methodUnimplemented)})))
-instance (Rpc.IsClient Echo) where
-    fromClient  = Echo
-    toClient (Echo client) = client
-instance (Classes.FromPtr msg Echo) where
-    fromPtr  = RpcHelpers.isClientFromPtr
-instance (Classes.ToPtr s Echo) where
-    toPtr  = RpcHelpers.isClientToPtr
-instance (Classes.Decerialize Echo) where
-    type Cerial msg Echo = (Capnp.Gen.ById.Xd0a87f36fa0182f5.Echo msg)
-    decerialize (Capnp.Gen.ById.Xd0a87f36fa0182f5.Echo'newtype_ maybeCap) = case maybeCap of
-        (Std_.Nothing) ->
-            (Std_.pure (Echo Message.nullClient))
-        (Std_.Just cap) ->
-            (Echo <$> (Untyped.getClient cap))
-instance (Classes.Cerialize s Echo) where
-    cerialize msg (Echo client) = (Capnp.Gen.ById.Xd0a87f36fa0182f5.Echo'newtype_ <$> (Std_.Just <$> (Untyped.appendCap msg client)))
-instance (Server.Server Std_.IO Echo)
-instance (Echo'server_ Std_.IO Echo) where
-    echo'echo (Echo client) = (Rpc.clientMethodHandler 16940812395455687611 0 client)
-data Echo'echo'params 
-    = Echo'echo'params 
-        {query :: T.Text}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Echo'echo'params) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Echo'echo'params) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Echo'echo'params) where
-    type Cerial msg Echo'echo'params = (Capnp.Gen.ById.Xd0a87f36fa0182f5.Echo'echo'params msg)
-    decerialize raw = (Echo'echo'params <$> ((Capnp.Gen.ById.Xd0a87f36fa0182f5.get_Echo'echo'params'query raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Echo'echo'params) where
-    marshalInto raw_ value_ = case value_ of
-        Echo'echo'params{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) query) >>= (Capnp.Gen.ById.Xd0a87f36fa0182f5.set_Echo'echo'params'query raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Echo'echo'params)
-instance (Classes.Cerialize s (V.Vector Echo'echo'params)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Echo'echo'params))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Echo'echo'params)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Echo'echo'params))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Echo'echo'params)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Echo'echo'params))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Echo'echo'params)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Echo'echo'results 
-    = Echo'echo'results 
-        {reply :: T.Text}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Echo'echo'results) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Echo'echo'results) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Echo'echo'results) where
-    type Cerial msg Echo'echo'results = (Capnp.Gen.ById.Xd0a87f36fa0182f5.Echo'echo'results msg)
-    decerialize raw = (Echo'echo'results <$> ((Capnp.Gen.ById.Xd0a87f36fa0182f5.get_Echo'echo'results'reply raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Echo'echo'results) where
-    marshalInto raw_ value_ = case value_ of
-        Echo'echo'results{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) reply) >>= (Capnp.Gen.ById.Xd0a87f36fa0182f5.set_Echo'echo'results'reply raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Echo'echo'results)
-instance (Classes.Cerialize s (V.Vector Echo'echo'results)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Echo'echo'results))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Echo'echo'results)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Echo'echo'results))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Echo'echo'results)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Echo'echo'results))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Echo'echo'results)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
diff --git a/gen/lib/Capnp/Gen/ById/X86c366a91393f3f8.hs b/gen/lib/Capnp/Gen/ById/X86c366a91393f3f8.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/ById/X86c366a91393f3f8.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.X86c366a91393f3f8(module Capnp.Gen.Capnp.Stream) where
-import Capnp.Gen.Capnp.Stream
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/lib/Capnp/Gen/ById/X86c366a91393f3f8/Pure.hs b/gen/lib/Capnp/Gen/ById/X86c366a91393f3f8/Pure.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/ById/X86c366a91393f3f8/Pure.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.X86c366a91393f3f8.Pure(module Capnp.Gen.Capnp.Stream.Pure) where
-import Capnp.Gen.Capnp.Stream.Pure
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/lib/Capnp/Gen/ById/X8ef99297a43a5e34.hs b/gen/lib/Capnp/Gen/ById/X8ef99297a43a5e34.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/ById/X8ef99297a43a5e34.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.X8ef99297a43a5e34(module Capnp.Gen.Capnp.Compat.Json) where
-import Capnp.Gen.Capnp.Compat.Json
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/lib/Capnp/Gen/ById/X8ef99297a43a5e34/Pure.hs b/gen/lib/Capnp/Gen/ById/X8ef99297a43a5e34/Pure.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/ById/X8ef99297a43a5e34/Pure.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.X8ef99297a43a5e34.Pure(module Capnp.Gen.Capnp.Compat.Json.Pure) where
-import Capnp.Gen.Capnp.Compat.Json.Pure
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/lib/Capnp/Gen/ById/Xa184c7885cdaf2a1.hs b/gen/lib/Capnp/Gen/ById/Xa184c7885cdaf2a1.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/ById/Xa184c7885cdaf2a1.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.Xa184c7885cdaf2a1(module Capnp.Gen.Capnp.RpcTwoparty) where
-import Capnp.Gen.Capnp.RpcTwoparty
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/lib/Capnp/Gen/ById/Xa184c7885cdaf2a1/Pure.hs b/gen/lib/Capnp/Gen/ById/Xa184c7885cdaf2a1/Pure.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/ById/Xa184c7885cdaf2a1/Pure.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.Xa184c7885cdaf2a1.Pure(module Capnp.Gen.Capnp.RpcTwoparty.Pure) where
-import Capnp.Gen.Capnp.RpcTwoparty.Pure
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/lib/Capnp/Gen/ById/Xa93fc509624c72d9.hs b/gen/lib/Capnp/Gen/ById/Xa93fc509624c72d9.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/ById/Xa93fc509624c72d9.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.Xa93fc509624c72d9(module Capnp.Gen.Capnp.Schema) where
-import Capnp.Gen.Capnp.Schema
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/lib/Capnp/Gen/ById/Xa93fc509624c72d9/Pure.hs b/gen/lib/Capnp/Gen/ById/Xa93fc509624c72d9/Pure.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/ById/Xa93fc509624c72d9/Pure.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.Xa93fc509624c72d9.Pure(module Capnp.Gen.Capnp.Schema.Pure) where
-import Capnp.Gen.Capnp.Schema.Pure
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/lib/Capnp/Gen/ById/Xb312981b2552a250.hs b/gen/lib/Capnp/Gen/ById/Xb312981b2552a250.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/ById/Xb312981b2552a250.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.Xb312981b2552a250(module Capnp.Gen.Capnp.Rpc) where
-import Capnp.Gen.Capnp.Rpc
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/lib/Capnp/Gen/ById/Xb312981b2552a250/Pure.hs b/gen/lib/Capnp/Gen/ById/Xb312981b2552a250/Pure.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/ById/Xb312981b2552a250/Pure.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.Xb312981b2552a250.Pure(module Capnp.Gen.Capnp.Rpc.Pure) where
-import Capnp.Gen.Capnp.Rpc.Pure
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/lib/Capnp/Gen/ById/Xb8630836983feed7.hs b/gen/lib/Capnp/Gen/ById/Xb8630836983feed7.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/ById/Xb8630836983feed7.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.Xb8630836983feed7(module Capnp.Gen.Capnp.Persistent) where
-import Capnp.Gen.Capnp.Persistent
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/lib/Capnp/Gen/ById/Xb8630836983feed7/Pure.hs b/gen/lib/Capnp/Gen/ById/Xb8630836983feed7/Pure.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/ById/Xb8630836983feed7/Pure.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.Xb8630836983feed7.Pure(module Capnp.Gen.Capnp.Persistent.Pure) where
-import Capnp.Gen.Capnp.Persistent.Pure
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/lib/Capnp/Gen/ById/Xbdf87d7bb8304e81.hs b/gen/lib/Capnp/Gen/ById/Xbdf87d7bb8304e81.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/ById/Xbdf87d7bb8304e81.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.Xbdf87d7bb8304e81(module Capnp.Gen.Capnp.Cxx) where
-import Capnp.Gen.Capnp.Cxx
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/lib/Capnp/Gen/ById/Xbdf87d7bb8304e81/Pure.hs b/gen/lib/Capnp/Gen/ById/Xbdf87d7bb8304e81/Pure.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/ById/Xbdf87d7bb8304e81/Pure.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.Xbdf87d7bb8304e81.Pure(module Capnp.Gen.Capnp.Cxx.Pure) where
-import Capnp.Gen.Capnp.Cxx.Pure
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/lib/Capnp/Gen/Capnp/Compat/Json.hs b/gen/lib/Capnp/Gen/Capnp/Compat/Json.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/Capnp/Compat/Json.hs
+++ /dev/null
@@ -1,410 +0,0 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Capnp.Compat.Json where
-import qualified Capnp.Message as Message
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Basics as Basics
-import qualified Capnp.GenHelpers as GenHelpers
-import qualified Capnp.Classes as Classes
-import qualified GHC.Generics as Generics
-import qualified Capnp.Bits as Std_
-import qualified Data.Maybe as Std_
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-newtype Value msg
-    = Value'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Value msg)) where
-    fromStruct struct = (Std_.pure (Value'newtype_ struct))
-instance (Classes.ToStruct msg (Value msg)) where
-    toStruct (Value'newtype_ struct) = struct
-instance (Untyped.HasMessage (Value mut) mut) where
-    message (Value'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Value mut) mut) where
-    messageDefault msg = (Value'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Value msg)) where
-    fromPtr msg ptr = (Value'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Value (Message.Mut s))) where
-    toPtr msg (Value'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Value (Message.Mut s))) where
-    new msg = (Value'newtype_ <$> (Untyped.allocStruct msg 2 1))
-instance (Basics.ListElem mut (Value mut)) where
-    newtype List mut (Value mut)
-        = Value'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Value'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Value'List_ l) = (Untyped.ListStruct l)
-    length (Value'List_ l) = (Untyped.length l)
-    index i (Value'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Value (Message.Mut s))) where
-    setIndex (Value'newtype_ elt) i (Value'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Value'List_ <$> (Untyped.allocCompositeList msg 2 1 len))
-data Value' (mut :: Message.Mutability)
-    = Value'null 
-    | Value'boolean Std_.Bool
-    | Value'number Std_.Double
-    | Value'string (Basics.Text mut)
-    | Value'array (Basics.List mut (Value mut))
-    | Value'object (Basics.List mut (Value'Field mut))
-    | Value'call (Value'Call mut)
-    | Value'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Value' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 0)
-        case tag of
-            0 ->
-                (Std_.pure Value'null)
-            1 ->
-                (Value'boolean <$> (GenHelpers.getWordField struct 0 16 0))
-            2 ->
-                (Value'number <$> (GenHelpers.getWordField struct 1 0 0))
-            3 ->
-                (Value'string <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            4 ->
-                (Value'array <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            5 ->
-                (Value'object <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            6 ->
-                (Value'call <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            _ ->
-                (Std_.pure (Value'unknown' (Std_.fromIntegral tag)))
-        )
-get_Value' :: ((Untyped.ReadCtx m msg)
-              ,(Classes.FromStruct msg (Value' msg))) => (Value msg) -> (m (Value' msg))
-get_Value' (Value'newtype_ struct) = (Classes.fromStruct struct)
-set_Value'null :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> (m ())
-set_Value'null (Value'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Value'boolean :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Value'boolean (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 0 16 0)
-    )
-set_Value'number :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> Std_.Double -> (m ())
-set_Value'number (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (2 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-    )
-set_Value'string :: ((Untyped.RWCtx m s)
-                    ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Value (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Value'string (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (3 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Value'array :: ((Untyped.RWCtx m s)
-                   ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Value (Message.Mut s))))) => (Value (Message.Mut s)) -> (Basics.List (Message.Mut s) (Value (Message.Mut s))) -> (m ())
-set_Value'array (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (4 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Value'object :: ((Untyped.RWCtx m s)
-                    ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Value'Field (Message.Mut s))))) => (Value (Message.Mut s)) -> (Basics.List (Message.Mut s) (Value'Field (Message.Mut s))) -> (m ())
-set_Value'object (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (5 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Value'call :: ((Untyped.RWCtx m s)
-                  ,(Classes.ToPtr s (Value'Call (Message.Mut s)))) => (Value (Message.Mut s)) -> (Value'Call (Message.Mut s)) -> (m ())
-set_Value'call (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (6 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Value'unknown' :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Value'unknown' (Value'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-newtype Value'Field msg
-    = Value'Field'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Value'Field msg)) where
-    fromStruct struct = (Std_.pure (Value'Field'newtype_ struct))
-instance (Classes.ToStruct msg (Value'Field msg)) where
-    toStruct (Value'Field'newtype_ struct) = struct
-instance (Untyped.HasMessage (Value'Field mut) mut) where
-    message (Value'Field'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Value'Field mut) mut) where
-    messageDefault msg = (Value'Field'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Value'Field msg)) where
-    fromPtr msg ptr = (Value'Field'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Value'Field (Message.Mut s))) where
-    toPtr msg (Value'Field'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Value'Field (Message.Mut s))) where
-    new msg = (Value'Field'newtype_ <$> (Untyped.allocStruct msg 0 2))
-instance (Basics.ListElem mut (Value'Field mut)) where
-    newtype List mut (Value'Field mut)
-        = Value'Field'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Value'Field'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Value'Field'List_ l) = (Untyped.ListStruct l)
-    length (Value'Field'List_ l) = (Untyped.length l)
-    index i (Value'Field'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Value'Field (Message.Mut s))) where
-    setIndex (Value'Field'newtype_ elt) i (Value'Field'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Value'Field'List_ <$> (Untyped.allocCompositeList msg 0 2 len))
-get_Value'Field'name :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Basics.Text msg))) => (Value'Field msg) -> (m (Basics.Text msg))
-get_Value'Field'name (Value'Field'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Value'Field'name :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Value'Field (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Value'Field'name (Value'Field'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Value'Field'name :: ((Untyped.ReadCtx m msg)) => (Value'Field msg) -> (m Std_.Bool)
-has_Value'Field'name (Value'Field'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Value'Field'name :: ((Untyped.RWCtx m s)) => Std_.Int -> (Value'Field (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Value'Field'name len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Value'Field'name struct result)
-    (Std_.pure result)
-    )
-get_Value'Field'value :: ((Untyped.ReadCtx m msg)
-                         ,(Classes.FromPtr msg (Value msg))) => (Value'Field msg) -> (m (Value msg))
-get_Value'Field'value (Value'Field'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Value'Field'value :: ((Untyped.RWCtx m s)
-                         ,(Classes.ToPtr s (Value (Message.Mut s)))) => (Value'Field (Message.Mut s)) -> (Value (Message.Mut s)) -> (m ())
-set_Value'Field'value (Value'Field'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Value'Field'value :: ((Untyped.ReadCtx m msg)) => (Value'Field msg) -> (m Std_.Bool)
-has_Value'Field'value (Value'Field'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_Value'Field'value :: ((Untyped.RWCtx m s)) => (Value'Field (Message.Mut s)) -> (m (Value (Message.Mut s)))
-new_Value'Field'value struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Value'Field'value struct result)
-    (Std_.pure result)
-    )
-newtype Value'Call msg
-    = Value'Call'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Value'Call msg)) where
-    fromStruct struct = (Std_.pure (Value'Call'newtype_ struct))
-instance (Classes.ToStruct msg (Value'Call msg)) where
-    toStruct (Value'Call'newtype_ struct) = struct
-instance (Untyped.HasMessage (Value'Call mut) mut) where
-    message (Value'Call'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Value'Call mut) mut) where
-    messageDefault msg = (Value'Call'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Value'Call msg)) where
-    fromPtr msg ptr = (Value'Call'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Value'Call (Message.Mut s))) where
-    toPtr msg (Value'Call'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Value'Call (Message.Mut s))) where
-    new msg = (Value'Call'newtype_ <$> (Untyped.allocStruct msg 0 2))
-instance (Basics.ListElem mut (Value'Call mut)) where
-    newtype List mut (Value'Call mut)
-        = Value'Call'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Value'Call'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Value'Call'List_ l) = (Untyped.ListStruct l)
-    length (Value'Call'List_ l) = (Untyped.length l)
-    index i (Value'Call'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Value'Call (Message.Mut s))) where
-    setIndex (Value'Call'newtype_ elt) i (Value'Call'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Value'Call'List_ <$> (Untyped.allocCompositeList msg 0 2 len))
-get_Value'Call'function :: ((Untyped.ReadCtx m msg)
-                           ,(Classes.FromPtr msg (Basics.Text msg))) => (Value'Call msg) -> (m (Basics.Text msg))
-get_Value'Call'function (Value'Call'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Value'Call'function :: ((Untyped.RWCtx m s)
-                           ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Value'Call (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Value'Call'function (Value'Call'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Value'Call'function :: ((Untyped.ReadCtx m msg)) => (Value'Call msg) -> (m Std_.Bool)
-has_Value'Call'function (Value'Call'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Value'Call'function :: ((Untyped.RWCtx m s)) => Std_.Int -> (Value'Call (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Value'Call'function len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Value'Call'function struct result)
-    (Std_.pure result)
-    )
-get_Value'Call'params :: ((Untyped.ReadCtx m msg)
-                         ,(Classes.FromPtr msg (Basics.List msg (Value msg)))) => (Value'Call msg) -> (m (Basics.List msg (Value msg)))
-get_Value'Call'params (Value'Call'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Value'Call'params :: ((Untyped.RWCtx m s)
-                         ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Value (Message.Mut s))))) => (Value'Call (Message.Mut s)) -> (Basics.List (Message.Mut s) (Value (Message.Mut s))) -> (m ())
-set_Value'Call'params (Value'Call'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Value'Call'params :: ((Untyped.ReadCtx m msg)) => (Value'Call msg) -> (m Std_.Bool)
-has_Value'Call'params (Value'Call'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_Value'Call'params :: ((Untyped.RWCtx m s)) => Std_.Int -> (Value'Call (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Value (Message.Mut s))))
-new_Value'Call'params len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Value'Call'params struct result)
-    (Std_.pure result)
-    )
-newtype FlattenOptions msg
-    = FlattenOptions'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (FlattenOptions msg)) where
-    fromStruct struct = (Std_.pure (FlattenOptions'newtype_ struct))
-instance (Classes.ToStruct msg (FlattenOptions msg)) where
-    toStruct (FlattenOptions'newtype_ struct) = struct
-instance (Untyped.HasMessage (FlattenOptions mut) mut) where
-    message (FlattenOptions'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (FlattenOptions mut) mut) where
-    messageDefault msg = (FlattenOptions'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (FlattenOptions msg)) where
-    fromPtr msg ptr = (FlattenOptions'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (FlattenOptions (Message.Mut s))) where
-    toPtr msg (FlattenOptions'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (FlattenOptions (Message.Mut s))) where
-    new msg = (FlattenOptions'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (FlattenOptions mut)) where
-    newtype List mut (FlattenOptions mut)
-        = FlattenOptions'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (FlattenOptions'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (FlattenOptions'List_ l) = (Untyped.ListStruct l)
-    length (FlattenOptions'List_ l) = (Untyped.length l)
-    index i (FlattenOptions'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (FlattenOptions (Message.Mut s))) where
-    setIndex (FlattenOptions'newtype_ elt) i (FlattenOptions'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (FlattenOptions'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_FlattenOptions'prefix :: ((Untyped.ReadCtx m msg)
-                             ,(Classes.FromPtr msg (Basics.Text msg))) => (FlattenOptions msg) -> (m (Basics.Text msg))
-get_FlattenOptions'prefix (FlattenOptions'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_FlattenOptions'prefix :: ((Untyped.RWCtx m s)
-                             ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (FlattenOptions (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_FlattenOptions'prefix (FlattenOptions'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_FlattenOptions'prefix :: ((Untyped.ReadCtx m msg)) => (FlattenOptions msg) -> (m Std_.Bool)
-has_FlattenOptions'prefix (FlattenOptions'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_FlattenOptions'prefix :: ((Untyped.RWCtx m s)) => Std_.Int -> (FlattenOptions (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_FlattenOptions'prefix len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_FlattenOptions'prefix struct result)
-    (Std_.pure result)
-    )
-newtype DiscriminatorOptions msg
-    = DiscriminatorOptions'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (DiscriminatorOptions msg)) where
-    fromStruct struct = (Std_.pure (DiscriminatorOptions'newtype_ struct))
-instance (Classes.ToStruct msg (DiscriminatorOptions msg)) where
-    toStruct (DiscriminatorOptions'newtype_ struct) = struct
-instance (Untyped.HasMessage (DiscriminatorOptions mut) mut) where
-    message (DiscriminatorOptions'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (DiscriminatorOptions mut) mut) where
-    messageDefault msg = (DiscriminatorOptions'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (DiscriminatorOptions msg)) where
-    fromPtr msg ptr = (DiscriminatorOptions'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (DiscriminatorOptions (Message.Mut s))) where
-    toPtr msg (DiscriminatorOptions'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (DiscriminatorOptions (Message.Mut s))) where
-    new msg = (DiscriminatorOptions'newtype_ <$> (Untyped.allocStruct msg 0 2))
-instance (Basics.ListElem mut (DiscriminatorOptions mut)) where
-    newtype List mut (DiscriminatorOptions mut)
-        = DiscriminatorOptions'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (DiscriminatorOptions'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (DiscriminatorOptions'List_ l) = (Untyped.ListStruct l)
-    length (DiscriminatorOptions'List_ l) = (Untyped.length l)
-    index i (DiscriminatorOptions'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (DiscriminatorOptions (Message.Mut s))) where
-    setIndex (DiscriminatorOptions'newtype_ elt) i (DiscriminatorOptions'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (DiscriminatorOptions'List_ <$> (Untyped.allocCompositeList msg 0 2 len))
-get_DiscriminatorOptions'name :: ((Untyped.ReadCtx m msg)
-                                 ,(Classes.FromPtr msg (Basics.Text msg))) => (DiscriminatorOptions msg) -> (m (Basics.Text msg))
-get_DiscriminatorOptions'name (DiscriminatorOptions'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_DiscriminatorOptions'name :: ((Untyped.RWCtx m s)
-                                 ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (DiscriminatorOptions (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_DiscriminatorOptions'name (DiscriminatorOptions'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_DiscriminatorOptions'name :: ((Untyped.ReadCtx m msg)) => (DiscriminatorOptions msg) -> (m Std_.Bool)
-has_DiscriminatorOptions'name (DiscriminatorOptions'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_DiscriminatorOptions'name :: ((Untyped.RWCtx m s)) => Std_.Int -> (DiscriminatorOptions (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_DiscriminatorOptions'name len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_DiscriminatorOptions'name struct result)
-    (Std_.pure result)
-    )
-get_DiscriminatorOptions'valueName :: ((Untyped.ReadCtx m msg)
-                                      ,(Classes.FromPtr msg (Basics.Text msg))) => (DiscriminatorOptions msg) -> (m (Basics.Text msg))
-get_DiscriminatorOptions'valueName (DiscriminatorOptions'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_DiscriminatorOptions'valueName :: ((Untyped.RWCtx m s)
-                                      ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (DiscriminatorOptions (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_DiscriminatorOptions'valueName (DiscriminatorOptions'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_DiscriminatorOptions'valueName :: ((Untyped.ReadCtx m msg)) => (DiscriminatorOptions msg) -> (m Std_.Bool)
-has_DiscriminatorOptions'valueName (DiscriminatorOptions'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_DiscriminatorOptions'valueName :: ((Untyped.RWCtx m s)) => Std_.Int -> (DiscriminatorOptions (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_DiscriminatorOptions'valueName len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_DiscriminatorOptions'valueName struct result)
-    (Std_.pure result)
-    )
diff --git a/gen/lib/Capnp/Gen/Capnp/Compat/Json/New.hs b/gen/lib/Capnp/Gen/Capnp/Compat/Json/New.hs
--- a/gen/lib/Capnp/Gen/Capnp/Compat/Json/New.hs
+++ b/gen/lib/Capnp/Gen/Capnp/Compat/Json/New.hs
@@ -27,7 +27,6 @@
 import qualified Capnp.GenHelpers.New as GH
 import qualified Capnp.New.Classes as C
 import qualified GHC.Generics as Generics
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
 import qualified Prelude as Std_
 import qualified Data.Word as Std_
 import qualified Data.Int as Std_
diff --git a/gen/lib/Capnp/Gen/Capnp/Compat/Json/Pure.hs b/gen/lib/Capnp/Gen/Capnp/Compat/Json/Pure.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/Capnp/Compat/Json/Pure.hs
+++ /dev/null
@@ -1,258 +0,0 @@
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE RecordWildCards #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Capnp.Compat.Json.Pure(Value(..)
-                                       ,Value'Field(..)
-                                       ,Value'Call(..)
-                                       ,FlattenOptions(..)
-                                       ,DiscriminatorOptions(..)) where
-import qualified Capnp.GenHelpers.ReExports.Data.Vector as V
-import qualified Capnp.GenHelpers.ReExports.Data.Text as T
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Capnp.GenHelpers.ReExports.Data.Default as Default
-import qualified GHC.Generics as Generics
-import qualified Control.Monad.IO.Class as MonadIO
-import qualified Capnp.Untyped.Pure as UntypedPure
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Message as Message
-import qualified Capnp.Classes as Classes
-import qualified Capnp.Basics.Pure as BasicsPure
-import qualified Capnp.GenHelpers.Pure as GenHelpersPure
-import qualified Capnp.Gen.ById.X8ef99297a43a5e34
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-data Value 
-    = Value'null 
-    | Value'boolean Std_.Bool
-    | Value'number Std_.Double
-    | Value'string T.Text
-    | Value'array (V.Vector Value)
-    | Value'object (V.Vector Value'Field)
-    | Value'call Value'Call
-    | Value'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Value) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Value) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Value) where
-    type Cerial msg Value = (Capnp.Gen.ById.X8ef99297a43a5e34.Value msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.X8ef99297a43a5e34.get_Value' raw)
-        case raw of
-            (Capnp.Gen.ById.X8ef99297a43a5e34.Value'null) ->
-                (Std_.pure Value'null)
-            (Capnp.Gen.ById.X8ef99297a43a5e34.Value'boolean raw) ->
-                (Std_.pure (Value'boolean raw))
-            (Capnp.Gen.ById.X8ef99297a43a5e34.Value'number raw) ->
-                (Std_.pure (Value'number raw))
-            (Capnp.Gen.ById.X8ef99297a43a5e34.Value'string raw) ->
-                (Value'string <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X8ef99297a43a5e34.Value'array raw) ->
-                (Value'array <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X8ef99297a43a5e34.Value'object raw) ->
-                (Value'object <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X8ef99297a43a5e34.Value'call raw) ->
-                (Value'call <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X8ef99297a43a5e34.Value'unknown' tag) ->
-                (Std_.pure (Value'unknown' tag))
-        )
-instance (Classes.Marshal s Value) where
-    marshalInto raw_ value_ = case value_ of
-        (Value'null) ->
-            (Capnp.Gen.ById.X8ef99297a43a5e34.set_Value'null raw_)
-        (Value'boolean arg_) ->
-            (Capnp.Gen.ById.X8ef99297a43a5e34.set_Value'boolean raw_ arg_)
-        (Value'number arg_) ->
-            (Capnp.Gen.ById.X8ef99297a43a5e34.set_Value'number raw_ arg_)
-        (Value'string arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X8ef99297a43a5e34.set_Value'string raw_))
-        (Value'array arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X8ef99297a43a5e34.set_Value'array raw_))
-        (Value'object arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X8ef99297a43a5e34.set_Value'object raw_))
-        (Value'call arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X8ef99297a43a5e34.set_Value'call raw_))
-        (Value'unknown' tag) ->
-            (Capnp.Gen.ById.X8ef99297a43a5e34.set_Value'unknown' raw_ tag)
-instance (Classes.Cerialize s Value)
-instance (Classes.Cerialize s (V.Vector Value)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Value))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Value)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Value))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Value'Field 
-    = Value'Field 
-        {name :: T.Text
-        ,value :: Value}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Value'Field) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Value'Field) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Value'Field) where
-    type Cerial msg Value'Field = (Capnp.Gen.ById.X8ef99297a43a5e34.Value'Field msg)
-    decerialize raw = (Value'Field <$> ((Capnp.Gen.ById.X8ef99297a43a5e34.get_Value'Field'name raw) >>= Classes.decerialize)
-                                   <*> ((Capnp.Gen.ById.X8ef99297a43a5e34.get_Value'Field'value raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Value'Field) where
-    marshalInto raw_ value_ = case value_ of
-        Value'Field{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) name) >>= (Capnp.Gen.ById.X8ef99297a43a5e34.set_Value'Field'name raw_))
-                ((Classes.cerialize (Untyped.message raw_) value) >>= (Capnp.Gen.ById.X8ef99297a43a5e34.set_Value'Field'value raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Value'Field)
-instance (Classes.Cerialize s (V.Vector Value'Field)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Value'Field))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Value'Field)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Value'Field))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value'Field)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value'Field))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value'Field)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Value'Call 
-    = Value'Call 
-        {function :: T.Text
-        ,params :: (V.Vector Value)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Value'Call) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Value'Call) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Value'Call) where
-    type Cerial msg Value'Call = (Capnp.Gen.ById.X8ef99297a43a5e34.Value'Call msg)
-    decerialize raw = (Value'Call <$> ((Capnp.Gen.ById.X8ef99297a43a5e34.get_Value'Call'function raw) >>= Classes.decerialize)
-                                  <*> ((Capnp.Gen.ById.X8ef99297a43a5e34.get_Value'Call'params raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Value'Call) where
-    marshalInto raw_ value_ = case value_ of
-        Value'Call{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) function) >>= (Capnp.Gen.ById.X8ef99297a43a5e34.set_Value'Call'function raw_))
-                ((Classes.cerialize (Untyped.message raw_) params) >>= (Capnp.Gen.ById.X8ef99297a43a5e34.set_Value'Call'params raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Value'Call)
-instance (Classes.Cerialize s (V.Vector Value'Call)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Value'Call))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Value'Call)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Value'Call))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value'Call)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value'Call))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value'Call)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data FlattenOptions 
-    = FlattenOptions 
-        {prefix :: T.Text}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default FlattenOptions) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const FlattenOptions) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize FlattenOptions) where
-    type Cerial msg FlattenOptions = (Capnp.Gen.ById.X8ef99297a43a5e34.FlattenOptions msg)
-    decerialize raw = (FlattenOptions <$> ((Capnp.Gen.ById.X8ef99297a43a5e34.get_FlattenOptions'prefix raw) >>= Classes.decerialize))
-instance (Classes.Marshal s FlattenOptions) where
-    marshalInto raw_ value_ = case value_ of
-        FlattenOptions{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) prefix) >>= (Capnp.Gen.ById.X8ef99297a43a5e34.set_FlattenOptions'prefix raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s FlattenOptions)
-instance (Classes.Cerialize s (V.Vector FlattenOptions)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector FlattenOptions))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector FlattenOptions)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector FlattenOptions))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector FlattenOptions)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector FlattenOptions))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector FlattenOptions)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data DiscriminatorOptions 
-    = DiscriminatorOptions 
-        {name :: T.Text
-        ,valueName :: T.Text}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default DiscriminatorOptions) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const DiscriminatorOptions) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize DiscriminatorOptions) where
-    type Cerial msg DiscriminatorOptions = (Capnp.Gen.ById.X8ef99297a43a5e34.DiscriminatorOptions msg)
-    decerialize raw = (DiscriminatorOptions <$> ((Capnp.Gen.ById.X8ef99297a43a5e34.get_DiscriminatorOptions'name raw) >>= Classes.decerialize)
-                                            <*> ((Capnp.Gen.ById.X8ef99297a43a5e34.get_DiscriminatorOptions'valueName raw) >>= Classes.decerialize))
-instance (Classes.Marshal s DiscriminatorOptions) where
-    marshalInto raw_ value_ = case value_ of
-        DiscriminatorOptions{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) name) >>= (Capnp.Gen.ById.X8ef99297a43a5e34.set_DiscriminatorOptions'name raw_))
-                ((Classes.cerialize (Untyped.message raw_) valueName) >>= (Capnp.Gen.ById.X8ef99297a43a5e34.set_DiscriminatorOptions'valueName raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s DiscriminatorOptions)
-instance (Classes.Cerialize s (V.Vector DiscriminatorOptions)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector DiscriminatorOptions))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector DiscriminatorOptions)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector DiscriminatorOptions))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector DiscriminatorOptions)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector DiscriminatorOptions))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector DiscriminatorOptions)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
diff --git a/gen/lib/Capnp/Gen/Capnp/Cxx.hs b/gen/lib/Capnp/Gen/Capnp/Cxx.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/Capnp/Cxx.hs
+++ /dev/null
@@ -1,27 +0,0 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Capnp.Cxx where
-import qualified Capnp.Message as Message
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Basics as Basics
-import qualified Capnp.GenHelpers as GenHelpers
-import qualified Capnp.Classes as Classes
-import qualified GHC.Generics as Generics
-import qualified Capnp.Bits as Std_
-import qualified Data.Maybe as Std_
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/lib/Capnp/Gen/Capnp/Cxx/New.hs b/gen/lib/Capnp/Gen/Capnp/Cxx/New.hs
--- a/gen/lib/Capnp/Gen/Capnp/Cxx/New.hs
+++ b/gen/lib/Capnp/Gen/Capnp/Cxx/New.hs
@@ -27,7 +27,6 @@
 import qualified Capnp.GenHelpers.New as GH
 import qualified Capnp.New.Classes as C
 import qualified GHC.Generics as Generics
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
 import qualified Prelude as Std_
 import qualified Data.Word as Std_
 import qualified Data.Int as Std_
diff --git a/gen/lib/Capnp/Gen/Capnp/Cxx/Pure.hs b/gen/lib/Capnp/Gen/Capnp/Cxx/Pure.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/Capnp/Cxx/Pure.hs
+++ /dev/null
@@ -1,33 +0,0 @@
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE RecordWildCards #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Capnp.Cxx.Pure() where
-import qualified Capnp.GenHelpers.ReExports.Data.Vector as V
-import qualified Capnp.GenHelpers.ReExports.Data.Text as T
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Capnp.GenHelpers.ReExports.Data.Default as Default
-import qualified GHC.Generics as Generics
-import qualified Control.Monad.IO.Class as MonadIO
-import qualified Capnp.Untyped.Pure as UntypedPure
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Message as Message
-import qualified Capnp.Classes as Classes
-import qualified Capnp.Basics.Pure as BasicsPure
-import qualified Capnp.GenHelpers.Pure as GenHelpersPure
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/lib/Capnp/Gen/Capnp/Persistent.hs b/gen/lib/Capnp/Gen/Capnp/Persistent.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/Capnp/Persistent.hs
+++ /dev/null
@@ -1,253 +0,0 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Capnp.Persistent where
-import qualified Capnp.Message as Message
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Basics as Basics
-import qualified Capnp.GenHelpers as GenHelpers
-import qualified Capnp.Classes as Classes
-import qualified GHC.Generics as Generics
-import qualified Capnp.Bits as Std_
-import qualified Data.Maybe as Std_
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-newtype Persistent sturdyRef owner msg
-    = Persistent'newtype_ (Std_.Maybe (Untyped.Cap msg))
-instance (Classes.FromPtr msg (Persistent sturdyRef owner msg)) where
-    fromPtr msg ptr = (Persistent'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Persistent sturdyRef owner (Message.Mut s))) where
-    toPtr msg (Persistent'newtype_ (Std_.Nothing)) = (Std_.pure Std_.Nothing)
-    toPtr msg (Persistent'newtype_ (Std_.Just cap)) = (Std_.pure (Std_.Just (Untyped.PtrCap cap)))
-newtype Persistent'SaveParams sturdyRef owner msg
-    = Persistent'SaveParams'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Persistent'SaveParams sturdyRef owner msg)) where
-    fromStruct struct = (Std_.pure (Persistent'SaveParams'newtype_ struct))
-instance (Classes.ToStruct msg (Persistent'SaveParams sturdyRef owner msg)) where
-    toStruct (Persistent'SaveParams'newtype_ struct) = struct
-instance (Untyped.HasMessage (Persistent'SaveParams sturdyRef owner mut) mut) where
-    message (Persistent'SaveParams'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Persistent'SaveParams sturdyRef owner mut) mut) where
-    messageDefault msg = (Persistent'SaveParams'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Persistent'SaveParams sturdyRef owner msg)) where
-    fromPtr msg ptr = (Persistent'SaveParams'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Persistent'SaveParams sturdyRef owner (Message.Mut s))) where
-    toPtr msg (Persistent'SaveParams'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Persistent'SaveParams sturdyRef owner (Message.Mut s))) where
-    new msg = (Persistent'SaveParams'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Persistent'SaveParams sturdyRef owner mut)) where
-    newtype List mut (Persistent'SaveParams sturdyRef owner mut)
-        = Persistent'SaveParams'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Persistent'SaveParams'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Persistent'SaveParams'List_ l) = (Untyped.ListStruct l)
-    length (Persistent'SaveParams'List_ l) = (Untyped.length l)
-    index i (Persistent'SaveParams'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Persistent'SaveParams sturdyRef owner (Message.Mut s))) where
-    setIndex (Persistent'SaveParams'newtype_ elt) i (Persistent'SaveParams'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Persistent'SaveParams'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Persistent'SaveParams'sealFor :: ((Untyped.ReadCtx m msg)
-                                     ,(Classes.FromPtr msg owner)) => (Persistent'SaveParams sturdyRef owner msg) -> (m owner)
-get_Persistent'SaveParams'sealFor (Persistent'SaveParams'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Persistent'SaveParams'sealFor :: ((Untyped.RWCtx m s)
-                                     ,(Classes.ToPtr s owner)) => (Persistent'SaveParams sturdyRef owner (Message.Mut s)) -> owner -> (m ())
-set_Persistent'SaveParams'sealFor (Persistent'SaveParams'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Persistent'SaveParams'sealFor :: ((Untyped.ReadCtx m msg)) => (Persistent'SaveParams sturdyRef owner msg) -> (m Std_.Bool)
-has_Persistent'SaveParams'sealFor (Persistent'SaveParams'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-newtype Persistent'SaveResults sturdyRef owner msg
-    = Persistent'SaveResults'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Persistent'SaveResults sturdyRef owner msg)) where
-    fromStruct struct = (Std_.pure (Persistent'SaveResults'newtype_ struct))
-instance (Classes.ToStruct msg (Persistent'SaveResults sturdyRef owner msg)) where
-    toStruct (Persistent'SaveResults'newtype_ struct) = struct
-instance (Untyped.HasMessage (Persistent'SaveResults sturdyRef owner mut) mut) where
-    message (Persistent'SaveResults'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Persistent'SaveResults sturdyRef owner mut) mut) where
-    messageDefault msg = (Persistent'SaveResults'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Persistent'SaveResults sturdyRef owner msg)) where
-    fromPtr msg ptr = (Persistent'SaveResults'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Persistent'SaveResults sturdyRef owner (Message.Mut s))) where
-    toPtr msg (Persistent'SaveResults'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Persistent'SaveResults sturdyRef owner (Message.Mut s))) where
-    new msg = (Persistent'SaveResults'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Persistent'SaveResults sturdyRef owner mut)) where
-    newtype List mut (Persistent'SaveResults sturdyRef owner mut)
-        = Persistent'SaveResults'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Persistent'SaveResults'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Persistent'SaveResults'List_ l) = (Untyped.ListStruct l)
-    length (Persistent'SaveResults'List_ l) = (Untyped.length l)
-    index i (Persistent'SaveResults'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Persistent'SaveResults sturdyRef owner (Message.Mut s))) where
-    setIndex (Persistent'SaveResults'newtype_ elt) i (Persistent'SaveResults'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Persistent'SaveResults'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Persistent'SaveResults'sturdyRef :: ((Untyped.ReadCtx m msg)
-                                        ,(Classes.FromPtr msg sturdyRef)) => (Persistent'SaveResults sturdyRef owner msg) -> (m sturdyRef)
-get_Persistent'SaveResults'sturdyRef (Persistent'SaveResults'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Persistent'SaveResults'sturdyRef :: ((Untyped.RWCtx m s)
-                                        ,(Classes.ToPtr s sturdyRef)) => (Persistent'SaveResults sturdyRef owner (Message.Mut s)) -> sturdyRef -> (m ())
-set_Persistent'SaveResults'sturdyRef (Persistent'SaveResults'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Persistent'SaveResults'sturdyRef :: ((Untyped.ReadCtx m msg)) => (Persistent'SaveResults sturdyRef owner msg) -> (m Std_.Bool)
-has_Persistent'SaveResults'sturdyRef (Persistent'SaveResults'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-newtype RealmGateway internalRef externalRef internalOwner externalOwner msg
-    = RealmGateway'newtype_ (Std_.Maybe (Untyped.Cap msg))
-instance (Classes.FromPtr msg (RealmGateway internalRef externalRef internalOwner externalOwner msg)) where
-    fromPtr msg ptr = (RealmGateway'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (RealmGateway internalRef externalRef internalOwner externalOwner (Message.Mut s))) where
-    toPtr msg (RealmGateway'newtype_ (Std_.Nothing)) = (Std_.pure Std_.Nothing)
-    toPtr msg (RealmGateway'newtype_ (Std_.Just cap)) = (Std_.pure (Std_.Just (Untyped.PtrCap cap)))
-newtype RealmGateway'import'params internalRef externalRef internalOwner externalOwner msg
-    = RealmGateway'import'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (RealmGateway'import'params internalRef externalRef internalOwner externalOwner msg)) where
-    fromStruct struct = (Std_.pure (RealmGateway'import'params'newtype_ struct))
-instance (Classes.ToStruct msg (RealmGateway'import'params internalRef externalRef internalOwner externalOwner msg)) where
-    toStruct (RealmGateway'import'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (RealmGateway'import'params internalRef externalRef internalOwner externalOwner mut) mut) where
-    message (RealmGateway'import'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (RealmGateway'import'params internalRef externalRef internalOwner externalOwner mut) mut) where
-    messageDefault msg = (RealmGateway'import'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (RealmGateway'import'params internalRef externalRef internalOwner externalOwner msg)) where
-    fromPtr msg ptr = (RealmGateway'import'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (RealmGateway'import'params internalRef externalRef internalOwner externalOwner (Message.Mut s))) where
-    toPtr msg (RealmGateway'import'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (RealmGateway'import'params internalRef externalRef internalOwner externalOwner (Message.Mut s))) where
-    new msg = (RealmGateway'import'params'newtype_ <$> (Untyped.allocStruct msg 0 2))
-instance (Basics.ListElem mut (RealmGateway'import'params internalRef externalRef internalOwner externalOwner mut)) where
-    newtype List mut (RealmGateway'import'params internalRef externalRef internalOwner externalOwner mut)
-        = RealmGateway'import'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (RealmGateway'import'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (RealmGateway'import'params'List_ l) = (Untyped.ListStruct l)
-    length (RealmGateway'import'params'List_ l) = (Untyped.length l)
-    index i (RealmGateway'import'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (RealmGateway'import'params internalRef externalRef internalOwner externalOwner (Message.Mut s))) where
-    setIndex (RealmGateway'import'params'newtype_ elt) i (RealmGateway'import'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (RealmGateway'import'params'List_ <$> (Untyped.allocCompositeList msg 0 2 len))
-get_RealmGateway'import'params'cap :: ((Untyped.ReadCtx m msg)
-                                      ,(Classes.FromPtr msg (Persistent externalRef externalOwner msg))) => (RealmGateway'import'params internalRef externalRef internalOwner externalOwner msg) -> (m (Persistent externalRef externalOwner msg))
-get_RealmGateway'import'params'cap (RealmGateway'import'params'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_RealmGateway'import'params'cap :: ((Untyped.RWCtx m s)
-                                      ,(Classes.ToPtr s (Persistent externalRef externalOwner (Message.Mut s)))) => (RealmGateway'import'params internalRef externalRef internalOwner externalOwner (Message.Mut s)) -> (Persistent externalRef externalOwner (Message.Mut s)) -> (m ())
-set_RealmGateway'import'params'cap (RealmGateway'import'params'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_RealmGateway'import'params'cap :: ((Untyped.ReadCtx m msg)) => (RealmGateway'import'params internalRef externalRef internalOwner externalOwner msg) -> (m Std_.Bool)
-has_RealmGateway'import'params'cap (RealmGateway'import'params'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-get_RealmGateway'import'params'params :: ((Untyped.ReadCtx m msg)
-                                         ,(Classes.FromPtr msg (Persistent'SaveParams internalRef internalOwner msg))) => (RealmGateway'import'params internalRef externalRef internalOwner externalOwner msg) -> (m (Persistent'SaveParams internalRef internalOwner msg))
-get_RealmGateway'import'params'params (RealmGateway'import'params'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_RealmGateway'import'params'params :: ((Untyped.RWCtx m s)
-                                         ,(Classes.ToPtr s (Persistent'SaveParams internalRef internalOwner (Message.Mut s)))) => (RealmGateway'import'params internalRef externalRef internalOwner externalOwner (Message.Mut s)) -> (Persistent'SaveParams internalRef internalOwner (Message.Mut s)) -> (m ())
-set_RealmGateway'import'params'params (RealmGateway'import'params'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_RealmGateway'import'params'params :: ((Untyped.ReadCtx m msg)) => (RealmGateway'import'params internalRef externalRef internalOwner externalOwner msg) -> (m Std_.Bool)
-has_RealmGateway'import'params'params (RealmGateway'import'params'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_RealmGateway'import'params'params :: ((Untyped.RWCtx m s)) => (RealmGateway'import'params internalRef externalRef internalOwner externalOwner (Message.Mut s)) -> (m (Persistent'SaveParams internalRef internalOwner (Message.Mut s)))
-new_RealmGateway'import'params'params struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_RealmGateway'import'params'params struct result)
-    (Std_.pure result)
-    )
-newtype RealmGateway'export'params internalRef externalRef internalOwner externalOwner msg
-    = RealmGateway'export'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (RealmGateway'export'params internalRef externalRef internalOwner externalOwner msg)) where
-    fromStruct struct = (Std_.pure (RealmGateway'export'params'newtype_ struct))
-instance (Classes.ToStruct msg (RealmGateway'export'params internalRef externalRef internalOwner externalOwner msg)) where
-    toStruct (RealmGateway'export'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (RealmGateway'export'params internalRef externalRef internalOwner externalOwner mut) mut) where
-    message (RealmGateway'export'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (RealmGateway'export'params internalRef externalRef internalOwner externalOwner mut) mut) where
-    messageDefault msg = (RealmGateway'export'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (RealmGateway'export'params internalRef externalRef internalOwner externalOwner msg)) where
-    fromPtr msg ptr = (RealmGateway'export'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (RealmGateway'export'params internalRef externalRef internalOwner externalOwner (Message.Mut s))) where
-    toPtr msg (RealmGateway'export'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (RealmGateway'export'params internalRef externalRef internalOwner externalOwner (Message.Mut s))) where
-    new msg = (RealmGateway'export'params'newtype_ <$> (Untyped.allocStruct msg 0 2))
-instance (Basics.ListElem mut (RealmGateway'export'params internalRef externalRef internalOwner externalOwner mut)) where
-    newtype List mut (RealmGateway'export'params internalRef externalRef internalOwner externalOwner mut)
-        = RealmGateway'export'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (RealmGateway'export'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (RealmGateway'export'params'List_ l) = (Untyped.ListStruct l)
-    length (RealmGateway'export'params'List_ l) = (Untyped.length l)
-    index i (RealmGateway'export'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (RealmGateway'export'params internalRef externalRef internalOwner externalOwner (Message.Mut s))) where
-    setIndex (RealmGateway'export'params'newtype_ elt) i (RealmGateway'export'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (RealmGateway'export'params'List_ <$> (Untyped.allocCompositeList msg 0 2 len))
-get_RealmGateway'export'params'cap :: ((Untyped.ReadCtx m msg)
-                                      ,(Classes.FromPtr msg (Persistent internalRef internalOwner msg))) => (RealmGateway'export'params internalRef externalRef internalOwner externalOwner msg) -> (m (Persistent internalRef internalOwner msg))
-get_RealmGateway'export'params'cap (RealmGateway'export'params'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_RealmGateway'export'params'cap :: ((Untyped.RWCtx m s)
-                                      ,(Classes.ToPtr s (Persistent internalRef internalOwner (Message.Mut s)))) => (RealmGateway'export'params internalRef externalRef internalOwner externalOwner (Message.Mut s)) -> (Persistent internalRef internalOwner (Message.Mut s)) -> (m ())
-set_RealmGateway'export'params'cap (RealmGateway'export'params'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_RealmGateway'export'params'cap :: ((Untyped.ReadCtx m msg)) => (RealmGateway'export'params internalRef externalRef internalOwner externalOwner msg) -> (m Std_.Bool)
-has_RealmGateway'export'params'cap (RealmGateway'export'params'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-get_RealmGateway'export'params'params :: ((Untyped.ReadCtx m msg)
-                                         ,(Classes.FromPtr msg (Persistent'SaveParams externalRef externalOwner msg))) => (RealmGateway'export'params internalRef externalRef internalOwner externalOwner msg) -> (m (Persistent'SaveParams externalRef externalOwner msg))
-get_RealmGateway'export'params'params (RealmGateway'export'params'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_RealmGateway'export'params'params :: ((Untyped.RWCtx m s)
-                                         ,(Classes.ToPtr s (Persistent'SaveParams externalRef externalOwner (Message.Mut s)))) => (RealmGateway'export'params internalRef externalRef internalOwner externalOwner (Message.Mut s)) -> (Persistent'SaveParams externalRef externalOwner (Message.Mut s)) -> (m ())
-set_RealmGateway'export'params'params (RealmGateway'export'params'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_RealmGateway'export'params'params :: ((Untyped.ReadCtx m msg)) => (RealmGateway'export'params internalRef externalRef internalOwner externalOwner msg) -> (m Std_.Bool)
-has_RealmGateway'export'params'params (RealmGateway'export'params'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_RealmGateway'export'params'params :: ((Untyped.RWCtx m s)) => (RealmGateway'export'params internalRef externalRef internalOwner externalOwner (Message.Mut s)) -> (m (Persistent'SaveParams externalRef externalOwner (Message.Mut s)))
-new_RealmGateway'export'params'params struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_RealmGateway'export'params'params struct result)
-    (Std_.pure result)
-    )
diff --git a/gen/lib/Capnp/Gen/Capnp/Persistent/New.hs b/gen/lib/Capnp/Gen/Capnp/Persistent/New.hs
--- a/gen/lib/Capnp/Gen/Capnp/Persistent/New.hs
+++ b/gen/lib/Capnp/Gen/Capnp/Persistent/New.hs
@@ -27,7 +27,7 @@
 import qualified Capnp.GenHelpers.New as GH
 import qualified Capnp.New.Classes as C
 import qualified GHC.Generics as Generics
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
+import qualified Capnp.GenHelpers.New.Rpc as GH
 import qualified Prelude as Std_
 import qualified Data.Word as Std_
 import qualified Data.Int as Std_
diff --git a/gen/lib/Capnp/Gen/Capnp/Persistent/Pure.hs b/gen/lib/Capnp/Gen/Capnp/Persistent/Pure.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/Capnp/Persistent/Pure.hs
+++ /dev/null
@@ -1,740 +0,0 @@
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE RecordWildCards #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Capnp.Persistent.Pure(Persistent(..)
-                                      ,Persistent'server_(..)
-                                      ,export_Persistent
-                                      ,Persistent'SaveParams(..)
-                                      ,Persistent'SaveResults(..)
-                                      ,RealmGateway(..)
-                                      ,RealmGateway'server_(..)
-                                      ,export_RealmGateway
-                                      ,RealmGateway'import'params(..)
-                                      ,RealmGateway'export'params(..)) where
-import qualified Capnp.GenHelpers.ReExports.Data.Vector as V
-import qualified Capnp.GenHelpers.ReExports.Data.Text as T
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Capnp.GenHelpers.ReExports.Data.Default as Default
-import qualified GHC.Generics as Generics
-import qualified Control.Monad.IO.Class as MonadIO
-import qualified Capnp.Untyped.Pure as UntypedPure
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Message as Message
-import qualified Capnp.Classes as Classes
-import qualified Capnp.Basics.Pure as BasicsPure
-import qualified Capnp.GenHelpers.Pure as GenHelpersPure
-import qualified Capnp.Rpc.Untyped as Rpc
-import qualified Capnp.Rpc.Server as Server
-import qualified Capnp.GenHelpers.Rpc as RpcHelpers
-import qualified Capnp.GenHelpers.ReExports.Control.Concurrent.STM as STM
-import qualified Capnp.GenHelpers.ReExports.Control.Monad.STM.Class as STM
-import qualified Capnp.GenHelpers.ReExports.Supervisors as Supervisors
-import qualified Capnp.Gen.ById.Xb8630836983feed7
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-newtype Persistent sturdyRef owner
-    = Persistent Message.Client
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-class ((MonadIO.MonadIO m)
-      ,(Server.Server m cap)) => (Persistent'server_ m cap sturdyRef owner) | cap -> sturdyRef, cap -> owner where
-    {-# MINIMAL persistent'save #-}
-    persistent'save :: cap -> (Server.MethodHandler m (Persistent'SaveParams sturdyRef owner) (Persistent'SaveResults sturdyRef owner))
-    persistent'save _ = Server.methodUnimplemented
-export_Persistent :: ((STM.MonadSTM m)
-                     ,(Persistent'server_ Std_.IO cap sturdyRef owner)) => Supervisors.Supervisor -> cap -> (m (Persistent sturdyRef owner))
-export_Persistent sup_ server_ = (STM.liftSTM (Persistent <$> (Rpc.export sup_ Server.ServerOps{handleCast = (Server.unwrap server_)
-                                                                                               ,handleStop = (Server.shutdown server_)
-                                                                                               ,handleCall = (\interfaceId_ methodId_ -> case interfaceId_ of
-                                                                                                   14468694717054801553 ->
-                                                                                                       case methodId_ of
-                                                                                                           0 ->
-                                                                                                               (Server.toUntypedHandler (persistent'save server_))
-                                                                                                           _ ->
-                                                                                                               Server.methodUnimplemented
-                                                                                                   _ ->
-                                                                                                       Server.methodUnimplemented)})))
-instance (Rpc.IsClient (Persistent sturdyRef owner)) where
-    fromClient  = Persistent
-    toClient (Persistent client) = client
-instance (Classes.FromPtr msg (Persistent sturdyRef owner)) where
-    fromPtr  = RpcHelpers.isClientFromPtr
-instance (Classes.ToPtr s (Persistent sturdyRef owner)) where
-    toPtr  = RpcHelpers.isClientToPtr
-instance (Classes.Decerialize (Persistent sturdyRef owner)) where
-    type Cerial msg (Persistent sturdyRef owner) = (Capnp.Gen.ById.Xb8630836983feed7.Persistent (Classes.Cerial msg sturdyRef) (Classes.Cerial msg owner) msg)
-    decerialize (Capnp.Gen.ById.Xb8630836983feed7.Persistent'newtype_ maybeCap) = case maybeCap of
-        (Std_.Nothing) ->
-            (Std_.pure (Persistent Message.nullClient))
-        (Std_.Just cap) ->
-            (Persistent <$> (Untyped.getClient cap))
-instance (Classes.Cerialize s (Persistent sturdyRef owner)) where
-    cerialize msg (Persistent client) = (Capnp.Gen.ById.Xb8630836983feed7.Persistent'newtype_ <$> (Std_.Just <$> (Untyped.appendCap msg client)))
-instance (Server.Server Std_.IO (Persistent sturdyRef owner))
-instance (Persistent'server_ Std_.IO (Persistent sturdyRef owner) sturdyRef owner) where
-    persistent'save (Persistent client) = (Rpc.clientMethodHandler 14468694717054801553 0 client)
-data Persistent'SaveParams sturdyRef owner
-    = Persistent'SaveParams 
-        {sealFor :: owner}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))) => (Default.Default (Persistent'SaveParams sturdyRef owner)) where
-    def  = GenHelpersPure.defaultStruct
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))) => (Classes.FromStruct Message.Const (Persistent'SaveParams sturdyRef owner)) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))) => (Classes.Decerialize (Persistent'SaveParams sturdyRef owner)) where
-    type Cerial msg (Persistent'SaveParams sturdyRef owner) = (Capnp.Gen.ById.Xb8630836983feed7.Persistent'SaveParams (Classes.Cerial msg sturdyRef) (Classes.Cerial msg owner) msg)
-    decerialize raw = (Persistent'SaveParams <$> ((Capnp.Gen.ById.Xb8630836983feed7.get_Persistent'SaveParams'sealFor raw) >>= Classes.decerialize))
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Marshal s (Persistent'SaveParams sturdyRef owner)) where
-    marshalInto raw_ value_ = case value_ of
-        Persistent'SaveParams{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) sealFor) >>= (Capnp.Gen.ById.Xb8630836983feed7.set_Persistent'SaveParams'sealFor raw_))
-                (Std_.pure ())
-                )
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Cerialize s (Persistent'SaveParams sturdyRef owner))
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Cerialize s (V.Vector (Persistent'SaveParams sturdyRef owner))) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Cerialize s (V.Vector (V.Vector (Persistent'SaveParams sturdyRef owner)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (Persistent'SaveParams sturdyRef owner))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (Persistent'SaveParams sturdyRef owner)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Persistent'SaveParams sturdyRef owner))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Persistent'SaveParams sturdyRef owner)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Persistent'SaveParams sturdyRef owner))))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Persistent'SaveResults sturdyRef owner
-    = Persistent'SaveResults 
-        {sturdyRef :: sturdyRef}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))) => (Default.Default (Persistent'SaveResults sturdyRef owner)) where
-    def  = GenHelpersPure.defaultStruct
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))) => (Classes.FromStruct Message.Const (Persistent'SaveResults sturdyRef owner)) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))) => (Classes.Decerialize (Persistent'SaveResults sturdyRef owner)) where
-    type Cerial msg (Persistent'SaveResults sturdyRef owner) = (Capnp.Gen.ById.Xb8630836983feed7.Persistent'SaveResults (Classes.Cerial msg sturdyRef) (Classes.Cerial msg owner) msg)
-    decerialize raw = (Persistent'SaveResults <$> ((Capnp.Gen.ById.Xb8630836983feed7.get_Persistent'SaveResults'sturdyRef raw) >>= Classes.decerialize))
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Marshal s (Persistent'SaveResults sturdyRef owner)) where
-    marshalInto raw_ value_ = case value_ of
-        Persistent'SaveResults{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) sturdyRef) >>= (Capnp.Gen.ById.Xb8630836983feed7.set_Persistent'SaveResults'sturdyRef raw_))
-                (Std_.pure ())
-                )
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Cerialize s (Persistent'SaveResults sturdyRef owner))
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Cerialize s (V.Vector (Persistent'SaveResults sturdyRef owner))) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Cerialize s (V.Vector (V.Vector (Persistent'SaveResults sturdyRef owner)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (Persistent'SaveResults sturdyRef owner))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (Persistent'SaveResults sturdyRef owner)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Persistent'SaveResults sturdyRef owner))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Persistent'SaveResults sturdyRef owner)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize sturdyRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const sturdyRef))
-         ,(Classes.Decerialize owner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const owner))
-         ,(Classes.Cerialize s sturdyRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) sturdyRef))
-         ,(Classes.Cerialize s owner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) owner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Persistent'SaveResults sturdyRef owner))))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-newtype RealmGateway internalRef externalRef internalOwner externalOwner
-    = RealmGateway Message.Client
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-class ((MonadIO.MonadIO m)
-      ,(Server.Server m cap)) => (RealmGateway'server_ m cap internalRef externalRef internalOwner externalOwner) | cap -> internalRef, cap -> externalRef, cap -> internalOwner, cap -> externalOwner where
-    {-# MINIMAL realmGateway'import_,realmGateway'export #-}
-    realmGateway'import_ :: cap -> (Server.MethodHandler m (RealmGateway'import'params internalRef externalRef internalOwner externalOwner) (Persistent'SaveResults internalRef internalOwner))
-    realmGateway'import_ _ = Server.methodUnimplemented
-    realmGateway'export :: cap -> (Server.MethodHandler m (RealmGateway'export'params internalRef externalRef internalOwner externalOwner) (Persistent'SaveResults externalRef externalOwner))
-    realmGateway'export _ = Server.methodUnimplemented
-export_RealmGateway :: ((STM.MonadSTM m)
-                       ,(RealmGateway'server_ Std_.IO cap internalRef externalRef internalOwner externalOwner)) => Supervisors.Supervisor -> cap -> (m (RealmGateway internalRef externalRef internalOwner externalOwner))
-export_RealmGateway sup_ server_ = (STM.liftSTM (RealmGateway <$> (Rpc.export sup_ Server.ServerOps{handleCast = (Server.unwrap server_)
-                                                                                                   ,handleStop = (Server.shutdown server_)
-                                                                                                   ,handleCall = (\interfaceId_ methodId_ -> case interfaceId_ of
-                                                                                                       9583422979879616212 ->
-                                                                                                           case methodId_ of
-                                                                                                               0 ->
-                                                                                                                   (Server.toUntypedHandler (realmGateway'import_ server_))
-                                                                                                               1 ->
-                                                                                                                   (Server.toUntypedHandler (realmGateway'export server_))
-                                                                                                               _ ->
-                                                                                                                   Server.methodUnimplemented
-                                                                                                       _ ->
-                                                                                                           Server.methodUnimplemented)})))
-instance (Rpc.IsClient (RealmGateway internalRef externalRef internalOwner externalOwner)) where
-    fromClient  = RealmGateway
-    toClient (RealmGateway client) = client
-instance (Classes.FromPtr msg (RealmGateway internalRef externalRef internalOwner externalOwner)) where
-    fromPtr  = RpcHelpers.isClientFromPtr
-instance (Classes.ToPtr s (RealmGateway internalRef externalRef internalOwner externalOwner)) where
-    toPtr  = RpcHelpers.isClientToPtr
-instance (Classes.Decerialize (RealmGateway internalRef externalRef internalOwner externalOwner)) where
-    type Cerial msg (RealmGateway internalRef externalRef internalOwner externalOwner) = (Capnp.Gen.ById.Xb8630836983feed7.RealmGateway (Classes.Cerial msg internalRef) (Classes.Cerial msg externalRef) (Classes.Cerial msg internalOwner) (Classes.Cerial msg externalOwner) msg)
-    decerialize (Capnp.Gen.ById.Xb8630836983feed7.RealmGateway'newtype_ maybeCap) = case maybeCap of
-        (Std_.Nothing) ->
-            (Std_.pure (RealmGateway Message.nullClient))
-        (Std_.Just cap) ->
-            (RealmGateway <$> (Untyped.getClient cap))
-instance (Classes.Cerialize s (RealmGateway internalRef externalRef internalOwner externalOwner)) where
-    cerialize msg (RealmGateway client) = (Capnp.Gen.ById.Xb8630836983feed7.RealmGateway'newtype_ <$> (Std_.Just <$> (Untyped.appendCap msg client)))
-instance (Server.Server Std_.IO (RealmGateway internalRef externalRef internalOwner externalOwner))
-instance (RealmGateway'server_ Std_.IO (RealmGateway internalRef externalRef internalOwner externalOwner) internalRef externalRef internalOwner externalOwner) where
-    realmGateway'import_ (RealmGateway client) = (Rpc.clientMethodHandler 9583422979879616212 0 client)
-    realmGateway'export (RealmGateway client) = (Rpc.clientMethodHandler 9583422979879616212 1 client)
-data RealmGateway'import'params internalRef externalRef internalOwner externalOwner
-    = RealmGateway'import'params 
-        {cap :: (Persistent externalRef externalOwner)
-        ,params :: (Persistent'SaveParams internalRef internalOwner)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))) => (Default.Default (RealmGateway'import'params internalRef externalRef internalOwner externalOwner)) where
-    def  = GenHelpersPure.defaultStruct
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))) => (Classes.FromStruct Message.Const (RealmGateway'import'params internalRef externalRef internalOwner externalOwner)) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))) => (Classes.Decerialize (RealmGateway'import'params internalRef externalRef internalOwner externalOwner)) where
-    type Cerial msg (RealmGateway'import'params internalRef externalRef internalOwner externalOwner) = (Capnp.Gen.ById.Xb8630836983feed7.RealmGateway'import'params (Classes.Cerial msg internalRef) (Classes.Cerial msg externalRef) (Classes.Cerial msg internalOwner) (Classes.Cerial msg externalOwner) msg)
-    decerialize raw = (RealmGateway'import'params <$> ((Capnp.Gen.ById.Xb8630836983feed7.get_RealmGateway'import'params'cap raw) >>= Classes.decerialize)
-                                                  <*> ((Capnp.Gen.ById.Xb8630836983feed7.get_RealmGateway'import'params'params raw) >>= Classes.decerialize))
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Marshal s (RealmGateway'import'params internalRef externalRef internalOwner externalOwner)) where
-    marshalInto raw_ value_ = case value_ of
-        RealmGateway'import'params{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) cap) >>= (Capnp.Gen.ById.Xb8630836983feed7.set_RealmGateway'import'params'cap raw_))
-                ((Classes.cerialize (Untyped.message raw_) params) >>= (Capnp.Gen.ById.Xb8630836983feed7.set_RealmGateway'import'params'params raw_))
-                (Std_.pure ())
-                )
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Cerialize s (RealmGateway'import'params internalRef externalRef internalOwner externalOwner))
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Cerialize s (V.Vector (RealmGateway'import'params internalRef externalRef internalOwner externalOwner))) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Cerialize s (V.Vector (V.Vector (RealmGateway'import'params internalRef externalRef internalOwner externalOwner)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (RealmGateway'import'params internalRef externalRef internalOwner externalOwner))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (RealmGateway'import'params internalRef externalRef internalOwner externalOwner)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (RealmGateway'import'params internalRef externalRef internalOwner externalOwner))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (RealmGateway'import'params internalRef externalRef internalOwner externalOwner)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (RealmGateway'import'params internalRef externalRef internalOwner externalOwner))))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data RealmGateway'export'params internalRef externalRef internalOwner externalOwner
-    = RealmGateway'export'params 
-        {cap :: (Persistent internalRef internalOwner)
-        ,params :: (Persistent'SaveParams externalRef externalOwner)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))) => (Default.Default (RealmGateway'export'params internalRef externalRef internalOwner externalOwner)) where
-    def  = GenHelpersPure.defaultStruct
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))) => (Classes.FromStruct Message.Const (RealmGateway'export'params internalRef externalRef internalOwner externalOwner)) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))) => (Classes.Decerialize (RealmGateway'export'params internalRef externalRef internalOwner externalOwner)) where
-    type Cerial msg (RealmGateway'export'params internalRef externalRef internalOwner externalOwner) = (Capnp.Gen.ById.Xb8630836983feed7.RealmGateway'export'params (Classes.Cerial msg internalRef) (Classes.Cerial msg externalRef) (Classes.Cerial msg internalOwner) (Classes.Cerial msg externalOwner) msg)
-    decerialize raw = (RealmGateway'export'params <$> ((Capnp.Gen.ById.Xb8630836983feed7.get_RealmGateway'export'params'cap raw) >>= Classes.decerialize)
-                                                  <*> ((Capnp.Gen.ById.Xb8630836983feed7.get_RealmGateway'export'params'params raw) >>= Classes.decerialize))
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Marshal s (RealmGateway'export'params internalRef externalRef internalOwner externalOwner)) where
-    marshalInto raw_ value_ = case value_ of
-        RealmGateway'export'params{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) cap) >>= (Capnp.Gen.ById.Xb8630836983feed7.set_RealmGateway'export'params'cap raw_))
-                ((Classes.cerialize (Untyped.message raw_) params) >>= (Capnp.Gen.ById.Xb8630836983feed7.set_RealmGateway'export'params'params raw_))
-                (Std_.pure ())
-                )
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Cerialize s (RealmGateway'export'params internalRef externalRef internalOwner externalOwner))
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Cerialize s (V.Vector (RealmGateway'export'params internalRef externalRef internalOwner externalOwner))) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Cerialize s (V.Vector (V.Vector (RealmGateway'export'params internalRef externalRef internalOwner externalOwner)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (RealmGateway'export'params internalRef externalRef internalOwner externalOwner))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (RealmGateway'export'params internalRef externalRef internalOwner externalOwner)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (RealmGateway'export'params internalRef externalRef internalOwner externalOwner))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (RealmGateway'export'params internalRef externalRef internalOwner externalOwner)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize internalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalRef))
-         ,(Classes.Decerialize externalRef)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalRef))
-         ,(Classes.Decerialize internalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const internalOwner))
-         ,(Classes.Decerialize externalOwner)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const externalOwner))
-         ,(Classes.Cerialize s internalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalRef))
-         ,(Classes.Cerialize s externalRef)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalRef))
-         ,(Classes.Cerialize s internalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) internalOwner))
-         ,(Classes.Cerialize s externalOwner)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) externalOwner))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (RealmGateway'export'params internalRef externalRef internalOwner externalOwner))))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
diff --git a/gen/lib/Capnp/Gen/Capnp/Rpc.hs b/gen/lib/Capnp/Gen/Capnp/Rpc.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/Capnp/Rpc.hs
+++ /dev/null
@@ -1,1532 +0,0 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Capnp.Rpc where
-import qualified Capnp.Message as Message
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Basics as Basics
-import qualified Capnp.GenHelpers as GenHelpers
-import qualified Capnp.Classes as Classes
-import qualified GHC.Generics as Generics
-import qualified Capnp.Bits as Std_
-import qualified Data.Maybe as Std_
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-newtype Message msg
-    = Message'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Message msg)) where
-    fromStruct struct = (Std_.pure (Message'newtype_ struct))
-instance (Classes.ToStruct msg (Message msg)) where
-    toStruct (Message'newtype_ struct) = struct
-instance (Untyped.HasMessage (Message mut) mut) where
-    message (Message'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Message mut) mut) where
-    messageDefault msg = (Message'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Message msg)) where
-    fromPtr msg ptr = (Message'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Message (Message.Mut s))) where
-    toPtr msg (Message'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Message (Message.Mut s))) where
-    new msg = (Message'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (Message mut)) where
-    newtype List mut (Message mut)
-        = Message'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Message'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Message'List_ l) = (Untyped.ListStruct l)
-    length (Message'List_ l) = (Untyped.length l)
-    index i (Message'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Message (Message.Mut s))) where
-    setIndex (Message'newtype_ elt) i (Message'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Message'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-data Message' (mut :: Message.Mutability)
-    = Message'unimplemented (Message mut)
-    | Message'abort (Exception mut)
-    | Message'call (Call mut)
-    | Message'return (Return mut)
-    | Message'finish (Finish mut)
-    | Message'resolve (Resolve mut)
-    | Message'release (Release mut)
-    | Message'obsoleteSave (Std_.Maybe (Untyped.Ptr mut))
-    | Message'bootstrap (Bootstrap mut)
-    | Message'obsoleteDelete (Std_.Maybe (Untyped.Ptr mut))
-    | Message'provide (Provide mut)
-    | Message'accept (Accept mut)
-    | Message'join (Join mut)
-    | Message'disembargo (Disembargo mut)
-    | Message'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Message' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 0)
-        case tag of
-            0 ->
-                (Message'unimplemented <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            1 ->
-                (Message'abort <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            2 ->
-                (Message'call <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            3 ->
-                (Message'return <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            4 ->
-                (Message'finish <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            5 ->
-                (Message'resolve <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            6 ->
-                (Message'release <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            7 ->
-                (Message'obsoleteSave <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            8 ->
-                (Message'bootstrap <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            9 ->
-                (Message'obsoleteDelete <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            10 ->
-                (Message'provide <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            11 ->
-                (Message'accept <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            12 ->
-                (Message'join <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            13 ->
-                (Message'disembargo <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            _ ->
-                (Std_.pure (Message'unknown' (Std_.fromIntegral tag)))
-        )
-get_Message' :: ((Untyped.ReadCtx m msg)
-                ,(Classes.FromStruct msg (Message' msg))) => (Message msg) -> (m (Message' msg))
-get_Message' (Message'newtype_ struct) = (Classes.fromStruct struct)
-set_Message'unimplemented :: ((Untyped.RWCtx m s)
-                             ,(Classes.ToPtr s (Message (Message.Mut s)))) => (Message (Message.Mut s)) -> (Message (Message.Mut s)) -> (m ())
-set_Message'unimplemented (Message'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Message'abort :: ((Untyped.RWCtx m s)
-                     ,(Classes.ToPtr s (Exception (Message.Mut s)))) => (Message (Message.Mut s)) -> (Exception (Message.Mut s)) -> (m ())
-set_Message'abort (Message'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Message'call :: ((Untyped.RWCtx m s)
-                    ,(Classes.ToPtr s (Call (Message.Mut s)))) => (Message (Message.Mut s)) -> (Call (Message.Mut s)) -> (m ())
-set_Message'call (Message'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (2 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Message'return :: ((Untyped.RWCtx m s)
-                      ,(Classes.ToPtr s (Return (Message.Mut s)))) => (Message (Message.Mut s)) -> (Return (Message.Mut s)) -> (m ())
-set_Message'return (Message'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (3 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Message'finish :: ((Untyped.RWCtx m s)
-                      ,(Classes.ToPtr s (Finish (Message.Mut s)))) => (Message (Message.Mut s)) -> (Finish (Message.Mut s)) -> (m ())
-set_Message'finish (Message'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (4 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Message'resolve :: ((Untyped.RWCtx m s)
-                       ,(Classes.ToPtr s (Resolve (Message.Mut s)))) => (Message (Message.Mut s)) -> (Resolve (Message.Mut s)) -> (m ())
-set_Message'resolve (Message'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (5 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Message'release :: ((Untyped.RWCtx m s)
-                       ,(Classes.ToPtr s (Release (Message.Mut s)))) => (Message (Message.Mut s)) -> (Release (Message.Mut s)) -> (m ())
-set_Message'release (Message'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (6 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Message'obsoleteSave :: ((Untyped.RWCtx m s)
-                            ,(Classes.ToPtr s (Std_.Maybe (Untyped.Ptr (Message.Mut s))))) => (Message (Message.Mut s)) -> (Std_.Maybe (Untyped.Ptr (Message.Mut s))) -> (m ())
-set_Message'obsoleteSave (Message'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (7 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Message'bootstrap :: ((Untyped.RWCtx m s)
-                         ,(Classes.ToPtr s (Bootstrap (Message.Mut s)))) => (Message (Message.Mut s)) -> (Bootstrap (Message.Mut s)) -> (m ())
-set_Message'bootstrap (Message'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (8 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Message'obsoleteDelete :: ((Untyped.RWCtx m s)
-                              ,(Classes.ToPtr s (Std_.Maybe (Untyped.Ptr (Message.Mut s))))) => (Message (Message.Mut s)) -> (Std_.Maybe (Untyped.Ptr (Message.Mut s))) -> (m ())
-set_Message'obsoleteDelete (Message'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (9 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Message'provide :: ((Untyped.RWCtx m s)
-                       ,(Classes.ToPtr s (Provide (Message.Mut s)))) => (Message (Message.Mut s)) -> (Provide (Message.Mut s)) -> (m ())
-set_Message'provide (Message'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (10 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Message'accept :: ((Untyped.RWCtx m s)
-                      ,(Classes.ToPtr s (Accept (Message.Mut s)))) => (Message (Message.Mut s)) -> (Accept (Message.Mut s)) -> (m ())
-set_Message'accept (Message'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (11 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Message'join :: ((Untyped.RWCtx m s)
-                    ,(Classes.ToPtr s (Join (Message.Mut s)))) => (Message (Message.Mut s)) -> (Join (Message.Mut s)) -> (m ())
-set_Message'join (Message'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (12 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Message'disembargo :: ((Untyped.RWCtx m s)
-                          ,(Classes.ToPtr s (Disembargo (Message.Mut s)))) => (Message (Message.Mut s)) -> (Disembargo (Message.Mut s)) -> (m ())
-set_Message'disembargo (Message'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (13 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Message'unknown' :: ((Untyped.RWCtx m s)) => (Message (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Message'unknown' (Message'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-newtype Bootstrap msg
-    = Bootstrap'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Bootstrap msg)) where
-    fromStruct struct = (Std_.pure (Bootstrap'newtype_ struct))
-instance (Classes.ToStruct msg (Bootstrap msg)) where
-    toStruct (Bootstrap'newtype_ struct) = struct
-instance (Untyped.HasMessage (Bootstrap mut) mut) where
-    message (Bootstrap'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Bootstrap mut) mut) where
-    messageDefault msg = (Bootstrap'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Bootstrap msg)) where
-    fromPtr msg ptr = (Bootstrap'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Bootstrap (Message.Mut s))) where
-    toPtr msg (Bootstrap'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Bootstrap (Message.Mut s))) where
-    new msg = (Bootstrap'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (Bootstrap mut)) where
-    newtype List mut (Bootstrap mut)
-        = Bootstrap'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Bootstrap'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Bootstrap'List_ l) = (Untyped.ListStruct l)
-    length (Bootstrap'List_ l) = (Untyped.length l)
-    index i (Bootstrap'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Bootstrap (Message.Mut s))) where
-    setIndex (Bootstrap'newtype_ elt) i (Bootstrap'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Bootstrap'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-get_Bootstrap'questionId :: ((Untyped.ReadCtx m msg)) => (Bootstrap msg) -> (m Std_.Word32)
-get_Bootstrap'questionId (Bootstrap'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Bootstrap'questionId :: ((Untyped.RWCtx m s)) => (Bootstrap (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Bootstrap'questionId (Bootstrap'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-get_Bootstrap'deprecatedObjectId :: ((Untyped.ReadCtx m msg)
-                                    ,(Classes.FromPtr msg (Std_.Maybe (Untyped.Ptr msg)))) => (Bootstrap msg) -> (m (Std_.Maybe (Untyped.Ptr msg)))
-get_Bootstrap'deprecatedObjectId (Bootstrap'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Bootstrap'deprecatedObjectId :: ((Untyped.RWCtx m s)
-                                    ,(Classes.ToPtr s (Std_.Maybe (Untyped.Ptr (Message.Mut s))))) => (Bootstrap (Message.Mut s)) -> (Std_.Maybe (Untyped.Ptr (Message.Mut s))) -> (m ())
-set_Bootstrap'deprecatedObjectId (Bootstrap'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Bootstrap'deprecatedObjectId :: ((Untyped.ReadCtx m msg)) => (Bootstrap msg) -> (m Std_.Bool)
-has_Bootstrap'deprecatedObjectId (Bootstrap'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-newtype Call msg
-    = Call'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Call msg)) where
-    fromStruct struct = (Std_.pure (Call'newtype_ struct))
-instance (Classes.ToStruct msg (Call msg)) where
-    toStruct (Call'newtype_ struct) = struct
-instance (Untyped.HasMessage (Call mut) mut) where
-    message (Call'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Call mut) mut) where
-    messageDefault msg = (Call'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Call msg)) where
-    fromPtr msg ptr = (Call'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Call (Message.Mut s))) where
-    toPtr msg (Call'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Call (Message.Mut s))) where
-    new msg = (Call'newtype_ <$> (Untyped.allocStruct msg 3 3))
-instance (Basics.ListElem mut (Call mut)) where
-    newtype List mut (Call mut)
-        = Call'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Call'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Call'List_ l) = (Untyped.ListStruct l)
-    length (Call'List_ l) = (Untyped.length l)
-    index i (Call'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Call (Message.Mut s))) where
-    setIndex (Call'newtype_ elt) i (Call'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Call'List_ <$> (Untyped.allocCompositeList msg 3 3 len))
-get_Call'questionId :: ((Untyped.ReadCtx m msg)) => (Call msg) -> (m Std_.Word32)
-get_Call'questionId (Call'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Call'questionId :: ((Untyped.RWCtx m s)) => (Call (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Call'questionId (Call'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-get_Call'target :: ((Untyped.ReadCtx m msg)
-                   ,(Classes.FromPtr msg (MessageTarget msg))) => (Call msg) -> (m (MessageTarget msg))
-get_Call'target (Call'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Call'target :: ((Untyped.RWCtx m s)
-                   ,(Classes.ToPtr s (MessageTarget (Message.Mut s)))) => (Call (Message.Mut s)) -> (MessageTarget (Message.Mut s)) -> (m ())
-set_Call'target (Call'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Call'target :: ((Untyped.ReadCtx m msg)) => (Call msg) -> (m Std_.Bool)
-has_Call'target (Call'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Call'target :: ((Untyped.RWCtx m s)) => (Call (Message.Mut s)) -> (m (MessageTarget (Message.Mut s)))
-new_Call'target struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Call'target struct result)
-    (Std_.pure result)
-    )
-get_Call'interfaceId :: ((Untyped.ReadCtx m msg)) => (Call msg) -> (m Std_.Word64)
-get_Call'interfaceId (Call'newtype_ struct) = (GenHelpers.getWordField struct 1 0 0)
-set_Call'interfaceId :: ((Untyped.RWCtx m s)) => (Call (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Call'interfaceId (Call'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-get_Call'methodId :: ((Untyped.ReadCtx m msg)) => (Call msg) -> (m Std_.Word16)
-get_Call'methodId (Call'newtype_ struct) = (GenHelpers.getWordField struct 0 32 0)
-set_Call'methodId :: ((Untyped.RWCtx m s)) => (Call (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Call'methodId (Call'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 32 0)
-get_Call'params :: ((Untyped.ReadCtx m msg)
-                   ,(Classes.FromPtr msg (Payload msg))) => (Call msg) -> (m (Payload msg))
-get_Call'params (Call'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Call'params :: ((Untyped.RWCtx m s)
-                   ,(Classes.ToPtr s (Payload (Message.Mut s)))) => (Call (Message.Mut s)) -> (Payload (Message.Mut s)) -> (m ())
-set_Call'params (Call'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Call'params :: ((Untyped.ReadCtx m msg)) => (Call msg) -> (m Std_.Bool)
-has_Call'params (Call'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_Call'params :: ((Untyped.RWCtx m s)) => (Call (Message.Mut s)) -> (m (Payload (Message.Mut s)))
-new_Call'params struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Call'params struct result)
-    (Std_.pure result)
-    )
-get_Call'sendResultsTo :: ((Untyped.ReadCtx m msg)
-                          ,(Classes.FromStruct msg (Call'sendResultsTo msg))) => (Call msg) -> (m (Call'sendResultsTo msg))
-get_Call'sendResultsTo (Call'newtype_ struct) = (Classes.fromStruct struct)
-get_Call'allowThirdPartyTailCall :: ((Untyped.ReadCtx m msg)) => (Call msg) -> (m Std_.Bool)
-get_Call'allowThirdPartyTailCall (Call'newtype_ struct) = (GenHelpers.getWordField struct 2 0 0)
-set_Call'allowThirdPartyTailCall :: ((Untyped.RWCtx m s)) => (Call (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Call'allowThirdPartyTailCall (Call'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 2 0 0)
-newtype Call'sendResultsTo msg
-    = Call'sendResultsTo'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Call'sendResultsTo msg)) where
-    fromStruct struct = (Std_.pure (Call'sendResultsTo'newtype_ struct))
-instance (Classes.ToStruct msg (Call'sendResultsTo msg)) where
-    toStruct (Call'sendResultsTo'newtype_ struct) = struct
-instance (Untyped.HasMessage (Call'sendResultsTo mut) mut) where
-    message (Call'sendResultsTo'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Call'sendResultsTo mut) mut) where
-    messageDefault msg = (Call'sendResultsTo'newtype_ <$> (Untyped.messageDefault msg))
-data Call'sendResultsTo' (mut :: Message.Mutability)
-    = Call'sendResultsTo'caller 
-    | Call'sendResultsTo'yourself 
-    | Call'sendResultsTo'thirdParty (Std_.Maybe (Untyped.Ptr mut))
-    | Call'sendResultsTo'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Call'sendResultsTo' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 3)
-        case tag of
-            0 ->
-                (Std_.pure Call'sendResultsTo'caller)
-            1 ->
-                (Std_.pure Call'sendResultsTo'yourself)
-            2 ->
-                (Call'sendResultsTo'thirdParty <$> (do
-                    ptr <- (Untyped.getPtr 2 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            _ ->
-                (Std_.pure (Call'sendResultsTo'unknown' (Std_.fromIntegral tag)))
-        )
-get_Call'sendResultsTo' :: ((Untyped.ReadCtx m msg)
-                           ,(Classes.FromStruct msg (Call'sendResultsTo' msg))) => (Call'sendResultsTo msg) -> (m (Call'sendResultsTo' msg))
-get_Call'sendResultsTo' (Call'sendResultsTo'newtype_ struct) = (Classes.fromStruct struct)
-set_Call'sendResultsTo'caller :: ((Untyped.RWCtx m s)) => (Call'sendResultsTo (Message.Mut s)) -> (m ())
-set_Call'sendResultsTo'caller (Call'sendResultsTo'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 48 0)
-    (Std_.pure ())
-    )
-set_Call'sendResultsTo'yourself :: ((Untyped.RWCtx m s)) => (Call'sendResultsTo (Message.Mut s)) -> (m ())
-set_Call'sendResultsTo'yourself (Call'sendResultsTo'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 48 0)
-    (Std_.pure ())
-    )
-set_Call'sendResultsTo'thirdParty :: ((Untyped.RWCtx m s)
-                                     ,(Classes.ToPtr s (Std_.Maybe (Untyped.Ptr (Message.Mut s))))) => (Call'sendResultsTo (Message.Mut s)) -> (Std_.Maybe (Untyped.Ptr (Message.Mut s))) -> (m ())
-set_Call'sendResultsTo'thirdParty (Call'sendResultsTo'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (2 :: Std_.Word16) 0 48 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 2 struct)
-        )
-    )
-set_Call'sendResultsTo'unknown' :: ((Untyped.RWCtx m s)) => (Call'sendResultsTo (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Call'sendResultsTo'unknown' (Call'sendResultsTo'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 48 0)
-newtype Return msg
-    = Return'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Return msg)) where
-    fromStruct struct = (Std_.pure (Return'newtype_ struct))
-instance (Classes.ToStruct msg (Return msg)) where
-    toStruct (Return'newtype_ struct) = struct
-instance (Untyped.HasMessage (Return mut) mut) where
-    message (Return'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Return mut) mut) where
-    messageDefault msg = (Return'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Return msg)) where
-    fromPtr msg ptr = (Return'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Return (Message.Mut s))) where
-    toPtr msg (Return'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Return (Message.Mut s))) where
-    new msg = (Return'newtype_ <$> (Untyped.allocStruct msg 2 1))
-instance (Basics.ListElem mut (Return mut)) where
-    newtype List mut (Return mut)
-        = Return'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Return'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Return'List_ l) = (Untyped.ListStruct l)
-    length (Return'List_ l) = (Untyped.length l)
-    index i (Return'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Return (Message.Mut s))) where
-    setIndex (Return'newtype_ elt) i (Return'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Return'List_ <$> (Untyped.allocCompositeList msg 2 1 len))
-get_Return'answerId :: ((Untyped.ReadCtx m msg)) => (Return msg) -> (m Std_.Word32)
-get_Return'answerId (Return'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Return'answerId :: ((Untyped.RWCtx m s)) => (Return (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Return'answerId (Return'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-get_Return'releaseParamCaps :: ((Untyped.ReadCtx m msg)) => (Return msg) -> (m Std_.Bool)
-get_Return'releaseParamCaps (Return'newtype_ struct) = (GenHelpers.getWordField struct 0 32 1)
-set_Return'releaseParamCaps :: ((Untyped.RWCtx m s)) => (Return (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Return'releaseParamCaps (Return'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 0 32 1)
-data Return' (mut :: Message.Mutability)
-    = Return'results (Payload mut)
-    | Return'exception (Exception mut)
-    | Return'canceled 
-    | Return'resultsSentElsewhere 
-    | Return'takeFromOtherQuestion Std_.Word32
-    | Return'acceptFromThirdParty (Std_.Maybe (Untyped.Ptr mut))
-    | Return'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Return' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 3)
-        case tag of
-            0 ->
-                (Return'results <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            1 ->
-                (Return'exception <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            2 ->
-                (Std_.pure Return'canceled)
-            3 ->
-                (Std_.pure Return'resultsSentElsewhere)
-            4 ->
-                (Return'takeFromOtherQuestion <$> (GenHelpers.getWordField struct 1 0 0))
-            5 ->
-                (Return'acceptFromThirdParty <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            _ ->
-                (Std_.pure (Return'unknown' (Std_.fromIntegral tag)))
-        )
-get_Return' :: ((Untyped.ReadCtx m msg)
-               ,(Classes.FromStruct msg (Return' msg))) => (Return msg) -> (m (Return' msg))
-get_Return' (Return'newtype_ struct) = (Classes.fromStruct struct)
-set_Return'results :: ((Untyped.RWCtx m s)
-                      ,(Classes.ToPtr s (Payload (Message.Mut s)))) => (Return (Message.Mut s)) -> (Payload (Message.Mut s)) -> (m ())
-set_Return'results (Return'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 48 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Return'exception :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Exception (Message.Mut s)))) => (Return (Message.Mut s)) -> (Exception (Message.Mut s)) -> (m ())
-set_Return'exception (Return'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 48 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Return'canceled :: ((Untyped.RWCtx m s)) => (Return (Message.Mut s)) -> (m ())
-set_Return'canceled (Return'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (2 :: Std_.Word16) 0 48 0)
-    (Std_.pure ())
-    )
-set_Return'resultsSentElsewhere :: ((Untyped.RWCtx m s)) => (Return (Message.Mut s)) -> (m ())
-set_Return'resultsSentElsewhere (Return'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (3 :: Std_.Word16) 0 48 0)
-    (Std_.pure ())
-    )
-set_Return'takeFromOtherQuestion :: ((Untyped.RWCtx m s)) => (Return (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Return'takeFromOtherQuestion (Return'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (4 :: Std_.Word16) 0 48 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 1 0 0)
-    )
-set_Return'acceptFromThirdParty :: ((Untyped.RWCtx m s)
-                                   ,(Classes.ToPtr s (Std_.Maybe (Untyped.Ptr (Message.Mut s))))) => (Return (Message.Mut s)) -> (Std_.Maybe (Untyped.Ptr (Message.Mut s))) -> (m ())
-set_Return'acceptFromThirdParty (Return'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (5 :: Std_.Word16) 0 48 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Return'unknown' :: ((Untyped.RWCtx m s)) => (Return (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Return'unknown' (Return'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 48 0)
-newtype Finish msg
-    = Finish'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Finish msg)) where
-    fromStruct struct = (Std_.pure (Finish'newtype_ struct))
-instance (Classes.ToStruct msg (Finish msg)) where
-    toStruct (Finish'newtype_ struct) = struct
-instance (Untyped.HasMessage (Finish mut) mut) where
-    message (Finish'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Finish mut) mut) where
-    messageDefault msg = (Finish'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Finish msg)) where
-    fromPtr msg ptr = (Finish'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Finish (Message.Mut s))) where
-    toPtr msg (Finish'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Finish (Message.Mut s))) where
-    new msg = (Finish'newtype_ <$> (Untyped.allocStruct msg 1 0))
-instance (Basics.ListElem mut (Finish mut)) where
-    newtype List mut (Finish mut)
-        = Finish'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Finish'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Finish'List_ l) = (Untyped.ListStruct l)
-    length (Finish'List_ l) = (Untyped.length l)
-    index i (Finish'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Finish (Message.Mut s))) where
-    setIndex (Finish'newtype_ elt) i (Finish'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Finish'List_ <$> (Untyped.allocCompositeList msg 1 0 len))
-get_Finish'questionId :: ((Untyped.ReadCtx m msg)) => (Finish msg) -> (m Std_.Word32)
-get_Finish'questionId (Finish'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Finish'questionId :: ((Untyped.RWCtx m s)) => (Finish (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Finish'questionId (Finish'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-get_Finish'releaseResultCaps :: ((Untyped.ReadCtx m msg)) => (Finish msg) -> (m Std_.Bool)
-get_Finish'releaseResultCaps (Finish'newtype_ struct) = (GenHelpers.getWordField struct 0 32 1)
-set_Finish'releaseResultCaps :: ((Untyped.RWCtx m s)) => (Finish (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Finish'releaseResultCaps (Finish'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 0 32 1)
-newtype Resolve msg
-    = Resolve'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Resolve msg)) where
-    fromStruct struct = (Std_.pure (Resolve'newtype_ struct))
-instance (Classes.ToStruct msg (Resolve msg)) where
-    toStruct (Resolve'newtype_ struct) = struct
-instance (Untyped.HasMessage (Resolve mut) mut) where
-    message (Resolve'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Resolve mut) mut) where
-    messageDefault msg = (Resolve'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Resolve msg)) where
-    fromPtr msg ptr = (Resolve'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Resolve (Message.Mut s))) where
-    toPtr msg (Resolve'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Resolve (Message.Mut s))) where
-    new msg = (Resolve'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (Resolve mut)) where
-    newtype List mut (Resolve mut)
-        = Resolve'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Resolve'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Resolve'List_ l) = (Untyped.ListStruct l)
-    length (Resolve'List_ l) = (Untyped.length l)
-    index i (Resolve'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Resolve (Message.Mut s))) where
-    setIndex (Resolve'newtype_ elt) i (Resolve'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Resolve'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-get_Resolve'promiseId :: ((Untyped.ReadCtx m msg)) => (Resolve msg) -> (m Std_.Word32)
-get_Resolve'promiseId (Resolve'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Resolve'promiseId :: ((Untyped.RWCtx m s)) => (Resolve (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Resolve'promiseId (Resolve'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-data Resolve' (mut :: Message.Mutability)
-    = Resolve'cap (CapDescriptor mut)
-    | Resolve'exception (Exception mut)
-    | Resolve'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Resolve' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 2)
-        case tag of
-            0 ->
-                (Resolve'cap <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            1 ->
-                (Resolve'exception <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            _ ->
-                (Std_.pure (Resolve'unknown' (Std_.fromIntegral tag)))
-        )
-get_Resolve' :: ((Untyped.ReadCtx m msg)
-                ,(Classes.FromStruct msg (Resolve' msg))) => (Resolve msg) -> (m (Resolve' msg))
-get_Resolve' (Resolve'newtype_ struct) = (Classes.fromStruct struct)
-set_Resolve'cap :: ((Untyped.RWCtx m s)
-                   ,(Classes.ToPtr s (CapDescriptor (Message.Mut s)))) => (Resolve (Message.Mut s)) -> (CapDescriptor (Message.Mut s)) -> (m ())
-set_Resolve'cap (Resolve'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 32 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Resolve'exception :: ((Untyped.RWCtx m s)
-                         ,(Classes.ToPtr s (Exception (Message.Mut s)))) => (Resolve (Message.Mut s)) -> (Exception (Message.Mut s)) -> (m ())
-set_Resolve'exception (Resolve'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 32 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Resolve'unknown' :: ((Untyped.RWCtx m s)) => (Resolve (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Resolve'unknown' (Resolve'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 32 0)
-newtype Release msg
-    = Release'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Release msg)) where
-    fromStruct struct = (Std_.pure (Release'newtype_ struct))
-instance (Classes.ToStruct msg (Release msg)) where
-    toStruct (Release'newtype_ struct) = struct
-instance (Untyped.HasMessage (Release mut) mut) where
-    message (Release'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Release mut) mut) where
-    messageDefault msg = (Release'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Release msg)) where
-    fromPtr msg ptr = (Release'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Release (Message.Mut s))) where
-    toPtr msg (Release'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Release (Message.Mut s))) where
-    new msg = (Release'newtype_ <$> (Untyped.allocStruct msg 1 0))
-instance (Basics.ListElem mut (Release mut)) where
-    newtype List mut (Release mut)
-        = Release'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Release'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Release'List_ l) = (Untyped.ListStruct l)
-    length (Release'List_ l) = (Untyped.length l)
-    index i (Release'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Release (Message.Mut s))) where
-    setIndex (Release'newtype_ elt) i (Release'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Release'List_ <$> (Untyped.allocCompositeList msg 1 0 len))
-get_Release'id :: ((Untyped.ReadCtx m msg)) => (Release msg) -> (m Std_.Word32)
-get_Release'id (Release'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Release'id :: ((Untyped.RWCtx m s)) => (Release (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Release'id (Release'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-get_Release'referenceCount :: ((Untyped.ReadCtx m msg)) => (Release msg) -> (m Std_.Word32)
-get_Release'referenceCount (Release'newtype_ struct) = (GenHelpers.getWordField struct 0 32 0)
-set_Release'referenceCount :: ((Untyped.RWCtx m s)) => (Release (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Release'referenceCount (Release'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 32 0)
-newtype Disembargo msg
-    = Disembargo'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Disembargo msg)) where
-    fromStruct struct = (Std_.pure (Disembargo'newtype_ struct))
-instance (Classes.ToStruct msg (Disembargo msg)) where
-    toStruct (Disembargo'newtype_ struct) = struct
-instance (Untyped.HasMessage (Disembargo mut) mut) where
-    message (Disembargo'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Disembargo mut) mut) where
-    messageDefault msg = (Disembargo'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Disembargo msg)) where
-    fromPtr msg ptr = (Disembargo'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Disembargo (Message.Mut s))) where
-    toPtr msg (Disembargo'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Disembargo (Message.Mut s))) where
-    new msg = (Disembargo'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (Disembargo mut)) where
-    newtype List mut (Disembargo mut)
-        = Disembargo'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Disembargo'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Disembargo'List_ l) = (Untyped.ListStruct l)
-    length (Disembargo'List_ l) = (Untyped.length l)
-    index i (Disembargo'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Disembargo (Message.Mut s))) where
-    setIndex (Disembargo'newtype_ elt) i (Disembargo'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Disembargo'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-get_Disembargo'target :: ((Untyped.ReadCtx m msg)
-                         ,(Classes.FromPtr msg (MessageTarget msg))) => (Disembargo msg) -> (m (MessageTarget msg))
-get_Disembargo'target (Disembargo'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Disembargo'target :: ((Untyped.RWCtx m s)
-                         ,(Classes.ToPtr s (MessageTarget (Message.Mut s)))) => (Disembargo (Message.Mut s)) -> (MessageTarget (Message.Mut s)) -> (m ())
-set_Disembargo'target (Disembargo'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Disembargo'target :: ((Untyped.ReadCtx m msg)) => (Disembargo msg) -> (m Std_.Bool)
-has_Disembargo'target (Disembargo'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Disembargo'target :: ((Untyped.RWCtx m s)) => (Disembargo (Message.Mut s)) -> (m (MessageTarget (Message.Mut s)))
-new_Disembargo'target struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Disembargo'target struct result)
-    (Std_.pure result)
-    )
-get_Disembargo'context :: ((Untyped.ReadCtx m msg)
-                          ,(Classes.FromStruct msg (Disembargo'context msg))) => (Disembargo msg) -> (m (Disembargo'context msg))
-get_Disembargo'context (Disembargo'newtype_ struct) = (Classes.fromStruct struct)
-newtype Disembargo'context msg
-    = Disembargo'context'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Disembargo'context msg)) where
-    fromStruct struct = (Std_.pure (Disembargo'context'newtype_ struct))
-instance (Classes.ToStruct msg (Disembargo'context msg)) where
-    toStruct (Disembargo'context'newtype_ struct) = struct
-instance (Untyped.HasMessage (Disembargo'context mut) mut) where
-    message (Disembargo'context'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Disembargo'context mut) mut) where
-    messageDefault msg = (Disembargo'context'newtype_ <$> (Untyped.messageDefault msg))
-data Disembargo'context' (mut :: Message.Mutability)
-    = Disembargo'context'senderLoopback Std_.Word32
-    | Disembargo'context'receiverLoopback Std_.Word32
-    | Disembargo'context'accept 
-    | Disembargo'context'provide Std_.Word32
-    | Disembargo'context'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Disembargo'context' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 2)
-        case tag of
-            0 ->
-                (Disembargo'context'senderLoopback <$> (GenHelpers.getWordField struct 0 0 0))
-            1 ->
-                (Disembargo'context'receiverLoopback <$> (GenHelpers.getWordField struct 0 0 0))
-            2 ->
-                (Std_.pure Disembargo'context'accept)
-            3 ->
-                (Disembargo'context'provide <$> (GenHelpers.getWordField struct 0 0 0))
-            _ ->
-                (Std_.pure (Disembargo'context'unknown' (Std_.fromIntegral tag)))
-        )
-get_Disembargo'context' :: ((Untyped.ReadCtx m msg)
-                           ,(Classes.FromStruct msg (Disembargo'context' msg))) => (Disembargo'context msg) -> (m (Disembargo'context' msg))
-get_Disembargo'context' (Disembargo'context'newtype_ struct) = (Classes.fromStruct struct)
-set_Disembargo'context'senderLoopback :: ((Untyped.RWCtx m s)) => (Disembargo'context (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Disembargo'context'senderLoopback (Disembargo'context'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 32 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-    )
-set_Disembargo'context'receiverLoopback :: ((Untyped.RWCtx m s)) => (Disembargo'context (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Disembargo'context'receiverLoopback (Disembargo'context'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 32 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-    )
-set_Disembargo'context'accept :: ((Untyped.RWCtx m s)) => (Disembargo'context (Message.Mut s)) -> (m ())
-set_Disembargo'context'accept (Disembargo'context'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (2 :: Std_.Word16) 0 32 0)
-    (Std_.pure ())
-    )
-set_Disembargo'context'provide :: ((Untyped.RWCtx m s)) => (Disembargo'context (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Disembargo'context'provide (Disembargo'context'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (3 :: Std_.Word16) 0 32 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-    )
-set_Disembargo'context'unknown' :: ((Untyped.RWCtx m s)) => (Disembargo'context (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Disembargo'context'unknown' (Disembargo'context'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 32 0)
-newtype Provide msg
-    = Provide'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Provide msg)) where
-    fromStruct struct = (Std_.pure (Provide'newtype_ struct))
-instance (Classes.ToStruct msg (Provide msg)) where
-    toStruct (Provide'newtype_ struct) = struct
-instance (Untyped.HasMessage (Provide mut) mut) where
-    message (Provide'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Provide mut) mut) where
-    messageDefault msg = (Provide'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Provide msg)) where
-    fromPtr msg ptr = (Provide'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Provide (Message.Mut s))) where
-    toPtr msg (Provide'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Provide (Message.Mut s))) where
-    new msg = (Provide'newtype_ <$> (Untyped.allocStruct msg 1 2))
-instance (Basics.ListElem mut (Provide mut)) where
-    newtype List mut (Provide mut)
-        = Provide'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Provide'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Provide'List_ l) = (Untyped.ListStruct l)
-    length (Provide'List_ l) = (Untyped.length l)
-    index i (Provide'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Provide (Message.Mut s))) where
-    setIndex (Provide'newtype_ elt) i (Provide'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Provide'List_ <$> (Untyped.allocCompositeList msg 1 2 len))
-get_Provide'questionId :: ((Untyped.ReadCtx m msg)) => (Provide msg) -> (m Std_.Word32)
-get_Provide'questionId (Provide'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Provide'questionId :: ((Untyped.RWCtx m s)) => (Provide (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Provide'questionId (Provide'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-get_Provide'target :: ((Untyped.ReadCtx m msg)
-                      ,(Classes.FromPtr msg (MessageTarget msg))) => (Provide msg) -> (m (MessageTarget msg))
-get_Provide'target (Provide'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Provide'target :: ((Untyped.RWCtx m s)
-                      ,(Classes.ToPtr s (MessageTarget (Message.Mut s)))) => (Provide (Message.Mut s)) -> (MessageTarget (Message.Mut s)) -> (m ())
-set_Provide'target (Provide'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Provide'target :: ((Untyped.ReadCtx m msg)) => (Provide msg) -> (m Std_.Bool)
-has_Provide'target (Provide'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Provide'target :: ((Untyped.RWCtx m s)) => (Provide (Message.Mut s)) -> (m (MessageTarget (Message.Mut s)))
-new_Provide'target struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Provide'target struct result)
-    (Std_.pure result)
-    )
-get_Provide'recipient :: ((Untyped.ReadCtx m msg)
-                         ,(Classes.FromPtr msg (Std_.Maybe (Untyped.Ptr msg)))) => (Provide msg) -> (m (Std_.Maybe (Untyped.Ptr msg)))
-get_Provide'recipient (Provide'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Provide'recipient :: ((Untyped.RWCtx m s)
-                         ,(Classes.ToPtr s (Std_.Maybe (Untyped.Ptr (Message.Mut s))))) => (Provide (Message.Mut s)) -> (Std_.Maybe (Untyped.Ptr (Message.Mut s))) -> (m ())
-set_Provide'recipient (Provide'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Provide'recipient :: ((Untyped.ReadCtx m msg)) => (Provide msg) -> (m Std_.Bool)
-has_Provide'recipient (Provide'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-newtype Accept msg
-    = Accept'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Accept msg)) where
-    fromStruct struct = (Std_.pure (Accept'newtype_ struct))
-instance (Classes.ToStruct msg (Accept msg)) where
-    toStruct (Accept'newtype_ struct) = struct
-instance (Untyped.HasMessage (Accept mut) mut) where
-    message (Accept'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Accept mut) mut) where
-    messageDefault msg = (Accept'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Accept msg)) where
-    fromPtr msg ptr = (Accept'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Accept (Message.Mut s))) where
-    toPtr msg (Accept'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Accept (Message.Mut s))) where
-    new msg = (Accept'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (Accept mut)) where
-    newtype List mut (Accept mut)
-        = Accept'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Accept'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Accept'List_ l) = (Untyped.ListStruct l)
-    length (Accept'List_ l) = (Untyped.length l)
-    index i (Accept'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Accept (Message.Mut s))) where
-    setIndex (Accept'newtype_ elt) i (Accept'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Accept'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-get_Accept'questionId :: ((Untyped.ReadCtx m msg)) => (Accept msg) -> (m Std_.Word32)
-get_Accept'questionId (Accept'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Accept'questionId :: ((Untyped.RWCtx m s)) => (Accept (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Accept'questionId (Accept'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-get_Accept'provision :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Std_.Maybe (Untyped.Ptr msg)))) => (Accept msg) -> (m (Std_.Maybe (Untyped.Ptr msg)))
-get_Accept'provision (Accept'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Accept'provision :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Std_.Maybe (Untyped.Ptr (Message.Mut s))))) => (Accept (Message.Mut s)) -> (Std_.Maybe (Untyped.Ptr (Message.Mut s))) -> (m ())
-set_Accept'provision (Accept'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Accept'provision :: ((Untyped.ReadCtx m msg)) => (Accept msg) -> (m Std_.Bool)
-has_Accept'provision (Accept'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-get_Accept'embargo :: ((Untyped.ReadCtx m msg)) => (Accept msg) -> (m Std_.Bool)
-get_Accept'embargo (Accept'newtype_ struct) = (GenHelpers.getWordField struct 0 32 0)
-set_Accept'embargo :: ((Untyped.RWCtx m s)) => (Accept (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Accept'embargo (Accept'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 0 32 0)
-newtype Join msg
-    = Join'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Join msg)) where
-    fromStruct struct = (Std_.pure (Join'newtype_ struct))
-instance (Classes.ToStruct msg (Join msg)) where
-    toStruct (Join'newtype_ struct) = struct
-instance (Untyped.HasMessage (Join mut) mut) where
-    message (Join'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Join mut) mut) where
-    messageDefault msg = (Join'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Join msg)) where
-    fromPtr msg ptr = (Join'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Join (Message.Mut s))) where
-    toPtr msg (Join'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Join (Message.Mut s))) where
-    new msg = (Join'newtype_ <$> (Untyped.allocStruct msg 1 2))
-instance (Basics.ListElem mut (Join mut)) where
-    newtype List mut (Join mut)
-        = Join'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Join'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Join'List_ l) = (Untyped.ListStruct l)
-    length (Join'List_ l) = (Untyped.length l)
-    index i (Join'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Join (Message.Mut s))) where
-    setIndex (Join'newtype_ elt) i (Join'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Join'List_ <$> (Untyped.allocCompositeList msg 1 2 len))
-get_Join'questionId :: ((Untyped.ReadCtx m msg)) => (Join msg) -> (m Std_.Word32)
-get_Join'questionId (Join'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Join'questionId :: ((Untyped.RWCtx m s)) => (Join (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Join'questionId (Join'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-get_Join'target :: ((Untyped.ReadCtx m msg)
-                   ,(Classes.FromPtr msg (MessageTarget msg))) => (Join msg) -> (m (MessageTarget msg))
-get_Join'target (Join'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Join'target :: ((Untyped.RWCtx m s)
-                   ,(Classes.ToPtr s (MessageTarget (Message.Mut s)))) => (Join (Message.Mut s)) -> (MessageTarget (Message.Mut s)) -> (m ())
-set_Join'target (Join'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Join'target :: ((Untyped.ReadCtx m msg)) => (Join msg) -> (m Std_.Bool)
-has_Join'target (Join'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Join'target :: ((Untyped.RWCtx m s)) => (Join (Message.Mut s)) -> (m (MessageTarget (Message.Mut s)))
-new_Join'target struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Join'target struct result)
-    (Std_.pure result)
-    )
-get_Join'keyPart :: ((Untyped.ReadCtx m msg)
-                    ,(Classes.FromPtr msg (Std_.Maybe (Untyped.Ptr msg)))) => (Join msg) -> (m (Std_.Maybe (Untyped.Ptr msg)))
-get_Join'keyPart (Join'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Join'keyPart :: ((Untyped.RWCtx m s)
-                    ,(Classes.ToPtr s (Std_.Maybe (Untyped.Ptr (Message.Mut s))))) => (Join (Message.Mut s)) -> (Std_.Maybe (Untyped.Ptr (Message.Mut s))) -> (m ())
-set_Join'keyPart (Join'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Join'keyPart :: ((Untyped.ReadCtx m msg)) => (Join msg) -> (m Std_.Bool)
-has_Join'keyPart (Join'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-newtype MessageTarget msg
-    = MessageTarget'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (MessageTarget msg)) where
-    fromStruct struct = (Std_.pure (MessageTarget'newtype_ struct))
-instance (Classes.ToStruct msg (MessageTarget msg)) where
-    toStruct (MessageTarget'newtype_ struct) = struct
-instance (Untyped.HasMessage (MessageTarget mut) mut) where
-    message (MessageTarget'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (MessageTarget mut) mut) where
-    messageDefault msg = (MessageTarget'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (MessageTarget msg)) where
-    fromPtr msg ptr = (MessageTarget'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (MessageTarget (Message.Mut s))) where
-    toPtr msg (MessageTarget'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (MessageTarget (Message.Mut s))) where
-    new msg = (MessageTarget'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (MessageTarget mut)) where
-    newtype List mut (MessageTarget mut)
-        = MessageTarget'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (MessageTarget'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (MessageTarget'List_ l) = (Untyped.ListStruct l)
-    length (MessageTarget'List_ l) = (Untyped.length l)
-    index i (MessageTarget'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (MessageTarget (Message.Mut s))) where
-    setIndex (MessageTarget'newtype_ elt) i (MessageTarget'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (MessageTarget'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-data MessageTarget' (mut :: Message.Mutability)
-    = MessageTarget'importedCap Std_.Word32
-    | MessageTarget'promisedAnswer (PromisedAnswer mut)
-    | MessageTarget'unknown' Std_.Word16
-instance (Classes.FromStruct mut (MessageTarget' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 2)
-        case tag of
-            0 ->
-                (MessageTarget'importedCap <$> (GenHelpers.getWordField struct 0 0 0))
-            1 ->
-                (MessageTarget'promisedAnswer <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            _ ->
-                (Std_.pure (MessageTarget'unknown' (Std_.fromIntegral tag)))
-        )
-get_MessageTarget' :: ((Untyped.ReadCtx m msg)
-                      ,(Classes.FromStruct msg (MessageTarget' msg))) => (MessageTarget msg) -> (m (MessageTarget' msg))
-get_MessageTarget' (MessageTarget'newtype_ struct) = (Classes.fromStruct struct)
-set_MessageTarget'importedCap :: ((Untyped.RWCtx m s)) => (MessageTarget (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_MessageTarget'importedCap (MessageTarget'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 32 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-    )
-set_MessageTarget'promisedAnswer :: ((Untyped.RWCtx m s)
-                                    ,(Classes.ToPtr s (PromisedAnswer (Message.Mut s)))) => (MessageTarget (Message.Mut s)) -> (PromisedAnswer (Message.Mut s)) -> (m ())
-set_MessageTarget'promisedAnswer (MessageTarget'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 32 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_MessageTarget'unknown' :: ((Untyped.RWCtx m s)) => (MessageTarget (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_MessageTarget'unknown' (MessageTarget'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 32 0)
-newtype Payload msg
-    = Payload'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Payload msg)) where
-    fromStruct struct = (Std_.pure (Payload'newtype_ struct))
-instance (Classes.ToStruct msg (Payload msg)) where
-    toStruct (Payload'newtype_ struct) = struct
-instance (Untyped.HasMessage (Payload mut) mut) where
-    message (Payload'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Payload mut) mut) where
-    messageDefault msg = (Payload'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Payload msg)) where
-    fromPtr msg ptr = (Payload'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Payload (Message.Mut s))) where
-    toPtr msg (Payload'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Payload (Message.Mut s))) where
-    new msg = (Payload'newtype_ <$> (Untyped.allocStruct msg 0 2))
-instance (Basics.ListElem mut (Payload mut)) where
-    newtype List mut (Payload mut)
-        = Payload'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Payload'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Payload'List_ l) = (Untyped.ListStruct l)
-    length (Payload'List_ l) = (Untyped.length l)
-    index i (Payload'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Payload (Message.Mut s))) where
-    setIndex (Payload'newtype_ elt) i (Payload'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Payload'List_ <$> (Untyped.allocCompositeList msg 0 2 len))
-get_Payload'content :: ((Untyped.ReadCtx m msg)
-                       ,(Classes.FromPtr msg (Std_.Maybe (Untyped.Ptr msg)))) => (Payload msg) -> (m (Std_.Maybe (Untyped.Ptr msg)))
-get_Payload'content (Payload'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Payload'content :: ((Untyped.RWCtx m s)
-                       ,(Classes.ToPtr s (Std_.Maybe (Untyped.Ptr (Message.Mut s))))) => (Payload (Message.Mut s)) -> (Std_.Maybe (Untyped.Ptr (Message.Mut s))) -> (m ())
-set_Payload'content (Payload'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Payload'content :: ((Untyped.ReadCtx m msg)) => (Payload msg) -> (m Std_.Bool)
-has_Payload'content (Payload'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-get_Payload'capTable :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Basics.List msg (CapDescriptor msg)))) => (Payload msg) -> (m (Basics.List msg (CapDescriptor msg)))
-get_Payload'capTable (Payload'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Payload'capTable :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Basics.List (Message.Mut s) (CapDescriptor (Message.Mut s))))) => (Payload (Message.Mut s)) -> (Basics.List (Message.Mut s) (CapDescriptor (Message.Mut s))) -> (m ())
-set_Payload'capTable (Payload'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Payload'capTable :: ((Untyped.ReadCtx m msg)) => (Payload msg) -> (m Std_.Bool)
-has_Payload'capTable (Payload'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_Payload'capTable :: ((Untyped.RWCtx m s)) => Std_.Int -> (Payload (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (CapDescriptor (Message.Mut s))))
-new_Payload'capTable len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Payload'capTable struct result)
-    (Std_.pure result)
-    )
-newtype CapDescriptor msg
-    = CapDescriptor'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (CapDescriptor msg)) where
-    fromStruct struct = (Std_.pure (CapDescriptor'newtype_ struct))
-instance (Classes.ToStruct msg (CapDescriptor msg)) where
-    toStruct (CapDescriptor'newtype_ struct) = struct
-instance (Untyped.HasMessage (CapDescriptor mut) mut) where
-    message (CapDescriptor'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (CapDescriptor mut) mut) where
-    messageDefault msg = (CapDescriptor'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (CapDescriptor msg)) where
-    fromPtr msg ptr = (CapDescriptor'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (CapDescriptor (Message.Mut s))) where
-    toPtr msg (CapDescriptor'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (CapDescriptor (Message.Mut s))) where
-    new msg = (CapDescriptor'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (CapDescriptor mut)) where
-    newtype List mut (CapDescriptor mut)
-        = CapDescriptor'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (CapDescriptor'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (CapDescriptor'List_ l) = (Untyped.ListStruct l)
-    length (CapDescriptor'List_ l) = (Untyped.length l)
-    index i (CapDescriptor'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (CapDescriptor (Message.Mut s))) where
-    setIndex (CapDescriptor'newtype_ elt) i (CapDescriptor'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (CapDescriptor'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-get_CapDescriptor'attachedFd :: ((Untyped.ReadCtx m msg)) => (CapDescriptor msg) -> (m Std_.Word8)
-get_CapDescriptor'attachedFd (CapDescriptor'newtype_ struct) = (GenHelpers.getWordField struct 0 16 255)
-set_CapDescriptor'attachedFd :: ((Untyped.RWCtx m s)) => (CapDescriptor (Message.Mut s)) -> Std_.Word8 -> (m ())
-set_CapDescriptor'attachedFd (CapDescriptor'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word8) 0 16 255)
-data CapDescriptor' (mut :: Message.Mutability)
-    = CapDescriptor'none 
-    | CapDescriptor'senderHosted Std_.Word32
-    | CapDescriptor'senderPromise Std_.Word32
-    | CapDescriptor'receiverHosted Std_.Word32
-    | CapDescriptor'receiverAnswer (PromisedAnswer mut)
-    | CapDescriptor'thirdPartyHosted (ThirdPartyCapDescriptor mut)
-    | CapDescriptor'unknown' Std_.Word16
-instance (Classes.FromStruct mut (CapDescriptor' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 0)
-        case tag of
-            0 ->
-                (Std_.pure CapDescriptor'none)
-            1 ->
-                (CapDescriptor'senderHosted <$> (GenHelpers.getWordField struct 0 32 0))
-            2 ->
-                (CapDescriptor'senderPromise <$> (GenHelpers.getWordField struct 0 32 0))
-            3 ->
-                (CapDescriptor'receiverHosted <$> (GenHelpers.getWordField struct 0 32 0))
-            4 ->
-                (CapDescriptor'receiverAnswer <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            5 ->
-                (CapDescriptor'thirdPartyHosted <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            _ ->
-                (Std_.pure (CapDescriptor'unknown' (Std_.fromIntegral tag)))
-        )
-get_CapDescriptor' :: ((Untyped.ReadCtx m msg)
-                      ,(Classes.FromStruct msg (CapDescriptor' msg))) => (CapDescriptor msg) -> (m (CapDescriptor' msg))
-get_CapDescriptor' (CapDescriptor'newtype_ struct) = (Classes.fromStruct struct)
-set_CapDescriptor'none :: ((Untyped.RWCtx m s)) => (CapDescriptor (Message.Mut s)) -> (m ())
-set_CapDescriptor'none (CapDescriptor'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_CapDescriptor'senderHosted :: ((Untyped.RWCtx m s)) => (CapDescriptor (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_CapDescriptor'senderHosted (CapDescriptor'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 32 0)
-    )
-set_CapDescriptor'senderPromise :: ((Untyped.RWCtx m s)) => (CapDescriptor (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_CapDescriptor'senderPromise (CapDescriptor'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (2 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 32 0)
-    )
-set_CapDescriptor'receiverHosted :: ((Untyped.RWCtx m s)) => (CapDescriptor (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_CapDescriptor'receiverHosted (CapDescriptor'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (3 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 32 0)
-    )
-set_CapDescriptor'receiverAnswer :: ((Untyped.RWCtx m s)
-                                    ,(Classes.ToPtr s (PromisedAnswer (Message.Mut s)))) => (CapDescriptor (Message.Mut s)) -> (PromisedAnswer (Message.Mut s)) -> (m ())
-set_CapDescriptor'receiverAnswer (CapDescriptor'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (4 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_CapDescriptor'thirdPartyHosted :: ((Untyped.RWCtx m s)
-                                      ,(Classes.ToPtr s (ThirdPartyCapDescriptor (Message.Mut s)))) => (CapDescriptor (Message.Mut s)) -> (ThirdPartyCapDescriptor (Message.Mut s)) -> (m ())
-set_CapDescriptor'thirdPartyHosted (CapDescriptor'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (5 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_CapDescriptor'unknown' :: ((Untyped.RWCtx m s)) => (CapDescriptor (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_CapDescriptor'unknown' (CapDescriptor'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-newtype PromisedAnswer msg
-    = PromisedAnswer'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (PromisedAnswer msg)) where
-    fromStruct struct = (Std_.pure (PromisedAnswer'newtype_ struct))
-instance (Classes.ToStruct msg (PromisedAnswer msg)) where
-    toStruct (PromisedAnswer'newtype_ struct) = struct
-instance (Untyped.HasMessage (PromisedAnswer mut) mut) where
-    message (PromisedAnswer'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (PromisedAnswer mut) mut) where
-    messageDefault msg = (PromisedAnswer'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (PromisedAnswer msg)) where
-    fromPtr msg ptr = (PromisedAnswer'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (PromisedAnswer (Message.Mut s))) where
-    toPtr msg (PromisedAnswer'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (PromisedAnswer (Message.Mut s))) where
-    new msg = (PromisedAnswer'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (PromisedAnswer mut)) where
-    newtype List mut (PromisedAnswer mut)
-        = PromisedAnswer'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (PromisedAnswer'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (PromisedAnswer'List_ l) = (Untyped.ListStruct l)
-    length (PromisedAnswer'List_ l) = (Untyped.length l)
-    index i (PromisedAnswer'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (PromisedAnswer (Message.Mut s))) where
-    setIndex (PromisedAnswer'newtype_ elt) i (PromisedAnswer'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (PromisedAnswer'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-get_PromisedAnswer'questionId :: ((Untyped.ReadCtx m msg)) => (PromisedAnswer msg) -> (m Std_.Word32)
-get_PromisedAnswer'questionId (PromisedAnswer'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_PromisedAnswer'questionId :: ((Untyped.RWCtx m s)) => (PromisedAnswer (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_PromisedAnswer'questionId (PromisedAnswer'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-get_PromisedAnswer'transform :: ((Untyped.ReadCtx m msg)
-                                ,(Classes.FromPtr msg (Basics.List msg (PromisedAnswer'Op msg)))) => (PromisedAnswer msg) -> (m (Basics.List msg (PromisedAnswer'Op msg)))
-get_PromisedAnswer'transform (PromisedAnswer'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_PromisedAnswer'transform :: ((Untyped.RWCtx m s)
-                                ,(Classes.ToPtr s (Basics.List (Message.Mut s) (PromisedAnswer'Op (Message.Mut s))))) => (PromisedAnswer (Message.Mut s)) -> (Basics.List (Message.Mut s) (PromisedAnswer'Op (Message.Mut s))) -> (m ())
-set_PromisedAnswer'transform (PromisedAnswer'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_PromisedAnswer'transform :: ((Untyped.ReadCtx m msg)) => (PromisedAnswer msg) -> (m Std_.Bool)
-has_PromisedAnswer'transform (PromisedAnswer'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_PromisedAnswer'transform :: ((Untyped.RWCtx m s)) => Std_.Int -> (PromisedAnswer (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (PromisedAnswer'Op (Message.Mut s))))
-new_PromisedAnswer'transform len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_PromisedAnswer'transform struct result)
-    (Std_.pure result)
-    )
-newtype PromisedAnswer'Op msg
-    = PromisedAnswer'Op'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (PromisedAnswer'Op msg)) where
-    fromStruct struct = (Std_.pure (PromisedAnswer'Op'newtype_ struct))
-instance (Classes.ToStruct msg (PromisedAnswer'Op msg)) where
-    toStruct (PromisedAnswer'Op'newtype_ struct) = struct
-instance (Untyped.HasMessage (PromisedAnswer'Op mut) mut) where
-    message (PromisedAnswer'Op'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (PromisedAnswer'Op mut) mut) where
-    messageDefault msg = (PromisedAnswer'Op'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (PromisedAnswer'Op msg)) where
-    fromPtr msg ptr = (PromisedAnswer'Op'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (PromisedAnswer'Op (Message.Mut s))) where
-    toPtr msg (PromisedAnswer'Op'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (PromisedAnswer'Op (Message.Mut s))) where
-    new msg = (PromisedAnswer'Op'newtype_ <$> (Untyped.allocStruct msg 1 0))
-instance (Basics.ListElem mut (PromisedAnswer'Op mut)) where
-    newtype List mut (PromisedAnswer'Op mut)
-        = PromisedAnswer'Op'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (PromisedAnswer'Op'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (PromisedAnswer'Op'List_ l) = (Untyped.ListStruct l)
-    length (PromisedAnswer'Op'List_ l) = (Untyped.length l)
-    index i (PromisedAnswer'Op'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (PromisedAnswer'Op (Message.Mut s))) where
-    setIndex (PromisedAnswer'Op'newtype_ elt) i (PromisedAnswer'Op'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (PromisedAnswer'Op'List_ <$> (Untyped.allocCompositeList msg 1 0 len))
-data PromisedAnswer'Op' (mut :: Message.Mutability)
-    = PromisedAnswer'Op'noop 
-    | PromisedAnswer'Op'getPointerField Std_.Word16
-    | PromisedAnswer'Op'unknown' Std_.Word16
-instance (Classes.FromStruct mut (PromisedAnswer'Op' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 0)
-        case tag of
-            0 ->
-                (Std_.pure PromisedAnswer'Op'noop)
-            1 ->
-                (PromisedAnswer'Op'getPointerField <$> (GenHelpers.getWordField struct 0 16 0))
-            _ ->
-                (Std_.pure (PromisedAnswer'Op'unknown' (Std_.fromIntegral tag)))
-        )
-get_PromisedAnswer'Op' :: ((Untyped.ReadCtx m msg)
-                          ,(Classes.FromStruct msg (PromisedAnswer'Op' msg))) => (PromisedAnswer'Op msg) -> (m (PromisedAnswer'Op' msg))
-get_PromisedAnswer'Op' (PromisedAnswer'Op'newtype_ struct) = (Classes.fromStruct struct)
-set_PromisedAnswer'Op'noop :: ((Untyped.RWCtx m s)) => (PromisedAnswer'Op (Message.Mut s)) -> (m ())
-set_PromisedAnswer'Op'noop (PromisedAnswer'Op'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_PromisedAnswer'Op'getPointerField :: ((Untyped.RWCtx m s)) => (PromisedAnswer'Op (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_PromisedAnswer'Op'getPointerField (PromisedAnswer'Op'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 16 0)
-    )
-set_PromisedAnswer'Op'unknown' :: ((Untyped.RWCtx m s)) => (PromisedAnswer'Op (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_PromisedAnswer'Op'unknown' (PromisedAnswer'Op'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-newtype ThirdPartyCapDescriptor msg
-    = ThirdPartyCapDescriptor'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (ThirdPartyCapDescriptor msg)) where
-    fromStruct struct = (Std_.pure (ThirdPartyCapDescriptor'newtype_ struct))
-instance (Classes.ToStruct msg (ThirdPartyCapDescriptor msg)) where
-    toStruct (ThirdPartyCapDescriptor'newtype_ struct) = struct
-instance (Untyped.HasMessage (ThirdPartyCapDescriptor mut) mut) where
-    message (ThirdPartyCapDescriptor'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (ThirdPartyCapDescriptor mut) mut) where
-    messageDefault msg = (ThirdPartyCapDescriptor'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (ThirdPartyCapDescriptor msg)) where
-    fromPtr msg ptr = (ThirdPartyCapDescriptor'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (ThirdPartyCapDescriptor (Message.Mut s))) where
-    toPtr msg (ThirdPartyCapDescriptor'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (ThirdPartyCapDescriptor (Message.Mut s))) where
-    new msg = (ThirdPartyCapDescriptor'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (ThirdPartyCapDescriptor mut)) where
-    newtype List mut (ThirdPartyCapDescriptor mut)
-        = ThirdPartyCapDescriptor'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (ThirdPartyCapDescriptor'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (ThirdPartyCapDescriptor'List_ l) = (Untyped.ListStruct l)
-    length (ThirdPartyCapDescriptor'List_ l) = (Untyped.length l)
-    index i (ThirdPartyCapDescriptor'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (ThirdPartyCapDescriptor (Message.Mut s))) where
-    setIndex (ThirdPartyCapDescriptor'newtype_ elt) i (ThirdPartyCapDescriptor'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (ThirdPartyCapDescriptor'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-get_ThirdPartyCapDescriptor'id :: ((Untyped.ReadCtx m msg)
-                                  ,(Classes.FromPtr msg (Std_.Maybe (Untyped.Ptr msg)))) => (ThirdPartyCapDescriptor msg) -> (m (Std_.Maybe (Untyped.Ptr msg)))
-get_ThirdPartyCapDescriptor'id (ThirdPartyCapDescriptor'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_ThirdPartyCapDescriptor'id :: ((Untyped.RWCtx m s)
-                                  ,(Classes.ToPtr s (Std_.Maybe (Untyped.Ptr (Message.Mut s))))) => (ThirdPartyCapDescriptor (Message.Mut s)) -> (Std_.Maybe (Untyped.Ptr (Message.Mut s))) -> (m ())
-set_ThirdPartyCapDescriptor'id (ThirdPartyCapDescriptor'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_ThirdPartyCapDescriptor'id :: ((Untyped.ReadCtx m msg)) => (ThirdPartyCapDescriptor msg) -> (m Std_.Bool)
-has_ThirdPartyCapDescriptor'id (ThirdPartyCapDescriptor'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-get_ThirdPartyCapDescriptor'vineId :: ((Untyped.ReadCtx m msg)) => (ThirdPartyCapDescriptor msg) -> (m Std_.Word32)
-get_ThirdPartyCapDescriptor'vineId (ThirdPartyCapDescriptor'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_ThirdPartyCapDescriptor'vineId :: ((Untyped.RWCtx m s)) => (ThirdPartyCapDescriptor (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_ThirdPartyCapDescriptor'vineId (ThirdPartyCapDescriptor'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-newtype Exception msg
-    = Exception'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Exception msg)) where
-    fromStruct struct = (Std_.pure (Exception'newtype_ struct))
-instance (Classes.ToStruct msg (Exception msg)) where
-    toStruct (Exception'newtype_ struct) = struct
-instance (Untyped.HasMessage (Exception mut) mut) where
-    message (Exception'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Exception mut) mut) where
-    messageDefault msg = (Exception'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Exception msg)) where
-    fromPtr msg ptr = (Exception'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Exception (Message.Mut s))) where
-    toPtr msg (Exception'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Exception (Message.Mut s))) where
-    new msg = (Exception'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (Exception mut)) where
-    newtype List mut (Exception mut)
-        = Exception'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Exception'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Exception'List_ l) = (Untyped.ListStruct l)
-    length (Exception'List_ l) = (Untyped.length l)
-    index i (Exception'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Exception (Message.Mut s))) where
-    setIndex (Exception'newtype_ elt) i (Exception'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Exception'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-get_Exception'reason :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Basics.Text msg))) => (Exception msg) -> (m (Basics.Text msg))
-get_Exception'reason (Exception'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Exception'reason :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Exception (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Exception'reason (Exception'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Exception'reason :: ((Untyped.ReadCtx m msg)) => (Exception msg) -> (m Std_.Bool)
-has_Exception'reason (Exception'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Exception'reason :: ((Untyped.RWCtx m s)) => Std_.Int -> (Exception (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Exception'reason len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Exception'reason struct result)
-    (Std_.pure result)
-    )
-get_Exception'obsoleteIsCallersFault :: ((Untyped.ReadCtx m msg)) => (Exception msg) -> (m Std_.Bool)
-get_Exception'obsoleteIsCallersFault (Exception'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Exception'obsoleteIsCallersFault :: ((Untyped.RWCtx m s)) => (Exception (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Exception'obsoleteIsCallersFault (Exception'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 0 0 0)
-get_Exception'obsoleteDurability :: ((Untyped.ReadCtx m msg)) => (Exception msg) -> (m Std_.Word16)
-get_Exception'obsoleteDurability (Exception'newtype_ struct) = (GenHelpers.getWordField struct 0 16 0)
-set_Exception'obsoleteDurability :: ((Untyped.RWCtx m s)) => (Exception (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Exception'obsoleteDurability (Exception'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 16 0)
-get_Exception'type_ :: ((Untyped.ReadCtx m msg)) => (Exception msg) -> (m Exception'Type)
-get_Exception'type_ (Exception'newtype_ struct) = (GenHelpers.getWordField struct 0 32 0)
-set_Exception'type_ :: ((Untyped.RWCtx m s)) => (Exception (Message.Mut s)) -> Exception'Type -> (m ())
-set_Exception'type_ (Exception'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 32 0)
-data Exception'Type 
-    = Exception'Type'failed 
-    | Exception'Type'overloaded 
-    | Exception'Type'disconnected 
-    | Exception'Type'unimplemented 
-    | Exception'Type'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Read
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Classes.IsWord Exception'Type) where
-    fromWord n = case ((Std_.fromIntegral n) :: Std_.Word16) of
-        0 ->
-            Exception'Type'failed
-        1 ->
-            Exception'Type'overloaded
-        2 ->
-            Exception'Type'disconnected
-        3 ->
-            Exception'Type'unimplemented
-        tag ->
-            (Exception'Type'unknown' tag)
-    toWord (Exception'Type'failed) = 0
-    toWord (Exception'Type'overloaded) = 1
-    toWord (Exception'Type'disconnected) = 2
-    toWord (Exception'Type'unimplemented) = 3
-    toWord (Exception'Type'unknown' tag) = (Std_.fromIntegral tag)
-instance (Std_.Enum Exception'Type) where
-    fromEnum x = (Std_.fromIntegral (Classes.toWord x))
-    toEnum x = (Classes.fromWord (Std_.fromIntegral x))
-instance (Basics.ListElem mut Exception'Type) where
-    newtype List mut Exception'Type
-        = Exception'Type'List_ (Untyped.ListOf mut Std_.Word16)
-    index i (Exception'Type'List_ l) = (Classes.fromWord <$> (Std_.fromIntegral <$> (Untyped.index i l)))
-    listFromPtr msg ptr = (Exception'Type'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Exception'Type'List_ l) = (Untyped.List16 l)
-    length (Exception'Type'List_ l) = (Untyped.length l)
-instance (Classes.MutListElem s Exception'Type) where
-    setIndex elt i (Exception'Type'List_ l) = (Untyped.setIndex (Std_.fromIntegral (Classes.toWord elt)) i l)
-    newList msg size = (Exception'Type'List_ <$> (Untyped.allocList16 msg size))
diff --git a/gen/lib/Capnp/Gen/Capnp/Rpc/New.hs b/gen/lib/Capnp/Gen/Capnp/Rpc/New.hs
--- a/gen/lib/Capnp/Gen/Capnp/Rpc/New.hs
+++ b/gen/lib/Capnp/Gen/Capnp/Rpc/New.hs
@@ -27,7 +27,6 @@
 import qualified Capnp.GenHelpers.New as GH
 import qualified Capnp.New.Classes as C
 import qualified GHC.Generics as Generics
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
 import qualified Prelude as Std_
 import qualified Data.Word as Std_
 import qualified Data.Int as Std_
diff --git a/gen/lib/Capnp/Gen/Capnp/Rpc/Pure.hs b/gen/lib/Capnp/Gen/Capnp/Rpc/Pure.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/Capnp/Rpc/Pure.hs
+++ /dev/null
@@ -1,1097 +0,0 @@
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE RecordWildCards #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Capnp.Rpc.Pure(Capnp.Gen.ById.Xb312981b2552a250.Exception'Type(..)
-                               ,Message(..)
-                               ,Bootstrap(..)
-                               ,Call(..)
-                               ,Call'sendResultsTo(..)
-                               ,Return(..)
-                               ,Return'(..)
-                               ,Finish(..)
-                               ,Resolve(..)
-                               ,Resolve'(..)
-                               ,Release(..)
-                               ,Disembargo(..)
-                               ,Disembargo'context(..)
-                               ,Provide(..)
-                               ,Accept(..)
-                               ,Join(..)
-                               ,MessageTarget(..)
-                               ,Payload(..)
-                               ,CapDescriptor(..)
-                               ,CapDescriptor'(..)
-                               ,PromisedAnswer(..)
-                               ,PromisedAnswer'Op(..)
-                               ,ThirdPartyCapDescriptor(..)
-                               ,Exception(..)) where
-import qualified Capnp.GenHelpers.ReExports.Data.Vector as V
-import qualified Capnp.GenHelpers.ReExports.Data.Text as T
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Capnp.GenHelpers.ReExports.Data.Default as Default
-import qualified GHC.Generics as Generics
-import qualified Control.Monad.IO.Class as MonadIO
-import qualified Capnp.Untyped.Pure as UntypedPure
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Message as Message
-import qualified Capnp.Classes as Classes
-import qualified Capnp.Basics.Pure as BasicsPure
-import qualified Capnp.GenHelpers.Pure as GenHelpersPure
-import qualified Capnp.Gen.ById.Xb312981b2552a250
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-data Message 
-    = Message'unimplemented Message
-    | Message'abort Exception
-    | Message'call Call
-    | Message'return Return
-    | Message'finish Finish
-    | Message'resolve Resolve
-    | Message'release Release
-    | Message'obsoleteSave (Std_.Maybe UntypedPure.Ptr)
-    | Message'bootstrap Bootstrap
-    | Message'obsoleteDelete (Std_.Maybe UntypedPure.Ptr)
-    | Message'provide Provide
-    | Message'accept Accept
-    | Message'join Join
-    | Message'disembargo Disembargo
-    | Message'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Message) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Message) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Message) where
-    type Cerial msg Message = (Capnp.Gen.ById.Xb312981b2552a250.Message msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xb312981b2552a250.get_Message' raw)
-        case raw of
-            (Capnp.Gen.ById.Xb312981b2552a250.Message'unimplemented raw) ->
-                (Message'unimplemented <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Message'abort raw) ->
-                (Message'abort <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Message'call raw) ->
-                (Message'call <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Message'return raw) ->
-                (Message'return <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Message'finish raw) ->
-                (Message'finish <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Message'resolve raw) ->
-                (Message'resolve <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Message'release raw) ->
-                (Message'release <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Message'obsoleteSave raw) ->
-                (Message'obsoleteSave <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Message'bootstrap raw) ->
-                (Message'bootstrap <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Message'obsoleteDelete raw) ->
-                (Message'obsoleteDelete <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Message'provide raw) ->
-                (Message'provide <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Message'accept raw) ->
-                (Message'accept <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Message'join raw) ->
-                (Message'join <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Message'disembargo raw) ->
-                (Message'disembargo <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Message'unknown' tag) ->
-                (Std_.pure (Message'unknown' tag))
-        )
-instance (Classes.Marshal s Message) where
-    marshalInto raw_ value_ = case value_ of
-        (Message'unimplemented arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Message'unimplemented raw_))
-        (Message'abort arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Message'abort raw_))
-        (Message'call arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Message'call raw_))
-        (Message'return arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Message'return raw_))
-        (Message'finish arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Message'finish raw_))
-        (Message'resolve arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Message'resolve raw_))
-        (Message'release arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Message'release raw_))
-        (Message'obsoleteSave arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Message'obsoleteSave raw_))
-        (Message'bootstrap arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Message'bootstrap raw_))
-        (Message'obsoleteDelete arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Message'obsoleteDelete raw_))
-        (Message'provide arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Message'provide raw_))
-        (Message'accept arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Message'accept raw_))
-        (Message'join arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Message'join raw_))
-        (Message'disembargo arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Message'disembargo raw_))
-        (Message'unknown' tag) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_Message'unknown' raw_ tag)
-instance (Classes.Cerialize s Message)
-instance (Classes.Cerialize s (V.Vector Message)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Message))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Message)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Message))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Message)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Message))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Message)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Bootstrap 
-    = Bootstrap 
-        {questionId :: Std_.Word32
-        ,deprecatedObjectId :: (Std_.Maybe UntypedPure.Ptr)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Bootstrap) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Bootstrap) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Bootstrap) where
-    type Cerial msg Bootstrap = (Capnp.Gen.ById.Xb312981b2552a250.Bootstrap msg)
-    decerialize raw = (Bootstrap <$> (Capnp.Gen.ById.Xb312981b2552a250.get_Bootstrap'questionId raw)
-                                 <*> ((Capnp.Gen.ById.Xb312981b2552a250.get_Bootstrap'deprecatedObjectId raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Bootstrap) where
-    marshalInto raw_ value_ = case value_ of
-        Bootstrap{..} ->
-            (do
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Bootstrap'questionId raw_ questionId)
-                ((Classes.cerialize (Untyped.message raw_) deprecatedObjectId) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Bootstrap'deprecatedObjectId raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Bootstrap)
-instance (Classes.Cerialize s (V.Vector Bootstrap)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Bootstrap))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Bootstrap)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Bootstrap))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Bootstrap)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Bootstrap))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Bootstrap)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Call 
-    = Call 
-        {questionId :: Std_.Word32
-        ,target :: MessageTarget
-        ,interfaceId :: Std_.Word64
-        ,methodId :: Std_.Word16
-        ,params :: Payload
-        ,sendResultsTo :: Call'sendResultsTo
-        ,allowThirdPartyTailCall :: Std_.Bool}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Call) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Call) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Call) where
-    type Cerial msg Call = (Capnp.Gen.ById.Xb312981b2552a250.Call msg)
-    decerialize raw = (Call <$> (Capnp.Gen.ById.Xb312981b2552a250.get_Call'questionId raw)
-                            <*> ((Capnp.Gen.ById.Xb312981b2552a250.get_Call'target raw) >>= Classes.decerialize)
-                            <*> (Capnp.Gen.ById.Xb312981b2552a250.get_Call'interfaceId raw)
-                            <*> (Capnp.Gen.ById.Xb312981b2552a250.get_Call'methodId raw)
-                            <*> ((Capnp.Gen.ById.Xb312981b2552a250.get_Call'params raw) >>= Classes.decerialize)
-                            <*> ((Capnp.Gen.ById.Xb312981b2552a250.get_Call'sendResultsTo raw) >>= Classes.decerialize)
-                            <*> (Capnp.Gen.ById.Xb312981b2552a250.get_Call'allowThirdPartyTailCall raw))
-instance (Classes.Marshal s Call) where
-    marshalInto raw_ value_ = case value_ of
-        Call{..} ->
-            (do
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Call'questionId raw_ questionId)
-                ((Classes.cerialize (Untyped.message raw_) target) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Call'target raw_))
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Call'interfaceId raw_ interfaceId)
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Call'methodId raw_ methodId)
-                ((Classes.cerialize (Untyped.message raw_) params) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Call'params raw_))
-                (do
-                    raw_ <- (Capnp.Gen.ById.Xb312981b2552a250.get_Call'sendResultsTo raw_)
-                    (Classes.marshalInto raw_ sendResultsTo)
-                    )
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Call'allowThirdPartyTailCall raw_ allowThirdPartyTailCall)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Call)
-instance (Classes.Cerialize s (V.Vector Call)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Call))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Call)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Call))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Call)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Call))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Call)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Call'sendResultsTo 
-    = Call'sendResultsTo'caller 
-    | Call'sendResultsTo'yourself 
-    | Call'sendResultsTo'thirdParty (Std_.Maybe UntypedPure.Ptr)
-    | Call'sendResultsTo'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Call'sendResultsTo) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Call'sendResultsTo) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Call'sendResultsTo) where
-    type Cerial msg Call'sendResultsTo = (Capnp.Gen.ById.Xb312981b2552a250.Call'sendResultsTo msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xb312981b2552a250.get_Call'sendResultsTo' raw)
-        case raw of
-            (Capnp.Gen.ById.Xb312981b2552a250.Call'sendResultsTo'caller) ->
-                (Std_.pure Call'sendResultsTo'caller)
-            (Capnp.Gen.ById.Xb312981b2552a250.Call'sendResultsTo'yourself) ->
-                (Std_.pure Call'sendResultsTo'yourself)
-            (Capnp.Gen.ById.Xb312981b2552a250.Call'sendResultsTo'thirdParty raw) ->
-                (Call'sendResultsTo'thirdParty <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Call'sendResultsTo'unknown' tag) ->
-                (Std_.pure (Call'sendResultsTo'unknown' tag))
-        )
-instance (Classes.Marshal s Call'sendResultsTo) where
-    marshalInto raw_ value_ = case value_ of
-        (Call'sendResultsTo'caller) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_Call'sendResultsTo'caller raw_)
-        (Call'sendResultsTo'yourself) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_Call'sendResultsTo'yourself raw_)
-        (Call'sendResultsTo'thirdParty arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Call'sendResultsTo'thirdParty raw_))
-        (Call'sendResultsTo'unknown' tag) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_Call'sendResultsTo'unknown' raw_ tag)
-data Return 
-    = Return 
-        {answerId :: Std_.Word32
-        ,releaseParamCaps :: Std_.Bool
-        ,union' :: Return'}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Return) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Return) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Return) where
-    type Cerial msg Return = (Capnp.Gen.ById.Xb312981b2552a250.Return msg)
-    decerialize raw = (Return <$> (Capnp.Gen.ById.Xb312981b2552a250.get_Return'answerId raw)
-                              <*> (Capnp.Gen.ById.Xb312981b2552a250.get_Return'releaseParamCaps raw)
-                              <*> (Classes.decerialize raw))
-instance (Classes.Marshal s Return) where
-    marshalInto raw_ value_ = case value_ of
-        Return{..} ->
-            (do
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Return'answerId raw_ answerId)
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Return'releaseParamCaps raw_ releaseParamCaps)
-                (do
-                    (Classes.marshalInto raw_ union')
-                    )
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Return)
-instance (Classes.Cerialize s (V.Vector Return)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Return))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Return)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Return))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Return)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Return))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Return)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Return' 
-    = Return'results Payload
-    | Return'exception Exception
-    | Return'canceled 
-    | Return'resultsSentElsewhere 
-    | Return'takeFromOtherQuestion Std_.Word32
-    | Return'acceptFromThirdParty (Std_.Maybe UntypedPure.Ptr)
-    | Return'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Return') where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Return') where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Return') where
-    type Cerial msg Return' = (Capnp.Gen.ById.Xb312981b2552a250.Return msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xb312981b2552a250.get_Return' raw)
-        case raw of
-            (Capnp.Gen.ById.Xb312981b2552a250.Return'results raw) ->
-                (Return'results <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Return'exception raw) ->
-                (Return'exception <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Return'canceled) ->
-                (Std_.pure Return'canceled)
-            (Capnp.Gen.ById.Xb312981b2552a250.Return'resultsSentElsewhere) ->
-                (Std_.pure Return'resultsSentElsewhere)
-            (Capnp.Gen.ById.Xb312981b2552a250.Return'takeFromOtherQuestion raw) ->
-                (Std_.pure (Return'takeFromOtherQuestion raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Return'acceptFromThirdParty raw) ->
-                (Return'acceptFromThirdParty <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Return'unknown' tag) ->
-                (Std_.pure (Return'unknown' tag))
-        )
-instance (Classes.Marshal s Return') where
-    marshalInto raw_ value_ = case value_ of
-        (Return'results arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Return'results raw_))
-        (Return'exception arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Return'exception raw_))
-        (Return'canceled) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_Return'canceled raw_)
-        (Return'resultsSentElsewhere) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_Return'resultsSentElsewhere raw_)
-        (Return'takeFromOtherQuestion arg_) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_Return'takeFromOtherQuestion raw_ arg_)
-        (Return'acceptFromThirdParty arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Return'acceptFromThirdParty raw_))
-        (Return'unknown' tag) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_Return'unknown' raw_ tag)
-data Finish 
-    = Finish 
-        {questionId :: Std_.Word32
-        ,releaseResultCaps :: Std_.Bool}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Finish) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Finish) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Finish) where
-    type Cerial msg Finish = (Capnp.Gen.ById.Xb312981b2552a250.Finish msg)
-    decerialize raw = (Finish <$> (Capnp.Gen.ById.Xb312981b2552a250.get_Finish'questionId raw)
-                              <*> (Capnp.Gen.ById.Xb312981b2552a250.get_Finish'releaseResultCaps raw))
-instance (Classes.Marshal s Finish) where
-    marshalInto raw_ value_ = case value_ of
-        Finish{..} ->
-            (do
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Finish'questionId raw_ questionId)
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Finish'releaseResultCaps raw_ releaseResultCaps)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Finish)
-instance (Classes.Cerialize s (V.Vector Finish)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Finish))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Finish)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Finish))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Finish)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Finish))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Finish)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Resolve 
-    = Resolve 
-        {promiseId :: Std_.Word32
-        ,union' :: Resolve'}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Resolve) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Resolve) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Resolve) where
-    type Cerial msg Resolve = (Capnp.Gen.ById.Xb312981b2552a250.Resolve msg)
-    decerialize raw = (Resolve <$> (Capnp.Gen.ById.Xb312981b2552a250.get_Resolve'promiseId raw)
-                               <*> (Classes.decerialize raw))
-instance (Classes.Marshal s Resolve) where
-    marshalInto raw_ value_ = case value_ of
-        Resolve{..} ->
-            (do
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Resolve'promiseId raw_ promiseId)
-                (do
-                    (Classes.marshalInto raw_ union')
-                    )
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Resolve)
-instance (Classes.Cerialize s (V.Vector Resolve)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Resolve))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Resolve)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Resolve))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Resolve)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Resolve))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Resolve)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Resolve' 
-    = Resolve'cap CapDescriptor
-    | Resolve'exception Exception
-    | Resolve'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Resolve') where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Resolve') where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Resolve') where
-    type Cerial msg Resolve' = (Capnp.Gen.ById.Xb312981b2552a250.Resolve msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xb312981b2552a250.get_Resolve' raw)
-        case raw of
-            (Capnp.Gen.ById.Xb312981b2552a250.Resolve'cap raw) ->
-                (Resolve'cap <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Resolve'exception raw) ->
-                (Resolve'exception <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Resolve'unknown' tag) ->
-                (Std_.pure (Resolve'unknown' tag))
-        )
-instance (Classes.Marshal s Resolve') where
-    marshalInto raw_ value_ = case value_ of
-        (Resolve'cap arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Resolve'cap raw_))
-        (Resolve'exception arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Resolve'exception raw_))
-        (Resolve'unknown' tag) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_Resolve'unknown' raw_ tag)
-data Release 
-    = Release 
-        {id :: Std_.Word32
-        ,referenceCount :: Std_.Word32}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Release) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Release) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Release) where
-    type Cerial msg Release = (Capnp.Gen.ById.Xb312981b2552a250.Release msg)
-    decerialize raw = (Release <$> (Capnp.Gen.ById.Xb312981b2552a250.get_Release'id raw)
-                               <*> (Capnp.Gen.ById.Xb312981b2552a250.get_Release'referenceCount raw))
-instance (Classes.Marshal s Release) where
-    marshalInto raw_ value_ = case value_ of
-        Release{..} ->
-            (do
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Release'id raw_ id)
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Release'referenceCount raw_ referenceCount)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Release)
-instance (Classes.Cerialize s (V.Vector Release)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Release))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Release)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Release))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Release)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Release))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Release)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Disembargo 
-    = Disembargo 
-        {target :: MessageTarget
-        ,context :: Disembargo'context}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Disembargo) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Disembargo) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Disembargo) where
-    type Cerial msg Disembargo = (Capnp.Gen.ById.Xb312981b2552a250.Disembargo msg)
-    decerialize raw = (Disembargo <$> ((Capnp.Gen.ById.Xb312981b2552a250.get_Disembargo'target raw) >>= Classes.decerialize)
-                                  <*> ((Capnp.Gen.ById.Xb312981b2552a250.get_Disembargo'context raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Disembargo) where
-    marshalInto raw_ value_ = case value_ of
-        Disembargo{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) target) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Disembargo'target raw_))
-                (do
-                    raw_ <- (Capnp.Gen.ById.Xb312981b2552a250.get_Disembargo'context raw_)
-                    (Classes.marshalInto raw_ context)
-                    )
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Disembargo)
-instance (Classes.Cerialize s (V.Vector Disembargo)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Disembargo))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Disembargo)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Disembargo))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Disembargo)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Disembargo))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Disembargo)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Disembargo'context 
-    = Disembargo'context'senderLoopback Std_.Word32
-    | Disembargo'context'receiverLoopback Std_.Word32
-    | Disembargo'context'accept 
-    | Disembargo'context'provide Std_.Word32
-    | Disembargo'context'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Disembargo'context) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Disembargo'context) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Disembargo'context) where
-    type Cerial msg Disembargo'context = (Capnp.Gen.ById.Xb312981b2552a250.Disembargo'context msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xb312981b2552a250.get_Disembargo'context' raw)
-        case raw of
-            (Capnp.Gen.ById.Xb312981b2552a250.Disembargo'context'senderLoopback raw) ->
-                (Std_.pure (Disembargo'context'senderLoopback raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Disembargo'context'receiverLoopback raw) ->
-                (Std_.pure (Disembargo'context'receiverLoopback raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Disembargo'context'accept) ->
-                (Std_.pure Disembargo'context'accept)
-            (Capnp.Gen.ById.Xb312981b2552a250.Disembargo'context'provide raw) ->
-                (Std_.pure (Disembargo'context'provide raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.Disembargo'context'unknown' tag) ->
-                (Std_.pure (Disembargo'context'unknown' tag))
-        )
-instance (Classes.Marshal s Disembargo'context) where
-    marshalInto raw_ value_ = case value_ of
-        (Disembargo'context'senderLoopback arg_) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_Disembargo'context'senderLoopback raw_ arg_)
-        (Disembargo'context'receiverLoopback arg_) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_Disembargo'context'receiverLoopback raw_ arg_)
-        (Disembargo'context'accept) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_Disembargo'context'accept raw_)
-        (Disembargo'context'provide arg_) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_Disembargo'context'provide raw_ arg_)
-        (Disembargo'context'unknown' tag) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_Disembargo'context'unknown' raw_ tag)
-data Provide 
-    = Provide 
-        {questionId :: Std_.Word32
-        ,target :: MessageTarget
-        ,recipient :: (Std_.Maybe UntypedPure.Ptr)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Provide) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Provide) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Provide) where
-    type Cerial msg Provide = (Capnp.Gen.ById.Xb312981b2552a250.Provide msg)
-    decerialize raw = (Provide <$> (Capnp.Gen.ById.Xb312981b2552a250.get_Provide'questionId raw)
-                               <*> ((Capnp.Gen.ById.Xb312981b2552a250.get_Provide'target raw) >>= Classes.decerialize)
-                               <*> ((Capnp.Gen.ById.Xb312981b2552a250.get_Provide'recipient raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Provide) where
-    marshalInto raw_ value_ = case value_ of
-        Provide{..} ->
-            (do
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Provide'questionId raw_ questionId)
-                ((Classes.cerialize (Untyped.message raw_) target) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Provide'target raw_))
-                ((Classes.cerialize (Untyped.message raw_) recipient) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Provide'recipient raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Provide)
-instance (Classes.Cerialize s (V.Vector Provide)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Provide))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Provide)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Provide))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Provide)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Provide))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Provide)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Accept 
-    = Accept 
-        {questionId :: Std_.Word32
-        ,provision :: (Std_.Maybe UntypedPure.Ptr)
-        ,embargo :: Std_.Bool}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Accept) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Accept) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Accept) where
-    type Cerial msg Accept = (Capnp.Gen.ById.Xb312981b2552a250.Accept msg)
-    decerialize raw = (Accept <$> (Capnp.Gen.ById.Xb312981b2552a250.get_Accept'questionId raw)
-                              <*> ((Capnp.Gen.ById.Xb312981b2552a250.get_Accept'provision raw) >>= Classes.decerialize)
-                              <*> (Capnp.Gen.ById.Xb312981b2552a250.get_Accept'embargo raw))
-instance (Classes.Marshal s Accept) where
-    marshalInto raw_ value_ = case value_ of
-        Accept{..} ->
-            (do
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Accept'questionId raw_ questionId)
-                ((Classes.cerialize (Untyped.message raw_) provision) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Accept'provision raw_))
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Accept'embargo raw_ embargo)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Accept)
-instance (Classes.Cerialize s (V.Vector Accept)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Accept))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Accept)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Accept))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Accept)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Accept))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Accept)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Join 
-    = Join 
-        {questionId :: Std_.Word32
-        ,target :: MessageTarget
-        ,keyPart :: (Std_.Maybe UntypedPure.Ptr)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Join) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Join) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Join) where
-    type Cerial msg Join = (Capnp.Gen.ById.Xb312981b2552a250.Join msg)
-    decerialize raw = (Join <$> (Capnp.Gen.ById.Xb312981b2552a250.get_Join'questionId raw)
-                            <*> ((Capnp.Gen.ById.Xb312981b2552a250.get_Join'target raw) >>= Classes.decerialize)
-                            <*> ((Capnp.Gen.ById.Xb312981b2552a250.get_Join'keyPart raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Join) where
-    marshalInto raw_ value_ = case value_ of
-        Join{..} ->
-            (do
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Join'questionId raw_ questionId)
-                ((Classes.cerialize (Untyped.message raw_) target) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Join'target raw_))
-                ((Classes.cerialize (Untyped.message raw_) keyPart) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Join'keyPart raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Join)
-instance (Classes.Cerialize s (V.Vector Join)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Join))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Join)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Join))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Join)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Join))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Join)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data MessageTarget 
-    = MessageTarget'importedCap Std_.Word32
-    | MessageTarget'promisedAnswer PromisedAnswer
-    | MessageTarget'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default MessageTarget) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const MessageTarget) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize MessageTarget) where
-    type Cerial msg MessageTarget = (Capnp.Gen.ById.Xb312981b2552a250.MessageTarget msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xb312981b2552a250.get_MessageTarget' raw)
-        case raw of
-            (Capnp.Gen.ById.Xb312981b2552a250.MessageTarget'importedCap raw) ->
-                (Std_.pure (MessageTarget'importedCap raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.MessageTarget'promisedAnswer raw) ->
-                (MessageTarget'promisedAnswer <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.MessageTarget'unknown' tag) ->
-                (Std_.pure (MessageTarget'unknown' tag))
-        )
-instance (Classes.Marshal s MessageTarget) where
-    marshalInto raw_ value_ = case value_ of
-        (MessageTarget'importedCap arg_) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_MessageTarget'importedCap raw_ arg_)
-        (MessageTarget'promisedAnswer arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_MessageTarget'promisedAnswer raw_))
-        (MessageTarget'unknown' tag) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_MessageTarget'unknown' raw_ tag)
-instance (Classes.Cerialize s MessageTarget)
-instance (Classes.Cerialize s (V.Vector MessageTarget)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector MessageTarget))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector MessageTarget)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector MessageTarget))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector MessageTarget)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector MessageTarget))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector MessageTarget)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Payload 
-    = Payload 
-        {content :: (Std_.Maybe UntypedPure.Ptr)
-        ,capTable :: (V.Vector CapDescriptor)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Payload) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Payload) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Payload) where
-    type Cerial msg Payload = (Capnp.Gen.ById.Xb312981b2552a250.Payload msg)
-    decerialize raw = (Payload <$> ((Capnp.Gen.ById.Xb312981b2552a250.get_Payload'content raw) >>= Classes.decerialize)
-                               <*> ((Capnp.Gen.ById.Xb312981b2552a250.get_Payload'capTable raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Payload) where
-    marshalInto raw_ value_ = case value_ of
-        Payload{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) content) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Payload'content raw_))
-                ((Classes.cerialize (Untyped.message raw_) capTable) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Payload'capTable raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Payload)
-instance (Classes.Cerialize s (V.Vector Payload)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Payload))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Payload)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Payload))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Payload)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Payload))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Payload)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data CapDescriptor 
-    = CapDescriptor 
-        {attachedFd :: Std_.Word8
-        ,union' :: CapDescriptor'}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default CapDescriptor) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const CapDescriptor) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize CapDescriptor) where
-    type Cerial msg CapDescriptor = (Capnp.Gen.ById.Xb312981b2552a250.CapDescriptor msg)
-    decerialize raw = (CapDescriptor <$> (Capnp.Gen.ById.Xb312981b2552a250.get_CapDescriptor'attachedFd raw)
-                                     <*> (Classes.decerialize raw))
-instance (Classes.Marshal s CapDescriptor) where
-    marshalInto raw_ value_ = case value_ of
-        CapDescriptor{..} ->
-            (do
-                (Capnp.Gen.ById.Xb312981b2552a250.set_CapDescriptor'attachedFd raw_ attachedFd)
-                (do
-                    (Classes.marshalInto raw_ union')
-                    )
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s CapDescriptor)
-instance (Classes.Cerialize s (V.Vector CapDescriptor)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector CapDescriptor))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector CapDescriptor)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector CapDescriptor))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CapDescriptor)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CapDescriptor))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CapDescriptor)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data CapDescriptor' 
-    = CapDescriptor'none 
-    | CapDescriptor'senderHosted Std_.Word32
-    | CapDescriptor'senderPromise Std_.Word32
-    | CapDescriptor'receiverHosted Std_.Word32
-    | CapDescriptor'receiverAnswer PromisedAnswer
-    | CapDescriptor'thirdPartyHosted ThirdPartyCapDescriptor
-    | CapDescriptor'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default CapDescriptor') where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const CapDescriptor') where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize CapDescriptor') where
-    type Cerial msg CapDescriptor' = (Capnp.Gen.ById.Xb312981b2552a250.CapDescriptor msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xb312981b2552a250.get_CapDescriptor' raw)
-        case raw of
-            (Capnp.Gen.ById.Xb312981b2552a250.CapDescriptor'none) ->
-                (Std_.pure CapDescriptor'none)
-            (Capnp.Gen.ById.Xb312981b2552a250.CapDescriptor'senderHosted raw) ->
-                (Std_.pure (CapDescriptor'senderHosted raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.CapDescriptor'senderPromise raw) ->
-                (Std_.pure (CapDescriptor'senderPromise raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.CapDescriptor'receiverHosted raw) ->
-                (Std_.pure (CapDescriptor'receiverHosted raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.CapDescriptor'receiverAnswer raw) ->
-                (CapDescriptor'receiverAnswer <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.CapDescriptor'thirdPartyHosted raw) ->
-                (CapDescriptor'thirdPartyHosted <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.CapDescriptor'unknown' tag) ->
-                (Std_.pure (CapDescriptor'unknown' tag))
-        )
-instance (Classes.Marshal s CapDescriptor') where
-    marshalInto raw_ value_ = case value_ of
-        (CapDescriptor'none) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_CapDescriptor'none raw_)
-        (CapDescriptor'senderHosted arg_) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_CapDescriptor'senderHosted raw_ arg_)
-        (CapDescriptor'senderPromise arg_) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_CapDescriptor'senderPromise raw_ arg_)
-        (CapDescriptor'receiverHosted arg_) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_CapDescriptor'receiverHosted raw_ arg_)
-        (CapDescriptor'receiverAnswer arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_CapDescriptor'receiverAnswer raw_))
-        (CapDescriptor'thirdPartyHosted arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_CapDescriptor'thirdPartyHosted raw_))
-        (CapDescriptor'unknown' tag) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_CapDescriptor'unknown' raw_ tag)
-data PromisedAnswer 
-    = PromisedAnswer 
-        {questionId :: Std_.Word32
-        ,transform :: (V.Vector PromisedAnswer'Op)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default PromisedAnswer) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const PromisedAnswer) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize PromisedAnswer) where
-    type Cerial msg PromisedAnswer = (Capnp.Gen.ById.Xb312981b2552a250.PromisedAnswer msg)
-    decerialize raw = (PromisedAnswer <$> (Capnp.Gen.ById.Xb312981b2552a250.get_PromisedAnswer'questionId raw)
-                                      <*> ((Capnp.Gen.ById.Xb312981b2552a250.get_PromisedAnswer'transform raw) >>= Classes.decerialize))
-instance (Classes.Marshal s PromisedAnswer) where
-    marshalInto raw_ value_ = case value_ of
-        PromisedAnswer{..} ->
-            (do
-                (Capnp.Gen.ById.Xb312981b2552a250.set_PromisedAnswer'questionId raw_ questionId)
-                ((Classes.cerialize (Untyped.message raw_) transform) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_PromisedAnswer'transform raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s PromisedAnswer)
-instance (Classes.Cerialize s (V.Vector PromisedAnswer)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector PromisedAnswer))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector PromisedAnswer)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector PromisedAnswer))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector PromisedAnswer)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector PromisedAnswer))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector PromisedAnswer)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data PromisedAnswer'Op 
-    = PromisedAnswer'Op'noop 
-    | PromisedAnswer'Op'getPointerField Std_.Word16
-    | PromisedAnswer'Op'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default PromisedAnswer'Op) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const PromisedAnswer'Op) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize PromisedAnswer'Op) where
-    type Cerial msg PromisedAnswer'Op = (Capnp.Gen.ById.Xb312981b2552a250.PromisedAnswer'Op msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xb312981b2552a250.get_PromisedAnswer'Op' raw)
-        case raw of
-            (Capnp.Gen.ById.Xb312981b2552a250.PromisedAnswer'Op'noop) ->
-                (Std_.pure PromisedAnswer'Op'noop)
-            (Capnp.Gen.ById.Xb312981b2552a250.PromisedAnswer'Op'getPointerField raw) ->
-                (Std_.pure (PromisedAnswer'Op'getPointerField raw))
-            (Capnp.Gen.ById.Xb312981b2552a250.PromisedAnswer'Op'unknown' tag) ->
-                (Std_.pure (PromisedAnswer'Op'unknown' tag))
-        )
-instance (Classes.Marshal s PromisedAnswer'Op) where
-    marshalInto raw_ value_ = case value_ of
-        (PromisedAnswer'Op'noop) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_PromisedAnswer'Op'noop raw_)
-        (PromisedAnswer'Op'getPointerField arg_) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_PromisedAnswer'Op'getPointerField raw_ arg_)
-        (PromisedAnswer'Op'unknown' tag) ->
-            (Capnp.Gen.ById.Xb312981b2552a250.set_PromisedAnswer'Op'unknown' raw_ tag)
-instance (Classes.Cerialize s PromisedAnswer'Op)
-instance (Classes.Cerialize s (V.Vector PromisedAnswer'Op)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector PromisedAnswer'Op))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector PromisedAnswer'Op)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector PromisedAnswer'Op))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector PromisedAnswer'Op)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector PromisedAnswer'Op))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector PromisedAnswer'Op)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data ThirdPartyCapDescriptor 
-    = ThirdPartyCapDescriptor 
-        {id :: (Std_.Maybe UntypedPure.Ptr)
-        ,vineId :: Std_.Word32}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default ThirdPartyCapDescriptor) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const ThirdPartyCapDescriptor) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize ThirdPartyCapDescriptor) where
-    type Cerial msg ThirdPartyCapDescriptor = (Capnp.Gen.ById.Xb312981b2552a250.ThirdPartyCapDescriptor msg)
-    decerialize raw = (ThirdPartyCapDescriptor <$> ((Capnp.Gen.ById.Xb312981b2552a250.get_ThirdPartyCapDescriptor'id raw) >>= Classes.decerialize)
-                                               <*> (Capnp.Gen.ById.Xb312981b2552a250.get_ThirdPartyCapDescriptor'vineId raw))
-instance (Classes.Marshal s ThirdPartyCapDescriptor) where
-    marshalInto raw_ value_ = case value_ of
-        ThirdPartyCapDescriptor{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) id) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_ThirdPartyCapDescriptor'id raw_))
-                (Capnp.Gen.ById.Xb312981b2552a250.set_ThirdPartyCapDescriptor'vineId raw_ vineId)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s ThirdPartyCapDescriptor)
-instance (Classes.Cerialize s (V.Vector ThirdPartyCapDescriptor)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector ThirdPartyCapDescriptor))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector ThirdPartyCapDescriptor)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector ThirdPartyCapDescriptor))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector ThirdPartyCapDescriptor)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector ThirdPartyCapDescriptor))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector ThirdPartyCapDescriptor)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Exception 
-    = Exception 
-        {reason :: T.Text
-        ,obsoleteIsCallersFault :: Std_.Bool
-        ,obsoleteDurability :: Std_.Word16
-        ,type_ :: Capnp.Gen.ById.Xb312981b2552a250.Exception'Type}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Exception) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Exception) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Exception) where
-    type Cerial msg Exception = (Capnp.Gen.ById.Xb312981b2552a250.Exception msg)
-    decerialize raw = (Exception <$> ((Capnp.Gen.ById.Xb312981b2552a250.get_Exception'reason raw) >>= Classes.decerialize)
-                                 <*> (Capnp.Gen.ById.Xb312981b2552a250.get_Exception'obsoleteIsCallersFault raw)
-                                 <*> (Capnp.Gen.ById.Xb312981b2552a250.get_Exception'obsoleteDurability raw)
-                                 <*> (Capnp.Gen.ById.Xb312981b2552a250.get_Exception'type_ raw))
-instance (Classes.Marshal s Exception) where
-    marshalInto raw_ value_ = case value_ of
-        Exception{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) reason) >>= (Capnp.Gen.ById.Xb312981b2552a250.set_Exception'reason raw_))
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Exception'obsoleteIsCallersFault raw_ obsoleteIsCallersFault)
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Exception'obsoleteDurability raw_ obsoleteDurability)
-                (Capnp.Gen.ById.Xb312981b2552a250.set_Exception'type_ raw_ type_)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Exception)
-instance (Classes.Cerialize s (V.Vector Exception)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Exception))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Exception)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Exception))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Exception)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Exception))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Exception)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Decerialize Capnp.Gen.ById.Xb312981b2552a250.Exception'Type) where
-    type Cerial msg Capnp.Gen.ById.Xb312981b2552a250.Exception'Type = Capnp.Gen.ById.Xb312981b2552a250.Exception'Type
-    decerialize  = Std_.pure
-instance (Classes.Cerialize s Capnp.Gen.ById.Xb312981b2552a250.Exception'Type) where
-    cerialize _ = Std_.pure
-instance (Classes.Cerialize s (V.Vector Capnp.Gen.ById.Xb312981b2552a250.Exception'Type)) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Capnp.Gen.ById.Xb312981b2552a250.Exception'Type))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.Xb312981b2552a250.Exception'Type)))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.Xb312981b2552a250.Exception'Type))))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.Xb312981b2552a250.Exception'Type)))))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.Xb312981b2552a250.Exception'Type))))))) where
-    cerialize  = Classes.cerializeBasicVec
diff --git a/gen/lib/Capnp/Gen/Capnp/RpcTwoparty.hs b/gen/lib/Capnp/Gen/Capnp/RpcTwoparty.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/Capnp/RpcTwoparty.hs
+++ /dev/null
@@ -1,275 +0,0 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Capnp.RpcTwoparty where
-import qualified Capnp.Message as Message
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Basics as Basics
-import qualified Capnp.GenHelpers as GenHelpers
-import qualified Capnp.Classes as Classes
-import qualified GHC.Generics as Generics
-import qualified Capnp.Bits as Std_
-import qualified Data.Maybe as Std_
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-data Side 
-    = Side'server 
-    | Side'client 
-    | Side'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Read
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Classes.IsWord Side) where
-    fromWord n = case ((Std_.fromIntegral n) :: Std_.Word16) of
-        0 ->
-            Side'server
-        1 ->
-            Side'client
-        tag ->
-            (Side'unknown' tag)
-    toWord (Side'server) = 0
-    toWord (Side'client) = 1
-    toWord (Side'unknown' tag) = (Std_.fromIntegral tag)
-instance (Std_.Enum Side) where
-    fromEnum x = (Std_.fromIntegral (Classes.toWord x))
-    toEnum x = (Classes.fromWord (Std_.fromIntegral x))
-instance (Basics.ListElem mut Side) where
-    newtype List mut Side
-        = Side'List_ (Untyped.ListOf mut Std_.Word16)
-    index i (Side'List_ l) = (Classes.fromWord <$> (Std_.fromIntegral <$> (Untyped.index i l)))
-    listFromPtr msg ptr = (Side'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Side'List_ l) = (Untyped.List16 l)
-    length (Side'List_ l) = (Untyped.length l)
-instance (Classes.MutListElem s Side) where
-    setIndex elt i (Side'List_ l) = (Untyped.setIndex (Std_.fromIntegral (Classes.toWord elt)) i l)
-    newList msg size = (Side'List_ <$> (Untyped.allocList16 msg size))
-newtype VatId msg
-    = VatId'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (VatId msg)) where
-    fromStruct struct = (Std_.pure (VatId'newtype_ struct))
-instance (Classes.ToStruct msg (VatId msg)) where
-    toStruct (VatId'newtype_ struct) = struct
-instance (Untyped.HasMessage (VatId mut) mut) where
-    message (VatId'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (VatId mut) mut) where
-    messageDefault msg = (VatId'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (VatId msg)) where
-    fromPtr msg ptr = (VatId'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (VatId (Message.Mut s))) where
-    toPtr msg (VatId'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (VatId (Message.Mut s))) where
-    new msg = (VatId'newtype_ <$> (Untyped.allocStruct msg 1 0))
-instance (Basics.ListElem mut (VatId mut)) where
-    newtype List mut (VatId mut)
-        = VatId'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (VatId'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (VatId'List_ l) = (Untyped.ListStruct l)
-    length (VatId'List_ l) = (Untyped.length l)
-    index i (VatId'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (VatId (Message.Mut s))) where
-    setIndex (VatId'newtype_ elt) i (VatId'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (VatId'List_ <$> (Untyped.allocCompositeList msg 1 0 len))
-get_VatId'side :: ((Untyped.ReadCtx m msg)) => (VatId msg) -> (m Side)
-get_VatId'side (VatId'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_VatId'side :: ((Untyped.RWCtx m s)) => (VatId (Message.Mut s)) -> Side -> (m ())
-set_VatId'side (VatId'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-newtype ProvisionId msg
-    = ProvisionId'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (ProvisionId msg)) where
-    fromStruct struct = (Std_.pure (ProvisionId'newtype_ struct))
-instance (Classes.ToStruct msg (ProvisionId msg)) where
-    toStruct (ProvisionId'newtype_ struct) = struct
-instance (Untyped.HasMessage (ProvisionId mut) mut) where
-    message (ProvisionId'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (ProvisionId mut) mut) where
-    messageDefault msg = (ProvisionId'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (ProvisionId msg)) where
-    fromPtr msg ptr = (ProvisionId'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (ProvisionId (Message.Mut s))) where
-    toPtr msg (ProvisionId'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (ProvisionId (Message.Mut s))) where
-    new msg = (ProvisionId'newtype_ <$> (Untyped.allocStruct msg 1 0))
-instance (Basics.ListElem mut (ProvisionId mut)) where
-    newtype List mut (ProvisionId mut)
-        = ProvisionId'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (ProvisionId'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (ProvisionId'List_ l) = (Untyped.ListStruct l)
-    length (ProvisionId'List_ l) = (Untyped.length l)
-    index i (ProvisionId'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (ProvisionId (Message.Mut s))) where
-    setIndex (ProvisionId'newtype_ elt) i (ProvisionId'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (ProvisionId'List_ <$> (Untyped.allocCompositeList msg 1 0 len))
-get_ProvisionId'joinId :: ((Untyped.ReadCtx m msg)) => (ProvisionId msg) -> (m Std_.Word32)
-get_ProvisionId'joinId (ProvisionId'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_ProvisionId'joinId :: ((Untyped.RWCtx m s)) => (ProvisionId (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_ProvisionId'joinId (ProvisionId'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-newtype RecipientId msg
-    = RecipientId'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (RecipientId msg)) where
-    fromStruct struct = (Std_.pure (RecipientId'newtype_ struct))
-instance (Classes.ToStruct msg (RecipientId msg)) where
-    toStruct (RecipientId'newtype_ struct) = struct
-instance (Untyped.HasMessage (RecipientId mut) mut) where
-    message (RecipientId'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (RecipientId mut) mut) where
-    messageDefault msg = (RecipientId'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (RecipientId msg)) where
-    fromPtr msg ptr = (RecipientId'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (RecipientId (Message.Mut s))) where
-    toPtr msg (RecipientId'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (RecipientId (Message.Mut s))) where
-    new msg = (RecipientId'newtype_ <$> (Untyped.allocStruct msg 0 0))
-instance (Basics.ListElem mut (RecipientId mut)) where
-    newtype List mut (RecipientId mut)
-        = RecipientId'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (RecipientId'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (RecipientId'List_ l) = (Untyped.ListStruct l)
-    length (RecipientId'List_ l) = (Untyped.length l)
-    index i (RecipientId'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (RecipientId (Message.Mut s))) where
-    setIndex (RecipientId'newtype_ elt) i (RecipientId'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (RecipientId'List_ <$> (Untyped.allocCompositeList msg 0 0 len))
-newtype ThirdPartyCapId msg
-    = ThirdPartyCapId'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (ThirdPartyCapId msg)) where
-    fromStruct struct = (Std_.pure (ThirdPartyCapId'newtype_ struct))
-instance (Classes.ToStruct msg (ThirdPartyCapId msg)) where
-    toStruct (ThirdPartyCapId'newtype_ struct) = struct
-instance (Untyped.HasMessage (ThirdPartyCapId mut) mut) where
-    message (ThirdPartyCapId'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (ThirdPartyCapId mut) mut) where
-    messageDefault msg = (ThirdPartyCapId'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (ThirdPartyCapId msg)) where
-    fromPtr msg ptr = (ThirdPartyCapId'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (ThirdPartyCapId (Message.Mut s))) where
-    toPtr msg (ThirdPartyCapId'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (ThirdPartyCapId (Message.Mut s))) where
-    new msg = (ThirdPartyCapId'newtype_ <$> (Untyped.allocStruct msg 0 0))
-instance (Basics.ListElem mut (ThirdPartyCapId mut)) where
-    newtype List mut (ThirdPartyCapId mut)
-        = ThirdPartyCapId'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (ThirdPartyCapId'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (ThirdPartyCapId'List_ l) = (Untyped.ListStruct l)
-    length (ThirdPartyCapId'List_ l) = (Untyped.length l)
-    index i (ThirdPartyCapId'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (ThirdPartyCapId (Message.Mut s))) where
-    setIndex (ThirdPartyCapId'newtype_ elt) i (ThirdPartyCapId'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (ThirdPartyCapId'List_ <$> (Untyped.allocCompositeList msg 0 0 len))
-newtype JoinKeyPart msg
-    = JoinKeyPart'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (JoinKeyPart msg)) where
-    fromStruct struct = (Std_.pure (JoinKeyPart'newtype_ struct))
-instance (Classes.ToStruct msg (JoinKeyPart msg)) where
-    toStruct (JoinKeyPart'newtype_ struct) = struct
-instance (Untyped.HasMessage (JoinKeyPart mut) mut) where
-    message (JoinKeyPart'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (JoinKeyPart mut) mut) where
-    messageDefault msg = (JoinKeyPart'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (JoinKeyPart msg)) where
-    fromPtr msg ptr = (JoinKeyPart'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (JoinKeyPart (Message.Mut s))) where
-    toPtr msg (JoinKeyPart'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (JoinKeyPart (Message.Mut s))) where
-    new msg = (JoinKeyPart'newtype_ <$> (Untyped.allocStruct msg 1 0))
-instance (Basics.ListElem mut (JoinKeyPart mut)) where
-    newtype List mut (JoinKeyPart mut)
-        = JoinKeyPart'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (JoinKeyPart'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (JoinKeyPart'List_ l) = (Untyped.ListStruct l)
-    length (JoinKeyPart'List_ l) = (Untyped.length l)
-    index i (JoinKeyPart'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (JoinKeyPart (Message.Mut s))) where
-    setIndex (JoinKeyPart'newtype_ elt) i (JoinKeyPart'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (JoinKeyPart'List_ <$> (Untyped.allocCompositeList msg 1 0 len))
-get_JoinKeyPart'joinId :: ((Untyped.ReadCtx m msg)) => (JoinKeyPart msg) -> (m Std_.Word32)
-get_JoinKeyPart'joinId (JoinKeyPart'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_JoinKeyPart'joinId :: ((Untyped.RWCtx m s)) => (JoinKeyPart (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_JoinKeyPart'joinId (JoinKeyPart'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-get_JoinKeyPart'partCount :: ((Untyped.ReadCtx m msg)) => (JoinKeyPart msg) -> (m Std_.Word16)
-get_JoinKeyPart'partCount (JoinKeyPart'newtype_ struct) = (GenHelpers.getWordField struct 0 32 0)
-set_JoinKeyPart'partCount :: ((Untyped.RWCtx m s)) => (JoinKeyPart (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_JoinKeyPart'partCount (JoinKeyPart'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 32 0)
-get_JoinKeyPart'partNum :: ((Untyped.ReadCtx m msg)) => (JoinKeyPart msg) -> (m Std_.Word16)
-get_JoinKeyPart'partNum (JoinKeyPart'newtype_ struct) = (GenHelpers.getWordField struct 0 48 0)
-set_JoinKeyPart'partNum :: ((Untyped.RWCtx m s)) => (JoinKeyPart (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_JoinKeyPart'partNum (JoinKeyPart'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 48 0)
-newtype JoinResult msg
-    = JoinResult'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (JoinResult msg)) where
-    fromStruct struct = (Std_.pure (JoinResult'newtype_ struct))
-instance (Classes.ToStruct msg (JoinResult msg)) where
-    toStruct (JoinResult'newtype_ struct) = struct
-instance (Untyped.HasMessage (JoinResult mut) mut) where
-    message (JoinResult'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (JoinResult mut) mut) where
-    messageDefault msg = (JoinResult'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (JoinResult msg)) where
-    fromPtr msg ptr = (JoinResult'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (JoinResult (Message.Mut s))) where
-    toPtr msg (JoinResult'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (JoinResult (Message.Mut s))) where
-    new msg = (JoinResult'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (JoinResult mut)) where
-    newtype List mut (JoinResult mut)
-        = JoinResult'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (JoinResult'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (JoinResult'List_ l) = (Untyped.ListStruct l)
-    length (JoinResult'List_ l) = (Untyped.length l)
-    index i (JoinResult'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (JoinResult (Message.Mut s))) where
-    setIndex (JoinResult'newtype_ elt) i (JoinResult'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (JoinResult'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-get_JoinResult'joinId :: ((Untyped.ReadCtx m msg)) => (JoinResult msg) -> (m Std_.Word32)
-get_JoinResult'joinId (JoinResult'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_JoinResult'joinId :: ((Untyped.RWCtx m s)) => (JoinResult (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_JoinResult'joinId (JoinResult'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-get_JoinResult'succeeded :: ((Untyped.ReadCtx m msg)) => (JoinResult msg) -> (m Std_.Bool)
-get_JoinResult'succeeded (JoinResult'newtype_ struct) = (GenHelpers.getWordField struct 0 32 0)
-set_JoinResult'succeeded :: ((Untyped.RWCtx m s)) => (JoinResult (Message.Mut s)) -> Std_.Bool -> (m ())
-set_JoinResult'succeeded (JoinResult'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 0 32 0)
-get_JoinResult'cap :: ((Untyped.ReadCtx m msg)
-                      ,(Classes.FromPtr msg (Std_.Maybe (Untyped.Ptr msg)))) => (JoinResult msg) -> (m (Std_.Maybe (Untyped.Ptr msg)))
-get_JoinResult'cap (JoinResult'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_JoinResult'cap :: ((Untyped.RWCtx m s)
-                      ,(Classes.ToPtr s (Std_.Maybe (Untyped.Ptr (Message.Mut s))))) => (JoinResult (Message.Mut s)) -> (Std_.Maybe (Untyped.Ptr (Message.Mut s))) -> (m ())
-set_JoinResult'cap (JoinResult'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_JoinResult'cap :: ((Untyped.ReadCtx m msg)) => (JoinResult msg) -> (m Std_.Bool)
-has_JoinResult'cap (JoinResult'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
diff --git a/gen/lib/Capnp/Gen/Capnp/RpcTwoparty/New.hs b/gen/lib/Capnp/Gen/Capnp/RpcTwoparty/New.hs
--- a/gen/lib/Capnp/Gen/Capnp/RpcTwoparty/New.hs
+++ b/gen/lib/Capnp/Gen/Capnp/RpcTwoparty/New.hs
@@ -27,7 +27,6 @@
 import qualified Capnp.GenHelpers.New as GH
 import qualified Capnp.New.Classes as C
 import qualified GHC.Generics as Generics
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
 import qualified Prelude as Std_
 import qualified Data.Word as Std_
 import qualified Data.Int as Std_
diff --git a/gen/lib/Capnp/Gen/Capnp/RpcTwoparty/Pure.hs b/gen/lib/Capnp/Gen/Capnp/RpcTwoparty/Pure.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/Capnp/RpcTwoparty/Pure.hs
+++ /dev/null
@@ -1,277 +0,0 @@
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE RecordWildCards #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Capnp.RpcTwoparty.Pure(Capnp.Gen.ById.Xa184c7885cdaf2a1.Side(..)
-                                       ,VatId(..)
-                                       ,ProvisionId(..)
-                                       ,RecipientId(..)
-                                       ,ThirdPartyCapId(..)
-                                       ,JoinKeyPart(..)
-                                       ,JoinResult(..)) where
-import qualified Capnp.GenHelpers.ReExports.Data.Vector as V
-import qualified Capnp.GenHelpers.ReExports.Data.Text as T
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Capnp.GenHelpers.ReExports.Data.Default as Default
-import qualified GHC.Generics as Generics
-import qualified Control.Monad.IO.Class as MonadIO
-import qualified Capnp.Untyped.Pure as UntypedPure
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Message as Message
-import qualified Capnp.Classes as Classes
-import qualified Capnp.Basics.Pure as BasicsPure
-import qualified Capnp.GenHelpers.Pure as GenHelpersPure
-import qualified Capnp.Gen.ById.Xa184c7885cdaf2a1
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-data VatId 
-    = VatId 
-        {side :: Capnp.Gen.ById.Xa184c7885cdaf2a1.Side}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default VatId) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const VatId) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize VatId) where
-    type Cerial msg VatId = (Capnp.Gen.ById.Xa184c7885cdaf2a1.VatId msg)
-    decerialize raw = (VatId <$> (Capnp.Gen.ById.Xa184c7885cdaf2a1.get_VatId'side raw))
-instance (Classes.Marshal s VatId) where
-    marshalInto raw_ value_ = case value_ of
-        VatId{..} ->
-            (do
-                (Capnp.Gen.ById.Xa184c7885cdaf2a1.set_VatId'side raw_ side)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s VatId)
-instance (Classes.Cerialize s (V.Vector VatId)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector VatId))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector VatId)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector VatId))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VatId)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VatId))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VatId)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data ProvisionId 
-    = ProvisionId 
-        {joinId :: Std_.Word32}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default ProvisionId) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const ProvisionId) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize ProvisionId) where
-    type Cerial msg ProvisionId = (Capnp.Gen.ById.Xa184c7885cdaf2a1.ProvisionId msg)
-    decerialize raw = (ProvisionId <$> (Capnp.Gen.ById.Xa184c7885cdaf2a1.get_ProvisionId'joinId raw))
-instance (Classes.Marshal s ProvisionId) where
-    marshalInto raw_ value_ = case value_ of
-        ProvisionId{..} ->
-            (do
-                (Capnp.Gen.ById.Xa184c7885cdaf2a1.set_ProvisionId'joinId raw_ joinId)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s ProvisionId)
-instance (Classes.Cerialize s (V.Vector ProvisionId)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector ProvisionId))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector ProvisionId)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector ProvisionId))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector ProvisionId)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector ProvisionId))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector ProvisionId)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data RecipientId 
-    = RecipientId 
-        {}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default RecipientId) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const RecipientId) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize RecipientId) where
-    type Cerial msg RecipientId = (Capnp.Gen.ById.Xa184c7885cdaf2a1.RecipientId msg)
-    decerialize raw = (Std_.pure RecipientId)
-instance (Classes.Marshal s RecipientId) where
-    marshalInto raw_ value_ = case value_ of
-        (RecipientId) ->
-            (do
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s RecipientId)
-instance (Classes.Cerialize s (V.Vector RecipientId)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector RecipientId))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector RecipientId)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector RecipientId))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector RecipientId)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector RecipientId))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector RecipientId)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data ThirdPartyCapId 
-    = ThirdPartyCapId 
-        {}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default ThirdPartyCapId) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const ThirdPartyCapId) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize ThirdPartyCapId) where
-    type Cerial msg ThirdPartyCapId = (Capnp.Gen.ById.Xa184c7885cdaf2a1.ThirdPartyCapId msg)
-    decerialize raw = (Std_.pure ThirdPartyCapId)
-instance (Classes.Marshal s ThirdPartyCapId) where
-    marshalInto raw_ value_ = case value_ of
-        (ThirdPartyCapId) ->
-            (do
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s ThirdPartyCapId)
-instance (Classes.Cerialize s (V.Vector ThirdPartyCapId)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector ThirdPartyCapId))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector ThirdPartyCapId)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector ThirdPartyCapId))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector ThirdPartyCapId)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector ThirdPartyCapId))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector ThirdPartyCapId)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data JoinKeyPart 
-    = JoinKeyPart 
-        {joinId :: Std_.Word32
-        ,partCount :: Std_.Word16
-        ,partNum :: Std_.Word16}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default JoinKeyPart) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const JoinKeyPart) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize JoinKeyPart) where
-    type Cerial msg JoinKeyPart = (Capnp.Gen.ById.Xa184c7885cdaf2a1.JoinKeyPart msg)
-    decerialize raw = (JoinKeyPart <$> (Capnp.Gen.ById.Xa184c7885cdaf2a1.get_JoinKeyPart'joinId raw)
-                                   <*> (Capnp.Gen.ById.Xa184c7885cdaf2a1.get_JoinKeyPart'partCount raw)
-                                   <*> (Capnp.Gen.ById.Xa184c7885cdaf2a1.get_JoinKeyPart'partNum raw))
-instance (Classes.Marshal s JoinKeyPart) where
-    marshalInto raw_ value_ = case value_ of
-        JoinKeyPart{..} ->
-            (do
-                (Capnp.Gen.ById.Xa184c7885cdaf2a1.set_JoinKeyPart'joinId raw_ joinId)
-                (Capnp.Gen.ById.Xa184c7885cdaf2a1.set_JoinKeyPart'partCount raw_ partCount)
-                (Capnp.Gen.ById.Xa184c7885cdaf2a1.set_JoinKeyPart'partNum raw_ partNum)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s JoinKeyPart)
-instance (Classes.Cerialize s (V.Vector JoinKeyPart)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector JoinKeyPart))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector JoinKeyPart)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector JoinKeyPart))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector JoinKeyPart)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector JoinKeyPart))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector JoinKeyPart)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data JoinResult 
-    = JoinResult 
-        {joinId :: Std_.Word32
-        ,succeeded :: Std_.Bool
-        ,cap :: (Std_.Maybe UntypedPure.Ptr)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default JoinResult) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const JoinResult) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize JoinResult) where
-    type Cerial msg JoinResult = (Capnp.Gen.ById.Xa184c7885cdaf2a1.JoinResult msg)
-    decerialize raw = (JoinResult <$> (Capnp.Gen.ById.Xa184c7885cdaf2a1.get_JoinResult'joinId raw)
-                                  <*> (Capnp.Gen.ById.Xa184c7885cdaf2a1.get_JoinResult'succeeded raw)
-                                  <*> ((Capnp.Gen.ById.Xa184c7885cdaf2a1.get_JoinResult'cap raw) >>= Classes.decerialize))
-instance (Classes.Marshal s JoinResult) where
-    marshalInto raw_ value_ = case value_ of
-        JoinResult{..} ->
-            (do
-                (Capnp.Gen.ById.Xa184c7885cdaf2a1.set_JoinResult'joinId raw_ joinId)
-                (Capnp.Gen.ById.Xa184c7885cdaf2a1.set_JoinResult'succeeded raw_ succeeded)
-                ((Classes.cerialize (Untyped.message raw_) cap) >>= (Capnp.Gen.ById.Xa184c7885cdaf2a1.set_JoinResult'cap raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s JoinResult)
-instance (Classes.Cerialize s (V.Vector JoinResult)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector JoinResult))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector JoinResult)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector JoinResult))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector JoinResult)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector JoinResult))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector JoinResult)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Decerialize Capnp.Gen.ById.Xa184c7885cdaf2a1.Side) where
-    type Cerial msg Capnp.Gen.ById.Xa184c7885cdaf2a1.Side = Capnp.Gen.ById.Xa184c7885cdaf2a1.Side
-    decerialize  = Std_.pure
-instance (Classes.Cerialize s Capnp.Gen.ById.Xa184c7885cdaf2a1.Side) where
-    cerialize _ = Std_.pure
-instance (Classes.Cerialize s (V.Vector Capnp.Gen.ById.Xa184c7885cdaf2a1.Side)) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Capnp.Gen.ById.Xa184c7885cdaf2a1.Side))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.Xa184c7885cdaf2a1.Side)))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.Xa184c7885cdaf2a1.Side))))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.Xa184c7885cdaf2a1.Side)))))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.Xa184c7885cdaf2a1.Side))))))) where
-    cerialize  = Classes.cerializeBasicVec
diff --git a/gen/lib/Capnp/Gen/Capnp/Schema.hs b/gen/lib/Capnp/Gen/Capnp/Schema.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/Capnp/Schema.hs
+++ /dev/null
@@ -1,2489 +0,0 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Capnp.Schema where
-import qualified Capnp.Message as Message
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Basics as Basics
-import qualified Capnp.GenHelpers as GenHelpers
-import qualified Capnp.Classes as Classes
-import qualified GHC.Generics as Generics
-import qualified Capnp.Bits as Std_
-import qualified Data.Maybe as Std_
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-newtype Node msg
-    = Node'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Node msg)) where
-    fromStruct struct = (Std_.pure (Node'newtype_ struct))
-instance (Classes.ToStruct msg (Node msg)) where
-    toStruct (Node'newtype_ struct) = struct
-instance (Untyped.HasMessage (Node mut) mut) where
-    message (Node'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Node mut) mut) where
-    messageDefault msg = (Node'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Node msg)) where
-    fromPtr msg ptr = (Node'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Node (Message.Mut s))) where
-    toPtr msg (Node'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Node (Message.Mut s))) where
-    new msg = (Node'newtype_ <$> (Untyped.allocStruct msg 5 6))
-instance (Basics.ListElem mut (Node mut)) where
-    newtype List mut (Node mut)
-        = Node'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Node'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Node'List_ l) = (Untyped.ListStruct l)
-    length (Node'List_ l) = (Untyped.length l)
-    index i (Node'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Node (Message.Mut s))) where
-    setIndex (Node'newtype_ elt) i (Node'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Node'List_ <$> (Untyped.allocCompositeList msg 5 6 len))
-get_Node'id :: ((Untyped.ReadCtx m msg)) => (Node msg) -> (m Std_.Word64)
-get_Node'id (Node'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Node'id :: ((Untyped.RWCtx m s)) => (Node (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Node'id (Node'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 0 0 0)
-get_Node'displayName :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Basics.Text msg))) => (Node msg) -> (m (Basics.Text msg))
-get_Node'displayName (Node'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Node'displayName :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Node (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Node'displayName (Node'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Node'displayName :: ((Untyped.ReadCtx m msg)) => (Node msg) -> (m Std_.Bool)
-has_Node'displayName (Node'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Node'displayName :: ((Untyped.RWCtx m s)) => Std_.Int -> (Node (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Node'displayName len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Node'displayName struct result)
-    (Std_.pure result)
-    )
-get_Node'displayNamePrefixLength :: ((Untyped.ReadCtx m msg)) => (Node msg) -> (m Std_.Word32)
-get_Node'displayNamePrefixLength (Node'newtype_ struct) = (GenHelpers.getWordField struct 1 0 0)
-set_Node'displayNamePrefixLength :: ((Untyped.RWCtx m s)) => (Node (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Node'displayNamePrefixLength (Node'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 1 0 0)
-get_Node'scopeId :: ((Untyped.ReadCtx m msg)) => (Node msg) -> (m Std_.Word64)
-get_Node'scopeId (Node'newtype_ struct) = (GenHelpers.getWordField struct 2 0 0)
-set_Node'scopeId :: ((Untyped.RWCtx m s)) => (Node (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Node'scopeId (Node'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 2 0 0)
-get_Node'nestedNodes :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Basics.List msg (Node'NestedNode msg)))) => (Node msg) -> (m (Basics.List msg (Node'NestedNode msg)))
-get_Node'nestedNodes (Node'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Node'nestedNodes :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Node'NestedNode (Message.Mut s))))) => (Node (Message.Mut s)) -> (Basics.List (Message.Mut s) (Node'NestedNode (Message.Mut s))) -> (m ())
-set_Node'nestedNodes (Node'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Node'nestedNodes :: ((Untyped.ReadCtx m msg)) => (Node msg) -> (m Std_.Bool)
-has_Node'nestedNodes (Node'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_Node'nestedNodes :: ((Untyped.RWCtx m s)) => Std_.Int -> (Node (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Node'NestedNode (Message.Mut s))))
-new_Node'nestedNodes len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Node'nestedNodes struct result)
-    (Std_.pure result)
-    )
-get_Node'annotations :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Basics.List msg (Annotation msg)))) => (Node msg) -> (m (Basics.List msg (Annotation msg)))
-get_Node'annotations (Node'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 2 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Node'annotations :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Annotation (Message.Mut s))))) => (Node (Message.Mut s)) -> (Basics.List (Message.Mut s) (Annotation (Message.Mut s))) -> (m ())
-set_Node'annotations (Node'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 2 struct)
-    )
-has_Node'annotations :: ((Untyped.ReadCtx m msg)) => (Node msg) -> (m Std_.Bool)
-has_Node'annotations (Node'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 2 struct))
-new_Node'annotations :: ((Untyped.RWCtx m s)) => Std_.Int -> (Node (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Annotation (Message.Mut s))))
-new_Node'annotations len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Node'annotations struct result)
-    (Std_.pure result)
-    )
-get_Node'parameters :: ((Untyped.ReadCtx m msg)
-                       ,(Classes.FromPtr msg (Basics.List msg (Node'Parameter msg)))) => (Node msg) -> (m (Basics.List msg (Node'Parameter msg)))
-get_Node'parameters (Node'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 5 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Node'parameters :: ((Untyped.RWCtx m s)
-                       ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Node'Parameter (Message.Mut s))))) => (Node (Message.Mut s)) -> (Basics.List (Message.Mut s) (Node'Parameter (Message.Mut s))) -> (m ())
-set_Node'parameters (Node'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 5 struct)
-    )
-has_Node'parameters :: ((Untyped.ReadCtx m msg)) => (Node msg) -> (m Std_.Bool)
-has_Node'parameters (Node'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 5 struct))
-new_Node'parameters :: ((Untyped.RWCtx m s)) => Std_.Int -> (Node (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Node'Parameter (Message.Mut s))))
-new_Node'parameters len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Node'parameters struct result)
-    (Std_.pure result)
-    )
-get_Node'isGeneric :: ((Untyped.ReadCtx m msg)) => (Node msg) -> (m Std_.Bool)
-get_Node'isGeneric (Node'newtype_ struct) = (GenHelpers.getWordField struct 4 32 0)
-set_Node'isGeneric :: ((Untyped.RWCtx m s)) => (Node (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Node'isGeneric (Node'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 4 32 0)
-data Node' (mut :: Message.Mutability)
-    = Node'file 
-    | Node'struct (Node'struct mut)
-    | Node'enum (Node'enum mut)
-    | Node'interface (Node'interface mut)
-    | Node'const (Node'const mut)
-    | Node'annotation (Node'annotation mut)
-    | Node'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Node' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 6)
-        case tag of
-            0 ->
-                (Std_.pure Node'file)
-            1 ->
-                (Node'struct <$> (Classes.fromStruct struct))
-            2 ->
-                (Node'enum <$> (Classes.fromStruct struct))
-            3 ->
-                (Node'interface <$> (Classes.fromStruct struct))
-            4 ->
-                (Node'const <$> (Classes.fromStruct struct))
-            5 ->
-                (Node'annotation <$> (Classes.fromStruct struct))
-            _ ->
-                (Std_.pure (Node'unknown' (Std_.fromIntegral tag)))
-        )
-get_Node' :: ((Untyped.ReadCtx m msg)
-             ,(Classes.FromStruct msg (Node' msg))) => (Node msg) -> (m (Node' msg))
-get_Node' (Node'newtype_ struct) = (Classes.fromStruct struct)
-set_Node'file :: ((Untyped.RWCtx m s)) => (Node (Message.Mut s)) -> (m ())
-set_Node'file (Node'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 1 32 0)
-    (Std_.pure ())
-    )
-set_Node'struct :: ((Untyped.RWCtx m s)
-                   ,(Classes.FromStruct (Message.Mut s) (Node'struct (Message.Mut s)))) => (Node (Message.Mut s)) -> (m (Node'struct (Message.Mut s)))
-set_Node'struct (Node'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 1 32 0)
-    (Classes.fromStruct struct)
-    )
-set_Node'enum :: ((Untyped.RWCtx m s)
-                 ,(Classes.FromStruct (Message.Mut s) (Node'enum (Message.Mut s)))) => (Node (Message.Mut s)) -> (m (Node'enum (Message.Mut s)))
-set_Node'enum (Node'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (2 :: Std_.Word16) 1 32 0)
-    (Classes.fromStruct struct)
-    )
-set_Node'interface :: ((Untyped.RWCtx m s)
-                      ,(Classes.FromStruct (Message.Mut s) (Node'interface (Message.Mut s)))) => (Node (Message.Mut s)) -> (m (Node'interface (Message.Mut s)))
-set_Node'interface (Node'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (3 :: Std_.Word16) 1 32 0)
-    (Classes.fromStruct struct)
-    )
-set_Node'const :: ((Untyped.RWCtx m s)
-                  ,(Classes.FromStruct (Message.Mut s) (Node'const (Message.Mut s)))) => (Node (Message.Mut s)) -> (m (Node'const (Message.Mut s)))
-set_Node'const (Node'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (4 :: Std_.Word16) 1 32 0)
-    (Classes.fromStruct struct)
-    )
-set_Node'annotation :: ((Untyped.RWCtx m s)
-                       ,(Classes.FromStruct (Message.Mut s) (Node'annotation (Message.Mut s)))) => (Node (Message.Mut s)) -> (m (Node'annotation (Message.Mut s)))
-set_Node'annotation (Node'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (5 :: Std_.Word16) 1 32 0)
-    (Classes.fromStruct struct)
-    )
-set_Node'unknown' :: ((Untyped.RWCtx m s)) => (Node (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Node'unknown' (Node'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 1 32 0)
-newtype Node'struct msg
-    = Node'struct'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Node'struct msg)) where
-    fromStruct struct = (Std_.pure (Node'struct'newtype_ struct))
-instance (Classes.ToStruct msg (Node'struct msg)) where
-    toStruct (Node'struct'newtype_ struct) = struct
-instance (Untyped.HasMessage (Node'struct mut) mut) where
-    message (Node'struct'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Node'struct mut) mut) where
-    messageDefault msg = (Node'struct'newtype_ <$> (Untyped.messageDefault msg))
-get_Node'struct'dataWordCount :: ((Untyped.ReadCtx m msg)) => (Node'struct msg) -> (m Std_.Word16)
-get_Node'struct'dataWordCount (Node'struct'newtype_ struct) = (GenHelpers.getWordField struct 1 48 0)
-set_Node'struct'dataWordCount :: ((Untyped.RWCtx m s)) => (Node'struct (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Node'struct'dataWordCount (Node'struct'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 1 48 0)
-get_Node'struct'pointerCount :: ((Untyped.ReadCtx m msg)) => (Node'struct msg) -> (m Std_.Word16)
-get_Node'struct'pointerCount (Node'struct'newtype_ struct) = (GenHelpers.getWordField struct 3 0 0)
-set_Node'struct'pointerCount :: ((Untyped.RWCtx m s)) => (Node'struct (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Node'struct'pointerCount (Node'struct'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 3 0 0)
-get_Node'struct'preferredListEncoding :: ((Untyped.ReadCtx m msg)) => (Node'struct msg) -> (m ElementSize)
-get_Node'struct'preferredListEncoding (Node'struct'newtype_ struct) = (GenHelpers.getWordField struct 3 16 0)
-set_Node'struct'preferredListEncoding :: ((Untyped.RWCtx m s)) => (Node'struct (Message.Mut s)) -> ElementSize -> (m ())
-set_Node'struct'preferredListEncoding (Node'struct'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 3 16 0)
-get_Node'struct'isGroup :: ((Untyped.ReadCtx m msg)) => (Node'struct msg) -> (m Std_.Bool)
-get_Node'struct'isGroup (Node'struct'newtype_ struct) = (GenHelpers.getWordField struct 3 32 0)
-set_Node'struct'isGroup :: ((Untyped.RWCtx m s)) => (Node'struct (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Node'struct'isGroup (Node'struct'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 3 32 0)
-get_Node'struct'discriminantCount :: ((Untyped.ReadCtx m msg)) => (Node'struct msg) -> (m Std_.Word16)
-get_Node'struct'discriminantCount (Node'struct'newtype_ struct) = (GenHelpers.getWordField struct 3 48 0)
-set_Node'struct'discriminantCount :: ((Untyped.RWCtx m s)) => (Node'struct (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Node'struct'discriminantCount (Node'struct'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 3 48 0)
-get_Node'struct'discriminantOffset :: ((Untyped.ReadCtx m msg)) => (Node'struct msg) -> (m Std_.Word32)
-get_Node'struct'discriminantOffset (Node'struct'newtype_ struct) = (GenHelpers.getWordField struct 4 0 0)
-set_Node'struct'discriminantOffset :: ((Untyped.RWCtx m s)) => (Node'struct (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Node'struct'discriminantOffset (Node'struct'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 4 0 0)
-get_Node'struct'fields :: ((Untyped.ReadCtx m msg)
-                          ,(Classes.FromPtr msg (Basics.List msg (Field msg)))) => (Node'struct msg) -> (m (Basics.List msg (Field msg)))
-get_Node'struct'fields (Node'struct'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 3 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Node'struct'fields :: ((Untyped.RWCtx m s)
-                          ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Field (Message.Mut s))))) => (Node'struct (Message.Mut s)) -> (Basics.List (Message.Mut s) (Field (Message.Mut s))) -> (m ())
-set_Node'struct'fields (Node'struct'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 3 struct)
-    )
-has_Node'struct'fields :: ((Untyped.ReadCtx m msg)) => (Node'struct msg) -> (m Std_.Bool)
-has_Node'struct'fields (Node'struct'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 3 struct))
-new_Node'struct'fields :: ((Untyped.RWCtx m s)) => Std_.Int -> (Node'struct (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Field (Message.Mut s))))
-new_Node'struct'fields len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Node'struct'fields struct result)
-    (Std_.pure result)
-    )
-newtype Node'enum msg
-    = Node'enum'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Node'enum msg)) where
-    fromStruct struct = (Std_.pure (Node'enum'newtype_ struct))
-instance (Classes.ToStruct msg (Node'enum msg)) where
-    toStruct (Node'enum'newtype_ struct) = struct
-instance (Untyped.HasMessage (Node'enum mut) mut) where
-    message (Node'enum'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Node'enum mut) mut) where
-    messageDefault msg = (Node'enum'newtype_ <$> (Untyped.messageDefault msg))
-get_Node'enum'enumerants :: ((Untyped.ReadCtx m msg)
-                            ,(Classes.FromPtr msg (Basics.List msg (Enumerant msg)))) => (Node'enum msg) -> (m (Basics.List msg (Enumerant msg)))
-get_Node'enum'enumerants (Node'enum'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 3 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Node'enum'enumerants :: ((Untyped.RWCtx m s)
-                            ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Enumerant (Message.Mut s))))) => (Node'enum (Message.Mut s)) -> (Basics.List (Message.Mut s) (Enumerant (Message.Mut s))) -> (m ())
-set_Node'enum'enumerants (Node'enum'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 3 struct)
-    )
-has_Node'enum'enumerants :: ((Untyped.ReadCtx m msg)) => (Node'enum msg) -> (m Std_.Bool)
-has_Node'enum'enumerants (Node'enum'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 3 struct))
-new_Node'enum'enumerants :: ((Untyped.RWCtx m s)) => Std_.Int -> (Node'enum (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Enumerant (Message.Mut s))))
-new_Node'enum'enumerants len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Node'enum'enumerants struct result)
-    (Std_.pure result)
-    )
-newtype Node'interface msg
-    = Node'interface'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Node'interface msg)) where
-    fromStruct struct = (Std_.pure (Node'interface'newtype_ struct))
-instance (Classes.ToStruct msg (Node'interface msg)) where
-    toStruct (Node'interface'newtype_ struct) = struct
-instance (Untyped.HasMessage (Node'interface mut) mut) where
-    message (Node'interface'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Node'interface mut) mut) where
-    messageDefault msg = (Node'interface'newtype_ <$> (Untyped.messageDefault msg))
-get_Node'interface'methods :: ((Untyped.ReadCtx m msg)
-                              ,(Classes.FromPtr msg (Basics.List msg (Method msg)))) => (Node'interface msg) -> (m (Basics.List msg (Method msg)))
-get_Node'interface'methods (Node'interface'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 3 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Node'interface'methods :: ((Untyped.RWCtx m s)
-                              ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Method (Message.Mut s))))) => (Node'interface (Message.Mut s)) -> (Basics.List (Message.Mut s) (Method (Message.Mut s))) -> (m ())
-set_Node'interface'methods (Node'interface'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 3 struct)
-    )
-has_Node'interface'methods :: ((Untyped.ReadCtx m msg)) => (Node'interface msg) -> (m Std_.Bool)
-has_Node'interface'methods (Node'interface'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 3 struct))
-new_Node'interface'methods :: ((Untyped.RWCtx m s)) => Std_.Int -> (Node'interface (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Method (Message.Mut s))))
-new_Node'interface'methods len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Node'interface'methods struct result)
-    (Std_.pure result)
-    )
-get_Node'interface'superclasses :: ((Untyped.ReadCtx m msg)
-                                   ,(Classes.FromPtr msg (Basics.List msg (Superclass msg)))) => (Node'interface msg) -> (m (Basics.List msg (Superclass msg)))
-get_Node'interface'superclasses (Node'interface'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 4 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Node'interface'superclasses :: ((Untyped.RWCtx m s)
-                                   ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Superclass (Message.Mut s))))) => (Node'interface (Message.Mut s)) -> (Basics.List (Message.Mut s) (Superclass (Message.Mut s))) -> (m ())
-set_Node'interface'superclasses (Node'interface'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 4 struct)
-    )
-has_Node'interface'superclasses :: ((Untyped.ReadCtx m msg)) => (Node'interface msg) -> (m Std_.Bool)
-has_Node'interface'superclasses (Node'interface'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 4 struct))
-new_Node'interface'superclasses :: ((Untyped.RWCtx m s)) => Std_.Int -> (Node'interface (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Superclass (Message.Mut s))))
-new_Node'interface'superclasses len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Node'interface'superclasses struct result)
-    (Std_.pure result)
-    )
-newtype Node'const msg
-    = Node'const'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Node'const msg)) where
-    fromStruct struct = (Std_.pure (Node'const'newtype_ struct))
-instance (Classes.ToStruct msg (Node'const msg)) where
-    toStruct (Node'const'newtype_ struct) = struct
-instance (Untyped.HasMessage (Node'const mut) mut) where
-    message (Node'const'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Node'const mut) mut) where
-    messageDefault msg = (Node'const'newtype_ <$> (Untyped.messageDefault msg))
-get_Node'const'type_ :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Type msg))) => (Node'const msg) -> (m (Type msg))
-get_Node'const'type_ (Node'const'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 3 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Node'const'type_ :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Type (Message.Mut s)))) => (Node'const (Message.Mut s)) -> (Type (Message.Mut s)) -> (m ())
-set_Node'const'type_ (Node'const'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 3 struct)
-    )
-has_Node'const'type_ :: ((Untyped.ReadCtx m msg)) => (Node'const msg) -> (m Std_.Bool)
-has_Node'const'type_ (Node'const'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 3 struct))
-new_Node'const'type_ :: ((Untyped.RWCtx m s)) => (Node'const (Message.Mut s)) -> (m (Type (Message.Mut s)))
-new_Node'const'type_ struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Node'const'type_ struct result)
-    (Std_.pure result)
-    )
-get_Node'const'value :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Value msg))) => (Node'const msg) -> (m (Value msg))
-get_Node'const'value (Node'const'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 4 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Node'const'value :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Value (Message.Mut s)))) => (Node'const (Message.Mut s)) -> (Value (Message.Mut s)) -> (m ())
-set_Node'const'value (Node'const'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 4 struct)
-    )
-has_Node'const'value :: ((Untyped.ReadCtx m msg)) => (Node'const msg) -> (m Std_.Bool)
-has_Node'const'value (Node'const'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 4 struct))
-new_Node'const'value :: ((Untyped.RWCtx m s)) => (Node'const (Message.Mut s)) -> (m (Value (Message.Mut s)))
-new_Node'const'value struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Node'const'value struct result)
-    (Std_.pure result)
-    )
-newtype Node'annotation msg
-    = Node'annotation'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Node'annotation msg)) where
-    fromStruct struct = (Std_.pure (Node'annotation'newtype_ struct))
-instance (Classes.ToStruct msg (Node'annotation msg)) where
-    toStruct (Node'annotation'newtype_ struct) = struct
-instance (Untyped.HasMessage (Node'annotation mut) mut) where
-    message (Node'annotation'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Node'annotation mut) mut) where
-    messageDefault msg = (Node'annotation'newtype_ <$> (Untyped.messageDefault msg))
-get_Node'annotation'type_ :: ((Untyped.ReadCtx m msg)
-                             ,(Classes.FromPtr msg (Type msg))) => (Node'annotation msg) -> (m (Type msg))
-get_Node'annotation'type_ (Node'annotation'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 3 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Node'annotation'type_ :: ((Untyped.RWCtx m s)
-                             ,(Classes.ToPtr s (Type (Message.Mut s)))) => (Node'annotation (Message.Mut s)) -> (Type (Message.Mut s)) -> (m ())
-set_Node'annotation'type_ (Node'annotation'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 3 struct)
-    )
-has_Node'annotation'type_ :: ((Untyped.ReadCtx m msg)) => (Node'annotation msg) -> (m Std_.Bool)
-has_Node'annotation'type_ (Node'annotation'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 3 struct))
-new_Node'annotation'type_ :: ((Untyped.RWCtx m s)) => (Node'annotation (Message.Mut s)) -> (m (Type (Message.Mut s)))
-new_Node'annotation'type_ struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Node'annotation'type_ struct result)
-    (Std_.pure result)
-    )
-get_Node'annotation'targetsFile :: ((Untyped.ReadCtx m msg)) => (Node'annotation msg) -> (m Std_.Bool)
-get_Node'annotation'targetsFile (Node'annotation'newtype_ struct) = (GenHelpers.getWordField struct 1 48 0)
-set_Node'annotation'targetsFile :: ((Untyped.RWCtx m s)) => (Node'annotation (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Node'annotation'targetsFile (Node'annotation'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 1 48 0)
-get_Node'annotation'targetsConst :: ((Untyped.ReadCtx m msg)) => (Node'annotation msg) -> (m Std_.Bool)
-get_Node'annotation'targetsConst (Node'annotation'newtype_ struct) = (GenHelpers.getWordField struct 1 49 0)
-set_Node'annotation'targetsConst :: ((Untyped.RWCtx m s)) => (Node'annotation (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Node'annotation'targetsConst (Node'annotation'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 1 49 0)
-get_Node'annotation'targetsEnum :: ((Untyped.ReadCtx m msg)) => (Node'annotation msg) -> (m Std_.Bool)
-get_Node'annotation'targetsEnum (Node'annotation'newtype_ struct) = (GenHelpers.getWordField struct 1 50 0)
-set_Node'annotation'targetsEnum :: ((Untyped.RWCtx m s)) => (Node'annotation (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Node'annotation'targetsEnum (Node'annotation'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 1 50 0)
-get_Node'annotation'targetsEnumerant :: ((Untyped.ReadCtx m msg)) => (Node'annotation msg) -> (m Std_.Bool)
-get_Node'annotation'targetsEnumerant (Node'annotation'newtype_ struct) = (GenHelpers.getWordField struct 1 51 0)
-set_Node'annotation'targetsEnumerant :: ((Untyped.RWCtx m s)) => (Node'annotation (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Node'annotation'targetsEnumerant (Node'annotation'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 1 51 0)
-get_Node'annotation'targetsStruct :: ((Untyped.ReadCtx m msg)) => (Node'annotation msg) -> (m Std_.Bool)
-get_Node'annotation'targetsStruct (Node'annotation'newtype_ struct) = (GenHelpers.getWordField struct 1 52 0)
-set_Node'annotation'targetsStruct :: ((Untyped.RWCtx m s)) => (Node'annotation (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Node'annotation'targetsStruct (Node'annotation'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 1 52 0)
-get_Node'annotation'targetsField :: ((Untyped.ReadCtx m msg)) => (Node'annotation msg) -> (m Std_.Bool)
-get_Node'annotation'targetsField (Node'annotation'newtype_ struct) = (GenHelpers.getWordField struct 1 53 0)
-set_Node'annotation'targetsField :: ((Untyped.RWCtx m s)) => (Node'annotation (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Node'annotation'targetsField (Node'annotation'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 1 53 0)
-get_Node'annotation'targetsUnion :: ((Untyped.ReadCtx m msg)) => (Node'annotation msg) -> (m Std_.Bool)
-get_Node'annotation'targetsUnion (Node'annotation'newtype_ struct) = (GenHelpers.getWordField struct 1 54 0)
-set_Node'annotation'targetsUnion :: ((Untyped.RWCtx m s)) => (Node'annotation (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Node'annotation'targetsUnion (Node'annotation'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 1 54 0)
-get_Node'annotation'targetsGroup :: ((Untyped.ReadCtx m msg)) => (Node'annotation msg) -> (m Std_.Bool)
-get_Node'annotation'targetsGroup (Node'annotation'newtype_ struct) = (GenHelpers.getWordField struct 1 55 0)
-set_Node'annotation'targetsGroup :: ((Untyped.RWCtx m s)) => (Node'annotation (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Node'annotation'targetsGroup (Node'annotation'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 1 55 0)
-get_Node'annotation'targetsInterface :: ((Untyped.ReadCtx m msg)) => (Node'annotation msg) -> (m Std_.Bool)
-get_Node'annotation'targetsInterface (Node'annotation'newtype_ struct) = (GenHelpers.getWordField struct 1 56 0)
-set_Node'annotation'targetsInterface :: ((Untyped.RWCtx m s)) => (Node'annotation (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Node'annotation'targetsInterface (Node'annotation'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 1 56 0)
-get_Node'annotation'targetsMethod :: ((Untyped.ReadCtx m msg)) => (Node'annotation msg) -> (m Std_.Bool)
-get_Node'annotation'targetsMethod (Node'annotation'newtype_ struct) = (GenHelpers.getWordField struct 1 57 0)
-set_Node'annotation'targetsMethod :: ((Untyped.RWCtx m s)) => (Node'annotation (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Node'annotation'targetsMethod (Node'annotation'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 1 57 0)
-get_Node'annotation'targetsParam :: ((Untyped.ReadCtx m msg)) => (Node'annotation msg) -> (m Std_.Bool)
-get_Node'annotation'targetsParam (Node'annotation'newtype_ struct) = (GenHelpers.getWordField struct 1 58 0)
-set_Node'annotation'targetsParam :: ((Untyped.RWCtx m s)) => (Node'annotation (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Node'annotation'targetsParam (Node'annotation'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 1 58 0)
-get_Node'annotation'targetsAnnotation :: ((Untyped.ReadCtx m msg)) => (Node'annotation msg) -> (m Std_.Bool)
-get_Node'annotation'targetsAnnotation (Node'annotation'newtype_ struct) = (GenHelpers.getWordField struct 1 59 0)
-set_Node'annotation'targetsAnnotation :: ((Untyped.RWCtx m s)) => (Node'annotation (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Node'annotation'targetsAnnotation (Node'annotation'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 1 59 0)
-newtype Node'Parameter msg
-    = Node'Parameter'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Node'Parameter msg)) where
-    fromStruct struct = (Std_.pure (Node'Parameter'newtype_ struct))
-instance (Classes.ToStruct msg (Node'Parameter msg)) where
-    toStruct (Node'Parameter'newtype_ struct) = struct
-instance (Untyped.HasMessage (Node'Parameter mut) mut) where
-    message (Node'Parameter'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Node'Parameter mut) mut) where
-    messageDefault msg = (Node'Parameter'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Node'Parameter msg)) where
-    fromPtr msg ptr = (Node'Parameter'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Node'Parameter (Message.Mut s))) where
-    toPtr msg (Node'Parameter'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Node'Parameter (Message.Mut s))) where
-    new msg = (Node'Parameter'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Node'Parameter mut)) where
-    newtype List mut (Node'Parameter mut)
-        = Node'Parameter'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Node'Parameter'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Node'Parameter'List_ l) = (Untyped.ListStruct l)
-    length (Node'Parameter'List_ l) = (Untyped.length l)
-    index i (Node'Parameter'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Node'Parameter (Message.Mut s))) where
-    setIndex (Node'Parameter'newtype_ elt) i (Node'Parameter'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Node'Parameter'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Node'Parameter'name :: ((Untyped.ReadCtx m msg)
-                           ,(Classes.FromPtr msg (Basics.Text msg))) => (Node'Parameter msg) -> (m (Basics.Text msg))
-get_Node'Parameter'name (Node'Parameter'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Node'Parameter'name :: ((Untyped.RWCtx m s)
-                           ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Node'Parameter (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Node'Parameter'name (Node'Parameter'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Node'Parameter'name :: ((Untyped.ReadCtx m msg)) => (Node'Parameter msg) -> (m Std_.Bool)
-has_Node'Parameter'name (Node'Parameter'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Node'Parameter'name :: ((Untyped.RWCtx m s)) => Std_.Int -> (Node'Parameter (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Node'Parameter'name len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Node'Parameter'name struct result)
-    (Std_.pure result)
-    )
-newtype Node'NestedNode msg
-    = Node'NestedNode'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Node'NestedNode msg)) where
-    fromStruct struct = (Std_.pure (Node'NestedNode'newtype_ struct))
-instance (Classes.ToStruct msg (Node'NestedNode msg)) where
-    toStruct (Node'NestedNode'newtype_ struct) = struct
-instance (Untyped.HasMessage (Node'NestedNode mut) mut) where
-    message (Node'NestedNode'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Node'NestedNode mut) mut) where
-    messageDefault msg = (Node'NestedNode'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Node'NestedNode msg)) where
-    fromPtr msg ptr = (Node'NestedNode'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Node'NestedNode (Message.Mut s))) where
-    toPtr msg (Node'NestedNode'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Node'NestedNode (Message.Mut s))) where
-    new msg = (Node'NestedNode'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (Node'NestedNode mut)) where
-    newtype List mut (Node'NestedNode mut)
-        = Node'NestedNode'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Node'NestedNode'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Node'NestedNode'List_ l) = (Untyped.ListStruct l)
-    length (Node'NestedNode'List_ l) = (Untyped.length l)
-    index i (Node'NestedNode'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Node'NestedNode (Message.Mut s))) where
-    setIndex (Node'NestedNode'newtype_ elt) i (Node'NestedNode'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Node'NestedNode'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-get_Node'NestedNode'name :: ((Untyped.ReadCtx m msg)
-                            ,(Classes.FromPtr msg (Basics.Text msg))) => (Node'NestedNode msg) -> (m (Basics.Text msg))
-get_Node'NestedNode'name (Node'NestedNode'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Node'NestedNode'name :: ((Untyped.RWCtx m s)
-                            ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Node'NestedNode (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Node'NestedNode'name (Node'NestedNode'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Node'NestedNode'name :: ((Untyped.ReadCtx m msg)) => (Node'NestedNode msg) -> (m Std_.Bool)
-has_Node'NestedNode'name (Node'NestedNode'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Node'NestedNode'name :: ((Untyped.RWCtx m s)) => Std_.Int -> (Node'NestedNode (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Node'NestedNode'name len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Node'NestedNode'name struct result)
-    (Std_.pure result)
-    )
-get_Node'NestedNode'id :: ((Untyped.ReadCtx m msg)) => (Node'NestedNode msg) -> (m Std_.Word64)
-get_Node'NestedNode'id (Node'NestedNode'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Node'NestedNode'id :: ((Untyped.RWCtx m s)) => (Node'NestedNode (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Node'NestedNode'id (Node'NestedNode'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 0 0 0)
-newtype Node'SourceInfo msg
-    = Node'SourceInfo'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Node'SourceInfo msg)) where
-    fromStruct struct = (Std_.pure (Node'SourceInfo'newtype_ struct))
-instance (Classes.ToStruct msg (Node'SourceInfo msg)) where
-    toStruct (Node'SourceInfo'newtype_ struct) = struct
-instance (Untyped.HasMessage (Node'SourceInfo mut) mut) where
-    message (Node'SourceInfo'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Node'SourceInfo mut) mut) where
-    messageDefault msg = (Node'SourceInfo'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Node'SourceInfo msg)) where
-    fromPtr msg ptr = (Node'SourceInfo'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Node'SourceInfo (Message.Mut s))) where
-    toPtr msg (Node'SourceInfo'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Node'SourceInfo (Message.Mut s))) where
-    new msg = (Node'SourceInfo'newtype_ <$> (Untyped.allocStruct msg 1 2))
-instance (Basics.ListElem mut (Node'SourceInfo mut)) where
-    newtype List mut (Node'SourceInfo mut)
-        = Node'SourceInfo'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Node'SourceInfo'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Node'SourceInfo'List_ l) = (Untyped.ListStruct l)
-    length (Node'SourceInfo'List_ l) = (Untyped.length l)
-    index i (Node'SourceInfo'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Node'SourceInfo (Message.Mut s))) where
-    setIndex (Node'SourceInfo'newtype_ elt) i (Node'SourceInfo'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Node'SourceInfo'List_ <$> (Untyped.allocCompositeList msg 1 2 len))
-get_Node'SourceInfo'id :: ((Untyped.ReadCtx m msg)) => (Node'SourceInfo msg) -> (m Std_.Word64)
-get_Node'SourceInfo'id (Node'SourceInfo'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Node'SourceInfo'id :: ((Untyped.RWCtx m s)) => (Node'SourceInfo (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Node'SourceInfo'id (Node'SourceInfo'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 0 0 0)
-get_Node'SourceInfo'docComment :: ((Untyped.ReadCtx m msg)
-                                  ,(Classes.FromPtr msg (Basics.Text msg))) => (Node'SourceInfo msg) -> (m (Basics.Text msg))
-get_Node'SourceInfo'docComment (Node'SourceInfo'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Node'SourceInfo'docComment :: ((Untyped.RWCtx m s)
-                                  ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Node'SourceInfo (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Node'SourceInfo'docComment (Node'SourceInfo'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Node'SourceInfo'docComment :: ((Untyped.ReadCtx m msg)) => (Node'SourceInfo msg) -> (m Std_.Bool)
-has_Node'SourceInfo'docComment (Node'SourceInfo'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Node'SourceInfo'docComment :: ((Untyped.RWCtx m s)) => Std_.Int -> (Node'SourceInfo (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Node'SourceInfo'docComment len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Node'SourceInfo'docComment struct result)
-    (Std_.pure result)
-    )
-get_Node'SourceInfo'members :: ((Untyped.ReadCtx m msg)
-                               ,(Classes.FromPtr msg (Basics.List msg (Node'SourceInfo'Member msg)))) => (Node'SourceInfo msg) -> (m (Basics.List msg (Node'SourceInfo'Member msg)))
-get_Node'SourceInfo'members (Node'SourceInfo'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Node'SourceInfo'members :: ((Untyped.RWCtx m s)
-                               ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Node'SourceInfo'Member (Message.Mut s))))) => (Node'SourceInfo (Message.Mut s)) -> (Basics.List (Message.Mut s) (Node'SourceInfo'Member (Message.Mut s))) -> (m ())
-set_Node'SourceInfo'members (Node'SourceInfo'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Node'SourceInfo'members :: ((Untyped.ReadCtx m msg)) => (Node'SourceInfo msg) -> (m Std_.Bool)
-has_Node'SourceInfo'members (Node'SourceInfo'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_Node'SourceInfo'members :: ((Untyped.RWCtx m s)) => Std_.Int -> (Node'SourceInfo (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Node'SourceInfo'Member (Message.Mut s))))
-new_Node'SourceInfo'members len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Node'SourceInfo'members struct result)
-    (Std_.pure result)
-    )
-newtype Node'SourceInfo'Member msg
-    = Node'SourceInfo'Member'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Node'SourceInfo'Member msg)) where
-    fromStruct struct = (Std_.pure (Node'SourceInfo'Member'newtype_ struct))
-instance (Classes.ToStruct msg (Node'SourceInfo'Member msg)) where
-    toStruct (Node'SourceInfo'Member'newtype_ struct) = struct
-instance (Untyped.HasMessage (Node'SourceInfo'Member mut) mut) where
-    message (Node'SourceInfo'Member'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Node'SourceInfo'Member mut) mut) where
-    messageDefault msg = (Node'SourceInfo'Member'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Node'SourceInfo'Member msg)) where
-    fromPtr msg ptr = (Node'SourceInfo'Member'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Node'SourceInfo'Member (Message.Mut s))) where
-    toPtr msg (Node'SourceInfo'Member'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Node'SourceInfo'Member (Message.Mut s))) where
-    new msg = (Node'SourceInfo'Member'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Node'SourceInfo'Member mut)) where
-    newtype List mut (Node'SourceInfo'Member mut)
-        = Node'SourceInfo'Member'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Node'SourceInfo'Member'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Node'SourceInfo'Member'List_ l) = (Untyped.ListStruct l)
-    length (Node'SourceInfo'Member'List_ l) = (Untyped.length l)
-    index i (Node'SourceInfo'Member'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Node'SourceInfo'Member (Message.Mut s))) where
-    setIndex (Node'SourceInfo'Member'newtype_ elt) i (Node'SourceInfo'Member'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Node'SourceInfo'Member'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Node'SourceInfo'Member'docComment :: ((Untyped.ReadCtx m msg)
-                                         ,(Classes.FromPtr msg (Basics.Text msg))) => (Node'SourceInfo'Member msg) -> (m (Basics.Text msg))
-get_Node'SourceInfo'Member'docComment (Node'SourceInfo'Member'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Node'SourceInfo'Member'docComment :: ((Untyped.RWCtx m s)
-                                         ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Node'SourceInfo'Member (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Node'SourceInfo'Member'docComment (Node'SourceInfo'Member'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Node'SourceInfo'Member'docComment :: ((Untyped.ReadCtx m msg)) => (Node'SourceInfo'Member msg) -> (m Std_.Bool)
-has_Node'SourceInfo'Member'docComment (Node'SourceInfo'Member'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Node'SourceInfo'Member'docComment :: ((Untyped.RWCtx m s)) => Std_.Int -> (Node'SourceInfo'Member (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Node'SourceInfo'Member'docComment len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Node'SourceInfo'Member'docComment struct result)
-    (Std_.pure result)
-    )
-newtype Field msg
-    = Field'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Field msg)) where
-    fromStruct struct = (Std_.pure (Field'newtype_ struct))
-instance (Classes.ToStruct msg (Field msg)) where
-    toStruct (Field'newtype_ struct) = struct
-instance (Untyped.HasMessage (Field mut) mut) where
-    message (Field'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Field mut) mut) where
-    messageDefault msg = (Field'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Field msg)) where
-    fromPtr msg ptr = (Field'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Field (Message.Mut s))) where
-    toPtr msg (Field'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Field (Message.Mut s))) where
-    new msg = (Field'newtype_ <$> (Untyped.allocStruct msg 3 4))
-instance (Basics.ListElem mut (Field mut)) where
-    newtype List mut (Field mut)
-        = Field'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Field'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Field'List_ l) = (Untyped.ListStruct l)
-    length (Field'List_ l) = (Untyped.length l)
-    index i (Field'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Field (Message.Mut s))) where
-    setIndex (Field'newtype_ elt) i (Field'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Field'List_ <$> (Untyped.allocCompositeList msg 3 4 len))
-get_Field'name :: ((Untyped.ReadCtx m msg)
-                  ,(Classes.FromPtr msg (Basics.Text msg))) => (Field msg) -> (m (Basics.Text msg))
-get_Field'name (Field'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Field'name :: ((Untyped.RWCtx m s)
-                  ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Field (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Field'name (Field'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Field'name :: ((Untyped.ReadCtx m msg)) => (Field msg) -> (m Std_.Bool)
-has_Field'name (Field'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Field'name :: ((Untyped.RWCtx m s)) => Std_.Int -> (Field (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Field'name len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Field'name struct result)
-    (Std_.pure result)
-    )
-get_Field'codeOrder :: ((Untyped.ReadCtx m msg)) => (Field msg) -> (m Std_.Word16)
-get_Field'codeOrder (Field'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Field'codeOrder :: ((Untyped.RWCtx m s)) => (Field (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Field'codeOrder (Field'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-get_Field'annotations :: ((Untyped.ReadCtx m msg)
-                         ,(Classes.FromPtr msg (Basics.List msg (Annotation msg)))) => (Field msg) -> (m (Basics.List msg (Annotation msg)))
-get_Field'annotations (Field'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Field'annotations :: ((Untyped.RWCtx m s)
-                         ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Annotation (Message.Mut s))))) => (Field (Message.Mut s)) -> (Basics.List (Message.Mut s) (Annotation (Message.Mut s))) -> (m ())
-set_Field'annotations (Field'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Field'annotations :: ((Untyped.ReadCtx m msg)) => (Field msg) -> (m Std_.Bool)
-has_Field'annotations (Field'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_Field'annotations :: ((Untyped.RWCtx m s)) => Std_.Int -> (Field (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Annotation (Message.Mut s))))
-new_Field'annotations len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Field'annotations struct result)
-    (Std_.pure result)
-    )
-get_Field'discriminantValue :: ((Untyped.ReadCtx m msg)) => (Field msg) -> (m Std_.Word16)
-get_Field'discriminantValue (Field'newtype_ struct) = (GenHelpers.getWordField struct 0 16 65535)
-set_Field'discriminantValue :: ((Untyped.RWCtx m s)) => (Field (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Field'discriminantValue (Field'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 16 65535)
-get_Field'ordinal :: ((Untyped.ReadCtx m msg)
-                     ,(Classes.FromStruct msg (Field'ordinal msg))) => (Field msg) -> (m (Field'ordinal msg))
-get_Field'ordinal (Field'newtype_ struct) = (Classes.fromStruct struct)
-data Field' (mut :: Message.Mutability)
-    = Field'slot (Field'slot mut)
-    | Field'group (Field'group mut)
-    | Field'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Field' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 4)
-        case tag of
-            0 ->
-                (Field'slot <$> (Classes.fromStruct struct))
-            1 ->
-                (Field'group <$> (Classes.fromStruct struct))
-            _ ->
-                (Std_.pure (Field'unknown' (Std_.fromIntegral tag)))
-        )
-get_Field' :: ((Untyped.ReadCtx m msg)
-              ,(Classes.FromStruct msg (Field' msg))) => (Field msg) -> (m (Field' msg))
-get_Field' (Field'newtype_ struct) = (Classes.fromStruct struct)
-set_Field'slot :: ((Untyped.RWCtx m s)
-                  ,(Classes.FromStruct (Message.Mut s) (Field'slot (Message.Mut s)))) => (Field (Message.Mut s)) -> (m (Field'slot (Message.Mut s)))
-set_Field'slot (Field'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 1 0 0)
-    (Classes.fromStruct struct)
-    )
-set_Field'group :: ((Untyped.RWCtx m s)
-                   ,(Classes.FromStruct (Message.Mut s) (Field'group (Message.Mut s)))) => (Field (Message.Mut s)) -> (m (Field'group (Message.Mut s)))
-set_Field'group (Field'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 1 0 0)
-    (Classes.fromStruct struct)
-    )
-set_Field'unknown' :: ((Untyped.RWCtx m s)) => (Field (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Field'unknown' (Field'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 1 0 0)
-newtype Field'slot msg
-    = Field'slot'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Field'slot msg)) where
-    fromStruct struct = (Std_.pure (Field'slot'newtype_ struct))
-instance (Classes.ToStruct msg (Field'slot msg)) where
-    toStruct (Field'slot'newtype_ struct) = struct
-instance (Untyped.HasMessage (Field'slot mut) mut) where
-    message (Field'slot'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Field'slot mut) mut) where
-    messageDefault msg = (Field'slot'newtype_ <$> (Untyped.messageDefault msg))
-get_Field'slot'offset :: ((Untyped.ReadCtx m msg)) => (Field'slot msg) -> (m Std_.Word32)
-get_Field'slot'offset (Field'slot'newtype_ struct) = (GenHelpers.getWordField struct 0 32 0)
-set_Field'slot'offset :: ((Untyped.RWCtx m s)) => (Field'slot (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Field'slot'offset (Field'slot'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 32 0)
-get_Field'slot'type_ :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Type msg))) => (Field'slot msg) -> (m (Type msg))
-get_Field'slot'type_ (Field'slot'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 2 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Field'slot'type_ :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Type (Message.Mut s)))) => (Field'slot (Message.Mut s)) -> (Type (Message.Mut s)) -> (m ())
-set_Field'slot'type_ (Field'slot'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 2 struct)
-    )
-has_Field'slot'type_ :: ((Untyped.ReadCtx m msg)) => (Field'slot msg) -> (m Std_.Bool)
-has_Field'slot'type_ (Field'slot'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 2 struct))
-new_Field'slot'type_ :: ((Untyped.RWCtx m s)) => (Field'slot (Message.Mut s)) -> (m (Type (Message.Mut s)))
-new_Field'slot'type_ struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Field'slot'type_ struct result)
-    (Std_.pure result)
-    )
-get_Field'slot'defaultValue :: ((Untyped.ReadCtx m msg)
-                               ,(Classes.FromPtr msg (Value msg))) => (Field'slot msg) -> (m (Value msg))
-get_Field'slot'defaultValue (Field'slot'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 3 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Field'slot'defaultValue :: ((Untyped.RWCtx m s)
-                               ,(Classes.ToPtr s (Value (Message.Mut s)))) => (Field'slot (Message.Mut s)) -> (Value (Message.Mut s)) -> (m ())
-set_Field'slot'defaultValue (Field'slot'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 3 struct)
-    )
-has_Field'slot'defaultValue :: ((Untyped.ReadCtx m msg)) => (Field'slot msg) -> (m Std_.Bool)
-has_Field'slot'defaultValue (Field'slot'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 3 struct))
-new_Field'slot'defaultValue :: ((Untyped.RWCtx m s)) => (Field'slot (Message.Mut s)) -> (m (Value (Message.Mut s)))
-new_Field'slot'defaultValue struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Field'slot'defaultValue struct result)
-    (Std_.pure result)
-    )
-get_Field'slot'hadExplicitDefault :: ((Untyped.ReadCtx m msg)) => (Field'slot msg) -> (m Std_.Bool)
-get_Field'slot'hadExplicitDefault (Field'slot'newtype_ struct) = (GenHelpers.getWordField struct 2 0 0)
-set_Field'slot'hadExplicitDefault :: ((Untyped.RWCtx m s)) => (Field'slot (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Field'slot'hadExplicitDefault (Field'slot'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 2 0 0)
-newtype Field'group msg
-    = Field'group'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Field'group msg)) where
-    fromStruct struct = (Std_.pure (Field'group'newtype_ struct))
-instance (Classes.ToStruct msg (Field'group msg)) where
-    toStruct (Field'group'newtype_ struct) = struct
-instance (Untyped.HasMessage (Field'group mut) mut) where
-    message (Field'group'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Field'group mut) mut) where
-    messageDefault msg = (Field'group'newtype_ <$> (Untyped.messageDefault msg))
-get_Field'group'typeId :: ((Untyped.ReadCtx m msg)) => (Field'group msg) -> (m Std_.Word64)
-get_Field'group'typeId (Field'group'newtype_ struct) = (GenHelpers.getWordField struct 2 0 0)
-set_Field'group'typeId :: ((Untyped.RWCtx m s)) => (Field'group (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Field'group'typeId (Field'group'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 2 0 0)
-newtype Field'ordinal msg
-    = Field'ordinal'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Field'ordinal msg)) where
-    fromStruct struct = (Std_.pure (Field'ordinal'newtype_ struct))
-instance (Classes.ToStruct msg (Field'ordinal msg)) where
-    toStruct (Field'ordinal'newtype_ struct) = struct
-instance (Untyped.HasMessage (Field'ordinal mut) mut) where
-    message (Field'ordinal'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Field'ordinal mut) mut) where
-    messageDefault msg = (Field'ordinal'newtype_ <$> (Untyped.messageDefault msg))
-data Field'ordinal' (mut :: Message.Mutability)
-    = Field'ordinal'implicit 
-    | Field'ordinal'explicit Std_.Word16
-    | Field'ordinal'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Field'ordinal' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 5)
-        case tag of
-            0 ->
-                (Std_.pure Field'ordinal'implicit)
-            1 ->
-                (Field'ordinal'explicit <$> (GenHelpers.getWordField struct 1 32 0))
-            _ ->
-                (Std_.pure (Field'ordinal'unknown' (Std_.fromIntegral tag)))
-        )
-get_Field'ordinal' :: ((Untyped.ReadCtx m msg)
-                      ,(Classes.FromStruct msg (Field'ordinal' msg))) => (Field'ordinal msg) -> (m (Field'ordinal' msg))
-get_Field'ordinal' (Field'ordinal'newtype_ struct) = (Classes.fromStruct struct)
-set_Field'ordinal'implicit :: ((Untyped.RWCtx m s)) => (Field'ordinal (Message.Mut s)) -> (m ())
-set_Field'ordinal'implicit (Field'ordinal'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 1 16 0)
-    (Std_.pure ())
-    )
-set_Field'ordinal'explicit :: ((Untyped.RWCtx m s)) => (Field'ordinal (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Field'ordinal'explicit (Field'ordinal'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 1 16 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 1 32 0)
-    )
-set_Field'ordinal'unknown' :: ((Untyped.RWCtx m s)) => (Field'ordinal (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Field'ordinal'unknown' (Field'ordinal'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 1 16 0)
-field'noDiscriminant :: Std_.Word16
-field'noDiscriminant  = (Classes.fromWord 65535)
-newtype Enumerant msg
-    = Enumerant'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Enumerant msg)) where
-    fromStruct struct = (Std_.pure (Enumerant'newtype_ struct))
-instance (Classes.ToStruct msg (Enumerant msg)) where
-    toStruct (Enumerant'newtype_ struct) = struct
-instance (Untyped.HasMessage (Enumerant mut) mut) where
-    message (Enumerant'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Enumerant mut) mut) where
-    messageDefault msg = (Enumerant'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Enumerant msg)) where
-    fromPtr msg ptr = (Enumerant'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Enumerant (Message.Mut s))) where
-    toPtr msg (Enumerant'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Enumerant (Message.Mut s))) where
-    new msg = (Enumerant'newtype_ <$> (Untyped.allocStruct msg 1 2))
-instance (Basics.ListElem mut (Enumerant mut)) where
-    newtype List mut (Enumerant mut)
-        = Enumerant'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Enumerant'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Enumerant'List_ l) = (Untyped.ListStruct l)
-    length (Enumerant'List_ l) = (Untyped.length l)
-    index i (Enumerant'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Enumerant (Message.Mut s))) where
-    setIndex (Enumerant'newtype_ elt) i (Enumerant'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Enumerant'List_ <$> (Untyped.allocCompositeList msg 1 2 len))
-get_Enumerant'name :: ((Untyped.ReadCtx m msg)
-                      ,(Classes.FromPtr msg (Basics.Text msg))) => (Enumerant msg) -> (m (Basics.Text msg))
-get_Enumerant'name (Enumerant'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Enumerant'name :: ((Untyped.RWCtx m s)
-                      ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Enumerant (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Enumerant'name (Enumerant'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Enumerant'name :: ((Untyped.ReadCtx m msg)) => (Enumerant msg) -> (m Std_.Bool)
-has_Enumerant'name (Enumerant'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Enumerant'name :: ((Untyped.RWCtx m s)) => Std_.Int -> (Enumerant (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Enumerant'name len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Enumerant'name struct result)
-    (Std_.pure result)
-    )
-get_Enumerant'codeOrder :: ((Untyped.ReadCtx m msg)) => (Enumerant msg) -> (m Std_.Word16)
-get_Enumerant'codeOrder (Enumerant'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Enumerant'codeOrder :: ((Untyped.RWCtx m s)) => (Enumerant (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Enumerant'codeOrder (Enumerant'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-get_Enumerant'annotations :: ((Untyped.ReadCtx m msg)
-                             ,(Classes.FromPtr msg (Basics.List msg (Annotation msg)))) => (Enumerant msg) -> (m (Basics.List msg (Annotation msg)))
-get_Enumerant'annotations (Enumerant'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Enumerant'annotations :: ((Untyped.RWCtx m s)
-                             ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Annotation (Message.Mut s))))) => (Enumerant (Message.Mut s)) -> (Basics.List (Message.Mut s) (Annotation (Message.Mut s))) -> (m ())
-set_Enumerant'annotations (Enumerant'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Enumerant'annotations :: ((Untyped.ReadCtx m msg)) => (Enumerant msg) -> (m Std_.Bool)
-has_Enumerant'annotations (Enumerant'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_Enumerant'annotations :: ((Untyped.RWCtx m s)) => Std_.Int -> (Enumerant (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Annotation (Message.Mut s))))
-new_Enumerant'annotations len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Enumerant'annotations struct result)
-    (Std_.pure result)
-    )
-newtype Superclass msg
-    = Superclass'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Superclass msg)) where
-    fromStruct struct = (Std_.pure (Superclass'newtype_ struct))
-instance (Classes.ToStruct msg (Superclass msg)) where
-    toStruct (Superclass'newtype_ struct) = struct
-instance (Untyped.HasMessage (Superclass mut) mut) where
-    message (Superclass'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Superclass mut) mut) where
-    messageDefault msg = (Superclass'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Superclass msg)) where
-    fromPtr msg ptr = (Superclass'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Superclass (Message.Mut s))) where
-    toPtr msg (Superclass'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Superclass (Message.Mut s))) where
-    new msg = (Superclass'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (Superclass mut)) where
-    newtype List mut (Superclass mut)
-        = Superclass'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Superclass'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Superclass'List_ l) = (Untyped.ListStruct l)
-    length (Superclass'List_ l) = (Untyped.length l)
-    index i (Superclass'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Superclass (Message.Mut s))) where
-    setIndex (Superclass'newtype_ elt) i (Superclass'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Superclass'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-get_Superclass'id :: ((Untyped.ReadCtx m msg)) => (Superclass msg) -> (m Std_.Word64)
-get_Superclass'id (Superclass'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Superclass'id :: ((Untyped.RWCtx m s)) => (Superclass (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Superclass'id (Superclass'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 0 0 0)
-get_Superclass'brand :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Brand msg))) => (Superclass msg) -> (m (Brand msg))
-get_Superclass'brand (Superclass'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Superclass'brand :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Brand (Message.Mut s)))) => (Superclass (Message.Mut s)) -> (Brand (Message.Mut s)) -> (m ())
-set_Superclass'brand (Superclass'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Superclass'brand :: ((Untyped.ReadCtx m msg)) => (Superclass msg) -> (m Std_.Bool)
-has_Superclass'brand (Superclass'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Superclass'brand :: ((Untyped.RWCtx m s)) => (Superclass (Message.Mut s)) -> (m (Brand (Message.Mut s)))
-new_Superclass'brand struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Superclass'brand struct result)
-    (Std_.pure result)
-    )
-newtype Method msg
-    = Method'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Method msg)) where
-    fromStruct struct = (Std_.pure (Method'newtype_ struct))
-instance (Classes.ToStruct msg (Method msg)) where
-    toStruct (Method'newtype_ struct) = struct
-instance (Untyped.HasMessage (Method mut) mut) where
-    message (Method'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Method mut) mut) where
-    messageDefault msg = (Method'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Method msg)) where
-    fromPtr msg ptr = (Method'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Method (Message.Mut s))) where
-    toPtr msg (Method'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Method (Message.Mut s))) where
-    new msg = (Method'newtype_ <$> (Untyped.allocStruct msg 3 5))
-instance (Basics.ListElem mut (Method mut)) where
-    newtype List mut (Method mut)
-        = Method'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Method'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Method'List_ l) = (Untyped.ListStruct l)
-    length (Method'List_ l) = (Untyped.length l)
-    index i (Method'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Method (Message.Mut s))) where
-    setIndex (Method'newtype_ elt) i (Method'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Method'List_ <$> (Untyped.allocCompositeList msg 3 5 len))
-get_Method'name :: ((Untyped.ReadCtx m msg)
-                   ,(Classes.FromPtr msg (Basics.Text msg))) => (Method msg) -> (m (Basics.Text msg))
-get_Method'name (Method'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Method'name :: ((Untyped.RWCtx m s)
-                   ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Method (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Method'name (Method'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Method'name :: ((Untyped.ReadCtx m msg)) => (Method msg) -> (m Std_.Bool)
-has_Method'name (Method'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Method'name :: ((Untyped.RWCtx m s)) => Std_.Int -> (Method (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Method'name len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Method'name struct result)
-    (Std_.pure result)
-    )
-get_Method'codeOrder :: ((Untyped.ReadCtx m msg)) => (Method msg) -> (m Std_.Word16)
-get_Method'codeOrder (Method'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Method'codeOrder :: ((Untyped.RWCtx m s)) => (Method (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Method'codeOrder (Method'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-get_Method'paramStructType :: ((Untyped.ReadCtx m msg)) => (Method msg) -> (m Std_.Word64)
-get_Method'paramStructType (Method'newtype_ struct) = (GenHelpers.getWordField struct 1 0 0)
-set_Method'paramStructType :: ((Untyped.RWCtx m s)) => (Method (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Method'paramStructType (Method'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-get_Method'resultStructType :: ((Untyped.ReadCtx m msg)) => (Method msg) -> (m Std_.Word64)
-get_Method'resultStructType (Method'newtype_ struct) = (GenHelpers.getWordField struct 2 0 0)
-set_Method'resultStructType :: ((Untyped.RWCtx m s)) => (Method (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Method'resultStructType (Method'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 2 0 0)
-get_Method'annotations :: ((Untyped.ReadCtx m msg)
-                          ,(Classes.FromPtr msg (Basics.List msg (Annotation msg)))) => (Method msg) -> (m (Basics.List msg (Annotation msg)))
-get_Method'annotations (Method'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Method'annotations :: ((Untyped.RWCtx m s)
-                          ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Annotation (Message.Mut s))))) => (Method (Message.Mut s)) -> (Basics.List (Message.Mut s) (Annotation (Message.Mut s))) -> (m ())
-set_Method'annotations (Method'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Method'annotations :: ((Untyped.ReadCtx m msg)) => (Method msg) -> (m Std_.Bool)
-has_Method'annotations (Method'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_Method'annotations :: ((Untyped.RWCtx m s)) => Std_.Int -> (Method (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Annotation (Message.Mut s))))
-new_Method'annotations len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Method'annotations struct result)
-    (Std_.pure result)
-    )
-get_Method'paramBrand :: ((Untyped.ReadCtx m msg)
-                         ,(Classes.FromPtr msg (Brand msg))) => (Method msg) -> (m (Brand msg))
-get_Method'paramBrand (Method'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 2 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Method'paramBrand :: ((Untyped.RWCtx m s)
-                         ,(Classes.ToPtr s (Brand (Message.Mut s)))) => (Method (Message.Mut s)) -> (Brand (Message.Mut s)) -> (m ())
-set_Method'paramBrand (Method'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 2 struct)
-    )
-has_Method'paramBrand :: ((Untyped.ReadCtx m msg)) => (Method msg) -> (m Std_.Bool)
-has_Method'paramBrand (Method'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 2 struct))
-new_Method'paramBrand :: ((Untyped.RWCtx m s)) => (Method (Message.Mut s)) -> (m (Brand (Message.Mut s)))
-new_Method'paramBrand struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Method'paramBrand struct result)
-    (Std_.pure result)
-    )
-get_Method'resultBrand :: ((Untyped.ReadCtx m msg)
-                          ,(Classes.FromPtr msg (Brand msg))) => (Method msg) -> (m (Brand msg))
-get_Method'resultBrand (Method'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 3 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Method'resultBrand :: ((Untyped.RWCtx m s)
-                          ,(Classes.ToPtr s (Brand (Message.Mut s)))) => (Method (Message.Mut s)) -> (Brand (Message.Mut s)) -> (m ())
-set_Method'resultBrand (Method'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 3 struct)
-    )
-has_Method'resultBrand :: ((Untyped.ReadCtx m msg)) => (Method msg) -> (m Std_.Bool)
-has_Method'resultBrand (Method'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 3 struct))
-new_Method'resultBrand :: ((Untyped.RWCtx m s)) => (Method (Message.Mut s)) -> (m (Brand (Message.Mut s)))
-new_Method'resultBrand struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Method'resultBrand struct result)
-    (Std_.pure result)
-    )
-get_Method'implicitParameters :: ((Untyped.ReadCtx m msg)
-                                 ,(Classes.FromPtr msg (Basics.List msg (Node'Parameter msg)))) => (Method msg) -> (m (Basics.List msg (Node'Parameter msg)))
-get_Method'implicitParameters (Method'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 4 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Method'implicitParameters :: ((Untyped.RWCtx m s)
-                                 ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Node'Parameter (Message.Mut s))))) => (Method (Message.Mut s)) -> (Basics.List (Message.Mut s) (Node'Parameter (Message.Mut s))) -> (m ())
-set_Method'implicitParameters (Method'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 4 struct)
-    )
-has_Method'implicitParameters :: ((Untyped.ReadCtx m msg)) => (Method msg) -> (m Std_.Bool)
-has_Method'implicitParameters (Method'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 4 struct))
-new_Method'implicitParameters :: ((Untyped.RWCtx m s)) => Std_.Int -> (Method (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Node'Parameter (Message.Mut s))))
-new_Method'implicitParameters len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Method'implicitParameters struct result)
-    (Std_.pure result)
-    )
-newtype Type msg
-    = Type'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Type msg)) where
-    fromStruct struct = (Std_.pure (Type'newtype_ struct))
-instance (Classes.ToStruct msg (Type msg)) where
-    toStruct (Type'newtype_ struct) = struct
-instance (Untyped.HasMessage (Type mut) mut) where
-    message (Type'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Type mut) mut) where
-    messageDefault msg = (Type'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Type msg)) where
-    fromPtr msg ptr = (Type'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Type (Message.Mut s))) where
-    toPtr msg (Type'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Type (Message.Mut s))) where
-    new msg = (Type'newtype_ <$> (Untyped.allocStruct msg 3 1))
-instance (Basics.ListElem mut (Type mut)) where
-    newtype List mut (Type mut)
-        = Type'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Type'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Type'List_ l) = (Untyped.ListStruct l)
-    length (Type'List_ l) = (Untyped.length l)
-    index i (Type'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Type (Message.Mut s))) where
-    setIndex (Type'newtype_ elt) i (Type'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Type'List_ <$> (Untyped.allocCompositeList msg 3 1 len))
-data Type' (mut :: Message.Mutability)
-    = Type'void 
-    | Type'bool 
-    | Type'int8 
-    | Type'int16 
-    | Type'int32 
-    | Type'int64 
-    | Type'uint8 
-    | Type'uint16 
-    | Type'uint32 
-    | Type'uint64 
-    | Type'float32 
-    | Type'float64 
-    | Type'text 
-    | Type'data_ 
-    | Type'list (Type'list mut)
-    | Type'enum (Type'enum mut)
-    | Type'struct (Type'struct mut)
-    | Type'interface (Type'interface mut)
-    | Type'anyPointer (Type'anyPointer mut)
-    | Type'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Type' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 0)
-        case tag of
-            0 ->
-                (Std_.pure Type'void)
-            1 ->
-                (Std_.pure Type'bool)
-            2 ->
-                (Std_.pure Type'int8)
-            3 ->
-                (Std_.pure Type'int16)
-            4 ->
-                (Std_.pure Type'int32)
-            5 ->
-                (Std_.pure Type'int64)
-            6 ->
-                (Std_.pure Type'uint8)
-            7 ->
-                (Std_.pure Type'uint16)
-            8 ->
-                (Std_.pure Type'uint32)
-            9 ->
-                (Std_.pure Type'uint64)
-            10 ->
-                (Std_.pure Type'float32)
-            11 ->
-                (Std_.pure Type'float64)
-            12 ->
-                (Std_.pure Type'text)
-            13 ->
-                (Std_.pure Type'data_)
-            14 ->
-                (Type'list <$> (Classes.fromStruct struct))
-            15 ->
-                (Type'enum <$> (Classes.fromStruct struct))
-            16 ->
-                (Type'struct <$> (Classes.fromStruct struct))
-            17 ->
-                (Type'interface <$> (Classes.fromStruct struct))
-            18 ->
-                (Type'anyPointer <$> (Classes.fromStruct struct))
-            _ ->
-                (Std_.pure (Type'unknown' (Std_.fromIntegral tag)))
-        )
-get_Type' :: ((Untyped.ReadCtx m msg)
-             ,(Classes.FromStruct msg (Type' msg))) => (Type msg) -> (m (Type' msg))
-get_Type' (Type'newtype_ struct) = (Classes.fromStruct struct)
-set_Type'void :: ((Untyped.RWCtx m s)) => (Type (Message.Mut s)) -> (m ())
-set_Type'void (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Type'bool :: ((Untyped.RWCtx m s)) => (Type (Message.Mut s)) -> (m ())
-set_Type'bool (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Type'int8 :: ((Untyped.RWCtx m s)) => (Type (Message.Mut s)) -> (m ())
-set_Type'int8 (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (2 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Type'int16 :: ((Untyped.RWCtx m s)) => (Type (Message.Mut s)) -> (m ())
-set_Type'int16 (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (3 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Type'int32 :: ((Untyped.RWCtx m s)) => (Type (Message.Mut s)) -> (m ())
-set_Type'int32 (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (4 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Type'int64 :: ((Untyped.RWCtx m s)) => (Type (Message.Mut s)) -> (m ())
-set_Type'int64 (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (5 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Type'uint8 :: ((Untyped.RWCtx m s)) => (Type (Message.Mut s)) -> (m ())
-set_Type'uint8 (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (6 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Type'uint16 :: ((Untyped.RWCtx m s)) => (Type (Message.Mut s)) -> (m ())
-set_Type'uint16 (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (7 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Type'uint32 :: ((Untyped.RWCtx m s)) => (Type (Message.Mut s)) -> (m ())
-set_Type'uint32 (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (8 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Type'uint64 :: ((Untyped.RWCtx m s)) => (Type (Message.Mut s)) -> (m ())
-set_Type'uint64 (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (9 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Type'float32 :: ((Untyped.RWCtx m s)) => (Type (Message.Mut s)) -> (m ())
-set_Type'float32 (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (10 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Type'float64 :: ((Untyped.RWCtx m s)) => (Type (Message.Mut s)) -> (m ())
-set_Type'float64 (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (11 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Type'text :: ((Untyped.RWCtx m s)) => (Type (Message.Mut s)) -> (m ())
-set_Type'text (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (12 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Type'data_ :: ((Untyped.RWCtx m s)) => (Type (Message.Mut s)) -> (m ())
-set_Type'data_ (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (13 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Type'list :: ((Untyped.RWCtx m s)
-                 ,(Classes.FromStruct (Message.Mut s) (Type'list (Message.Mut s)))) => (Type (Message.Mut s)) -> (m (Type'list (Message.Mut s)))
-set_Type'list (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (14 :: Std_.Word16) 0 0 0)
-    (Classes.fromStruct struct)
-    )
-set_Type'enum :: ((Untyped.RWCtx m s)
-                 ,(Classes.FromStruct (Message.Mut s) (Type'enum (Message.Mut s)))) => (Type (Message.Mut s)) -> (m (Type'enum (Message.Mut s)))
-set_Type'enum (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (15 :: Std_.Word16) 0 0 0)
-    (Classes.fromStruct struct)
-    )
-set_Type'struct :: ((Untyped.RWCtx m s)
-                   ,(Classes.FromStruct (Message.Mut s) (Type'struct (Message.Mut s)))) => (Type (Message.Mut s)) -> (m (Type'struct (Message.Mut s)))
-set_Type'struct (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (16 :: Std_.Word16) 0 0 0)
-    (Classes.fromStruct struct)
-    )
-set_Type'interface :: ((Untyped.RWCtx m s)
-                      ,(Classes.FromStruct (Message.Mut s) (Type'interface (Message.Mut s)))) => (Type (Message.Mut s)) -> (m (Type'interface (Message.Mut s)))
-set_Type'interface (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (17 :: Std_.Word16) 0 0 0)
-    (Classes.fromStruct struct)
-    )
-set_Type'anyPointer :: ((Untyped.RWCtx m s)
-                       ,(Classes.FromStruct (Message.Mut s) (Type'anyPointer (Message.Mut s)))) => (Type (Message.Mut s)) -> (m (Type'anyPointer (Message.Mut s)))
-set_Type'anyPointer (Type'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (18 :: Std_.Word16) 0 0 0)
-    (Classes.fromStruct struct)
-    )
-set_Type'unknown' :: ((Untyped.RWCtx m s)) => (Type (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Type'unknown' (Type'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-newtype Type'list msg
-    = Type'list'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Type'list msg)) where
-    fromStruct struct = (Std_.pure (Type'list'newtype_ struct))
-instance (Classes.ToStruct msg (Type'list msg)) where
-    toStruct (Type'list'newtype_ struct) = struct
-instance (Untyped.HasMessage (Type'list mut) mut) where
-    message (Type'list'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Type'list mut) mut) where
-    messageDefault msg = (Type'list'newtype_ <$> (Untyped.messageDefault msg))
-get_Type'list'elementType :: ((Untyped.ReadCtx m msg)
-                             ,(Classes.FromPtr msg (Type msg))) => (Type'list msg) -> (m (Type msg))
-get_Type'list'elementType (Type'list'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Type'list'elementType :: ((Untyped.RWCtx m s)
-                             ,(Classes.ToPtr s (Type (Message.Mut s)))) => (Type'list (Message.Mut s)) -> (Type (Message.Mut s)) -> (m ())
-set_Type'list'elementType (Type'list'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Type'list'elementType :: ((Untyped.ReadCtx m msg)) => (Type'list msg) -> (m Std_.Bool)
-has_Type'list'elementType (Type'list'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Type'list'elementType :: ((Untyped.RWCtx m s)) => (Type'list (Message.Mut s)) -> (m (Type (Message.Mut s)))
-new_Type'list'elementType struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Type'list'elementType struct result)
-    (Std_.pure result)
-    )
-newtype Type'enum msg
-    = Type'enum'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Type'enum msg)) where
-    fromStruct struct = (Std_.pure (Type'enum'newtype_ struct))
-instance (Classes.ToStruct msg (Type'enum msg)) where
-    toStruct (Type'enum'newtype_ struct) = struct
-instance (Untyped.HasMessage (Type'enum mut) mut) where
-    message (Type'enum'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Type'enum mut) mut) where
-    messageDefault msg = (Type'enum'newtype_ <$> (Untyped.messageDefault msg))
-get_Type'enum'typeId :: ((Untyped.ReadCtx m msg)) => (Type'enum msg) -> (m Std_.Word64)
-get_Type'enum'typeId (Type'enum'newtype_ struct) = (GenHelpers.getWordField struct 1 0 0)
-set_Type'enum'typeId :: ((Untyped.RWCtx m s)) => (Type'enum (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Type'enum'typeId (Type'enum'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-get_Type'enum'brand :: ((Untyped.ReadCtx m msg)
-                       ,(Classes.FromPtr msg (Brand msg))) => (Type'enum msg) -> (m (Brand msg))
-get_Type'enum'brand (Type'enum'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Type'enum'brand :: ((Untyped.RWCtx m s)
-                       ,(Classes.ToPtr s (Brand (Message.Mut s)))) => (Type'enum (Message.Mut s)) -> (Brand (Message.Mut s)) -> (m ())
-set_Type'enum'brand (Type'enum'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Type'enum'brand :: ((Untyped.ReadCtx m msg)) => (Type'enum msg) -> (m Std_.Bool)
-has_Type'enum'brand (Type'enum'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Type'enum'brand :: ((Untyped.RWCtx m s)) => (Type'enum (Message.Mut s)) -> (m (Brand (Message.Mut s)))
-new_Type'enum'brand struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Type'enum'brand struct result)
-    (Std_.pure result)
-    )
-newtype Type'struct msg
-    = Type'struct'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Type'struct msg)) where
-    fromStruct struct = (Std_.pure (Type'struct'newtype_ struct))
-instance (Classes.ToStruct msg (Type'struct msg)) where
-    toStruct (Type'struct'newtype_ struct) = struct
-instance (Untyped.HasMessage (Type'struct mut) mut) where
-    message (Type'struct'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Type'struct mut) mut) where
-    messageDefault msg = (Type'struct'newtype_ <$> (Untyped.messageDefault msg))
-get_Type'struct'typeId :: ((Untyped.ReadCtx m msg)) => (Type'struct msg) -> (m Std_.Word64)
-get_Type'struct'typeId (Type'struct'newtype_ struct) = (GenHelpers.getWordField struct 1 0 0)
-set_Type'struct'typeId :: ((Untyped.RWCtx m s)) => (Type'struct (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Type'struct'typeId (Type'struct'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-get_Type'struct'brand :: ((Untyped.ReadCtx m msg)
-                         ,(Classes.FromPtr msg (Brand msg))) => (Type'struct msg) -> (m (Brand msg))
-get_Type'struct'brand (Type'struct'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Type'struct'brand :: ((Untyped.RWCtx m s)
-                         ,(Classes.ToPtr s (Brand (Message.Mut s)))) => (Type'struct (Message.Mut s)) -> (Brand (Message.Mut s)) -> (m ())
-set_Type'struct'brand (Type'struct'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Type'struct'brand :: ((Untyped.ReadCtx m msg)) => (Type'struct msg) -> (m Std_.Bool)
-has_Type'struct'brand (Type'struct'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Type'struct'brand :: ((Untyped.RWCtx m s)) => (Type'struct (Message.Mut s)) -> (m (Brand (Message.Mut s)))
-new_Type'struct'brand struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Type'struct'brand struct result)
-    (Std_.pure result)
-    )
-newtype Type'interface msg
-    = Type'interface'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Type'interface msg)) where
-    fromStruct struct = (Std_.pure (Type'interface'newtype_ struct))
-instance (Classes.ToStruct msg (Type'interface msg)) where
-    toStruct (Type'interface'newtype_ struct) = struct
-instance (Untyped.HasMessage (Type'interface mut) mut) where
-    message (Type'interface'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Type'interface mut) mut) where
-    messageDefault msg = (Type'interface'newtype_ <$> (Untyped.messageDefault msg))
-get_Type'interface'typeId :: ((Untyped.ReadCtx m msg)) => (Type'interface msg) -> (m Std_.Word64)
-get_Type'interface'typeId (Type'interface'newtype_ struct) = (GenHelpers.getWordField struct 1 0 0)
-set_Type'interface'typeId :: ((Untyped.RWCtx m s)) => (Type'interface (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Type'interface'typeId (Type'interface'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-get_Type'interface'brand :: ((Untyped.ReadCtx m msg)
-                            ,(Classes.FromPtr msg (Brand msg))) => (Type'interface msg) -> (m (Brand msg))
-get_Type'interface'brand (Type'interface'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Type'interface'brand :: ((Untyped.RWCtx m s)
-                            ,(Classes.ToPtr s (Brand (Message.Mut s)))) => (Type'interface (Message.Mut s)) -> (Brand (Message.Mut s)) -> (m ())
-set_Type'interface'brand (Type'interface'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Type'interface'brand :: ((Untyped.ReadCtx m msg)) => (Type'interface msg) -> (m Std_.Bool)
-has_Type'interface'brand (Type'interface'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Type'interface'brand :: ((Untyped.RWCtx m s)) => (Type'interface (Message.Mut s)) -> (m (Brand (Message.Mut s)))
-new_Type'interface'brand struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Type'interface'brand struct result)
-    (Std_.pure result)
-    )
-newtype Type'anyPointer msg
-    = Type'anyPointer'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Type'anyPointer msg)) where
-    fromStruct struct = (Std_.pure (Type'anyPointer'newtype_ struct))
-instance (Classes.ToStruct msg (Type'anyPointer msg)) where
-    toStruct (Type'anyPointer'newtype_ struct) = struct
-instance (Untyped.HasMessage (Type'anyPointer mut) mut) where
-    message (Type'anyPointer'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Type'anyPointer mut) mut) where
-    messageDefault msg = (Type'anyPointer'newtype_ <$> (Untyped.messageDefault msg))
-data Type'anyPointer' (mut :: Message.Mutability)
-    = Type'anyPointer'unconstrained (Type'anyPointer'unconstrained mut)
-    | Type'anyPointer'parameter (Type'anyPointer'parameter mut)
-    | Type'anyPointer'implicitMethodParameter (Type'anyPointer'implicitMethodParameter mut)
-    | Type'anyPointer'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Type'anyPointer' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 4)
-        case tag of
-            0 ->
-                (Type'anyPointer'unconstrained <$> (Classes.fromStruct struct))
-            1 ->
-                (Type'anyPointer'parameter <$> (Classes.fromStruct struct))
-            2 ->
-                (Type'anyPointer'implicitMethodParameter <$> (Classes.fromStruct struct))
-            _ ->
-                (Std_.pure (Type'anyPointer'unknown' (Std_.fromIntegral tag)))
-        )
-get_Type'anyPointer' :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromStruct msg (Type'anyPointer' msg))) => (Type'anyPointer msg) -> (m (Type'anyPointer' msg))
-get_Type'anyPointer' (Type'anyPointer'newtype_ struct) = (Classes.fromStruct struct)
-set_Type'anyPointer'unconstrained :: ((Untyped.RWCtx m s)
-                                     ,(Classes.FromStruct (Message.Mut s) (Type'anyPointer'unconstrained (Message.Mut s)))) => (Type'anyPointer (Message.Mut s)) -> (m (Type'anyPointer'unconstrained (Message.Mut s)))
-set_Type'anyPointer'unconstrained (Type'anyPointer'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 1 0 0)
-    (Classes.fromStruct struct)
-    )
-set_Type'anyPointer'parameter :: ((Untyped.RWCtx m s)
-                                 ,(Classes.FromStruct (Message.Mut s) (Type'anyPointer'parameter (Message.Mut s)))) => (Type'anyPointer (Message.Mut s)) -> (m (Type'anyPointer'parameter (Message.Mut s)))
-set_Type'anyPointer'parameter (Type'anyPointer'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 1 0 0)
-    (Classes.fromStruct struct)
-    )
-set_Type'anyPointer'implicitMethodParameter :: ((Untyped.RWCtx m s)
-                                               ,(Classes.FromStruct (Message.Mut s) (Type'anyPointer'implicitMethodParameter (Message.Mut s)))) => (Type'anyPointer (Message.Mut s)) -> (m (Type'anyPointer'implicitMethodParameter (Message.Mut s)))
-set_Type'anyPointer'implicitMethodParameter (Type'anyPointer'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (2 :: Std_.Word16) 1 0 0)
-    (Classes.fromStruct struct)
-    )
-set_Type'anyPointer'unknown' :: ((Untyped.RWCtx m s)) => (Type'anyPointer (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Type'anyPointer'unknown' (Type'anyPointer'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 1 0 0)
-newtype Type'anyPointer'unconstrained msg
-    = Type'anyPointer'unconstrained'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Type'anyPointer'unconstrained msg)) where
-    fromStruct struct = (Std_.pure (Type'anyPointer'unconstrained'newtype_ struct))
-instance (Classes.ToStruct msg (Type'anyPointer'unconstrained msg)) where
-    toStruct (Type'anyPointer'unconstrained'newtype_ struct) = struct
-instance (Untyped.HasMessage (Type'anyPointer'unconstrained mut) mut) where
-    message (Type'anyPointer'unconstrained'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Type'anyPointer'unconstrained mut) mut) where
-    messageDefault msg = (Type'anyPointer'unconstrained'newtype_ <$> (Untyped.messageDefault msg))
-data Type'anyPointer'unconstrained' (mut :: Message.Mutability)
-    = Type'anyPointer'unconstrained'anyKind 
-    | Type'anyPointer'unconstrained'struct 
-    | Type'anyPointer'unconstrained'list 
-    | Type'anyPointer'unconstrained'capability 
-    | Type'anyPointer'unconstrained'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Type'anyPointer'unconstrained' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 5)
-        case tag of
-            0 ->
-                (Std_.pure Type'anyPointer'unconstrained'anyKind)
-            1 ->
-                (Std_.pure Type'anyPointer'unconstrained'struct)
-            2 ->
-                (Std_.pure Type'anyPointer'unconstrained'list)
-            3 ->
-                (Std_.pure Type'anyPointer'unconstrained'capability)
-            _ ->
-                (Std_.pure (Type'anyPointer'unconstrained'unknown' (Std_.fromIntegral tag)))
-        )
-get_Type'anyPointer'unconstrained' :: ((Untyped.ReadCtx m msg)
-                                      ,(Classes.FromStruct msg (Type'anyPointer'unconstrained' msg))) => (Type'anyPointer'unconstrained msg) -> (m (Type'anyPointer'unconstrained' msg))
-get_Type'anyPointer'unconstrained' (Type'anyPointer'unconstrained'newtype_ struct) = (Classes.fromStruct struct)
-set_Type'anyPointer'unconstrained'anyKind :: ((Untyped.RWCtx m s)) => (Type'anyPointer'unconstrained (Message.Mut s)) -> (m ())
-set_Type'anyPointer'unconstrained'anyKind (Type'anyPointer'unconstrained'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 1 16 0)
-    (Std_.pure ())
-    )
-set_Type'anyPointer'unconstrained'struct :: ((Untyped.RWCtx m s)) => (Type'anyPointer'unconstrained (Message.Mut s)) -> (m ())
-set_Type'anyPointer'unconstrained'struct (Type'anyPointer'unconstrained'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 1 16 0)
-    (Std_.pure ())
-    )
-set_Type'anyPointer'unconstrained'list :: ((Untyped.RWCtx m s)) => (Type'anyPointer'unconstrained (Message.Mut s)) -> (m ())
-set_Type'anyPointer'unconstrained'list (Type'anyPointer'unconstrained'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (2 :: Std_.Word16) 1 16 0)
-    (Std_.pure ())
-    )
-set_Type'anyPointer'unconstrained'capability :: ((Untyped.RWCtx m s)) => (Type'anyPointer'unconstrained (Message.Mut s)) -> (m ())
-set_Type'anyPointer'unconstrained'capability (Type'anyPointer'unconstrained'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (3 :: Std_.Word16) 1 16 0)
-    (Std_.pure ())
-    )
-set_Type'anyPointer'unconstrained'unknown' :: ((Untyped.RWCtx m s)) => (Type'anyPointer'unconstrained (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Type'anyPointer'unconstrained'unknown' (Type'anyPointer'unconstrained'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 1 16 0)
-newtype Type'anyPointer'parameter msg
-    = Type'anyPointer'parameter'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Type'anyPointer'parameter msg)) where
-    fromStruct struct = (Std_.pure (Type'anyPointer'parameter'newtype_ struct))
-instance (Classes.ToStruct msg (Type'anyPointer'parameter msg)) where
-    toStruct (Type'anyPointer'parameter'newtype_ struct) = struct
-instance (Untyped.HasMessage (Type'anyPointer'parameter mut) mut) where
-    message (Type'anyPointer'parameter'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Type'anyPointer'parameter mut) mut) where
-    messageDefault msg = (Type'anyPointer'parameter'newtype_ <$> (Untyped.messageDefault msg))
-get_Type'anyPointer'parameter'scopeId :: ((Untyped.ReadCtx m msg)) => (Type'anyPointer'parameter msg) -> (m Std_.Word64)
-get_Type'anyPointer'parameter'scopeId (Type'anyPointer'parameter'newtype_ struct) = (GenHelpers.getWordField struct 2 0 0)
-set_Type'anyPointer'parameter'scopeId :: ((Untyped.RWCtx m s)) => (Type'anyPointer'parameter (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Type'anyPointer'parameter'scopeId (Type'anyPointer'parameter'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 2 0 0)
-get_Type'anyPointer'parameter'parameterIndex :: ((Untyped.ReadCtx m msg)) => (Type'anyPointer'parameter msg) -> (m Std_.Word16)
-get_Type'anyPointer'parameter'parameterIndex (Type'anyPointer'parameter'newtype_ struct) = (GenHelpers.getWordField struct 1 16 0)
-set_Type'anyPointer'parameter'parameterIndex :: ((Untyped.RWCtx m s)) => (Type'anyPointer'parameter (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Type'anyPointer'parameter'parameterIndex (Type'anyPointer'parameter'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 1 16 0)
-newtype Type'anyPointer'implicitMethodParameter msg
-    = Type'anyPointer'implicitMethodParameter'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Type'anyPointer'implicitMethodParameter msg)) where
-    fromStruct struct = (Std_.pure (Type'anyPointer'implicitMethodParameter'newtype_ struct))
-instance (Classes.ToStruct msg (Type'anyPointer'implicitMethodParameter msg)) where
-    toStruct (Type'anyPointer'implicitMethodParameter'newtype_ struct) = struct
-instance (Untyped.HasMessage (Type'anyPointer'implicitMethodParameter mut) mut) where
-    message (Type'anyPointer'implicitMethodParameter'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Type'anyPointer'implicitMethodParameter mut) mut) where
-    messageDefault msg = (Type'anyPointer'implicitMethodParameter'newtype_ <$> (Untyped.messageDefault msg))
-get_Type'anyPointer'implicitMethodParameter'parameterIndex :: ((Untyped.ReadCtx m msg)) => (Type'anyPointer'implicitMethodParameter msg) -> (m Std_.Word16)
-get_Type'anyPointer'implicitMethodParameter'parameterIndex (Type'anyPointer'implicitMethodParameter'newtype_ struct) = (GenHelpers.getWordField struct 1 16 0)
-set_Type'anyPointer'implicitMethodParameter'parameterIndex :: ((Untyped.RWCtx m s)) => (Type'anyPointer'implicitMethodParameter (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Type'anyPointer'implicitMethodParameter'parameterIndex (Type'anyPointer'implicitMethodParameter'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 1 16 0)
-newtype Brand msg
-    = Brand'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Brand msg)) where
-    fromStruct struct = (Std_.pure (Brand'newtype_ struct))
-instance (Classes.ToStruct msg (Brand msg)) where
-    toStruct (Brand'newtype_ struct) = struct
-instance (Untyped.HasMessage (Brand mut) mut) where
-    message (Brand'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Brand mut) mut) where
-    messageDefault msg = (Brand'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Brand msg)) where
-    fromPtr msg ptr = (Brand'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Brand (Message.Mut s))) where
-    toPtr msg (Brand'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Brand (Message.Mut s))) where
-    new msg = (Brand'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Brand mut)) where
-    newtype List mut (Brand mut)
-        = Brand'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Brand'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Brand'List_ l) = (Untyped.ListStruct l)
-    length (Brand'List_ l) = (Untyped.length l)
-    index i (Brand'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Brand (Message.Mut s))) where
-    setIndex (Brand'newtype_ elt) i (Brand'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Brand'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Brand'scopes :: ((Untyped.ReadCtx m msg)
-                    ,(Classes.FromPtr msg (Basics.List msg (Brand'Scope msg)))) => (Brand msg) -> (m (Basics.List msg (Brand'Scope msg)))
-get_Brand'scopes (Brand'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Brand'scopes :: ((Untyped.RWCtx m s)
-                    ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Brand'Scope (Message.Mut s))))) => (Brand (Message.Mut s)) -> (Basics.List (Message.Mut s) (Brand'Scope (Message.Mut s))) -> (m ())
-set_Brand'scopes (Brand'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Brand'scopes :: ((Untyped.ReadCtx m msg)) => (Brand msg) -> (m Std_.Bool)
-has_Brand'scopes (Brand'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Brand'scopes :: ((Untyped.RWCtx m s)) => Std_.Int -> (Brand (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Brand'Scope (Message.Mut s))))
-new_Brand'scopes len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Brand'scopes struct result)
-    (Std_.pure result)
-    )
-newtype Brand'Scope msg
-    = Brand'Scope'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Brand'Scope msg)) where
-    fromStruct struct = (Std_.pure (Brand'Scope'newtype_ struct))
-instance (Classes.ToStruct msg (Brand'Scope msg)) where
-    toStruct (Brand'Scope'newtype_ struct) = struct
-instance (Untyped.HasMessage (Brand'Scope mut) mut) where
-    message (Brand'Scope'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Brand'Scope mut) mut) where
-    messageDefault msg = (Brand'Scope'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Brand'Scope msg)) where
-    fromPtr msg ptr = (Brand'Scope'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Brand'Scope (Message.Mut s))) where
-    toPtr msg (Brand'Scope'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Brand'Scope (Message.Mut s))) where
-    new msg = (Brand'Scope'newtype_ <$> (Untyped.allocStruct msg 2 1))
-instance (Basics.ListElem mut (Brand'Scope mut)) where
-    newtype List mut (Brand'Scope mut)
-        = Brand'Scope'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Brand'Scope'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Brand'Scope'List_ l) = (Untyped.ListStruct l)
-    length (Brand'Scope'List_ l) = (Untyped.length l)
-    index i (Brand'Scope'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Brand'Scope (Message.Mut s))) where
-    setIndex (Brand'Scope'newtype_ elt) i (Brand'Scope'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Brand'Scope'List_ <$> (Untyped.allocCompositeList msg 2 1 len))
-get_Brand'Scope'scopeId :: ((Untyped.ReadCtx m msg)) => (Brand'Scope msg) -> (m Std_.Word64)
-get_Brand'Scope'scopeId (Brand'Scope'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Brand'Scope'scopeId :: ((Untyped.RWCtx m s)) => (Brand'Scope (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Brand'Scope'scopeId (Brand'Scope'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 0 0 0)
-data Brand'Scope' (mut :: Message.Mutability)
-    = Brand'Scope'bind (Basics.List mut (Brand'Binding mut))
-    | Brand'Scope'inherit 
-    | Brand'Scope'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Brand'Scope' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 4)
-        case tag of
-            0 ->
-                (Brand'Scope'bind <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            1 ->
-                (Std_.pure Brand'Scope'inherit)
-            _ ->
-                (Std_.pure (Brand'Scope'unknown' (Std_.fromIntegral tag)))
-        )
-get_Brand'Scope' :: ((Untyped.ReadCtx m msg)
-                    ,(Classes.FromStruct msg (Brand'Scope' msg))) => (Brand'Scope msg) -> (m (Brand'Scope' msg))
-get_Brand'Scope' (Brand'Scope'newtype_ struct) = (Classes.fromStruct struct)
-set_Brand'Scope'bind :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Brand'Binding (Message.Mut s))))) => (Brand'Scope (Message.Mut s)) -> (Basics.List (Message.Mut s) (Brand'Binding (Message.Mut s))) -> (m ())
-set_Brand'Scope'bind (Brand'Scope'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 1 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Brand'Scope'inherit :: ((Untyped.RWCtx m s)) => (Brand'Scope (Message.Mut s)) -> (m ())
-set_Brand'Scope'inherit (Brand'Scope'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 1 0 0)
-    (Std_.pure ())
-    )
-set_Brand'Scope'unknown' :: ((Untyped.RWCtx m s)) => (Brand'Scope (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Brand'Scope'unknown' (Brand'Scope'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 1 0 0)
-newtype Brand'Binding msg
-    = Brand'Binding'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Brand'Binding msg)) where
-    fromStruct struct = (Std_.pure (Brand'Binding'newtype_ struct))
-instance (Classes.ToStruct msg (Brand'Binding msg)) where
-    toStruct (Brand'Binding'newtype_ struct) = struct
-instance (Untyped.HasMessage (Brand'Binding mut) mut) where
-    message (Brand'Binding'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Brand'Binding mut) mut) where
-    messageDefault msg = (Brand'Binding'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Brand'Binding msg)) where
-    fromPtr msg ptr = (Brand'Binding'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Brand'Binding (Message.Mut s))) where
-    toPtr msg (Brand'Binding'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Brand'Binding (Message.Mut s))) where
-    new msg = (Brand'Binding'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (Brand'Binding mut)) where
-    newtype List mut (Brand'Binding mut)
-        = Brand'Binding'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Brand'Binding'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Brand'Binding'List_ l) = (Untyped.ListStruct l)
-    length (Brand'Binding'List_ l) = (Untyped.length l)
-    index i (Brand'Binding'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Brand'Binding (Message.Mut s))) where
-    setIndex (Brand'Binding'newtype_ elt) i (Brand'Binding'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Brand'Binding'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-data Brand'Binding' (mut :: Message.Mutability)
-    = Brand'Binding'unbound 
-    | Brand'Binding'type_ (Type mut)
-    | Brand'Binding'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Brand'Binding' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 0)
-        case tag of
-            0 ->
-                (Std_.pure Brand'Binding'unbound)
-            1 ->
-                (Brand'Binding'type_ <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            _ ->
-                (Std_.pure (Brand'Binding'unknown' (Std_.fromIntegral tag)))
-        )
-get_Brand'Binding' :: ((Untyped.ReadCtx m msg)
-                      ,(Classes.FromStruct msg (Brand'Binding' msg))) => (Brand'Binding msg) -> (m (Brand'Binding' msg))
-get_Brand'Binding' (Brand'Binding'newtype_ struct) = (Classes.fromStruct struct)
-set_Brand'Binding'unbound :: ((Untyped.RWCtx m s)) => (Brand'Binding (Message.Mut s)) -> (m ())
-set_Brand'Binding'unbound (Brand'Binding'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Brand'Binding'type_ :: ((Untyped.RWCtx m s)
-                           ,(Classes.ToPtr s (Type (Message.Mut s)))) => (Brand'Binding (Message.Mut s)) -> (Type (Message.Mut s)) -> (m ())
-set_Brand'Binding'type_ (Brand'Binding'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Brand'Binding'unknown' :: ((Untyped.RWCtx m s)) => (Brand'Binding (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Brand'Binding'unknown' (Brand'Binding'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-newtype Value msg
-    = Value'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Value msg)) where
-    fromStruct struct = (Std_.pure (Value'newtype_ struct))
-instance (Classes.ToStruct msg (Value msg)) where
-    toStruct (Value'newtype_ struct) = struct
-instance (Untyped.HasMessage (Value mut) mut) where
-    message (Value'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Value mut) mut) where
-    messageDefault msg = (Value'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Value msg)) where
-    fromPtr msg ptr = (Value'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Value (Message.Mut s))) where
-    toPtr msg (Value'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Value (Message.Mut s))) where
-    new msg = (Value'newtype_ <$> (Untyped.allocStruct msg 2 1))
-instance (Basics.ListElem mut (Value mut)) where
-    newtype List mut (Value mut)
-        = Value'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Value'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Value'List_ l) = (Untyped.ListStruct l)
-    length (Value'List_ l) = (Untyped.length l)
-    index i (Value'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Value (Message.Mut s))) where
-    setIndex (Value'newtype_ elt) i (Value'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Value'List_ <$> (Untyped.allocCompositeList msg 2 1 len))
-data Value' (mut :: Message.Mutability)
-    = Value'void 
-    | Value'bool Std_.Bool
-    | Value'int8 Std_.Int8
-    | Value'int16 Std_.Int16
-    | Value'int32 Std_.Int32
-    | Value'int64 Std_.Int64
-    | Value'uint8 Std_.Word8
-    | Value'uint16 Std_.Word16
-    | Value'uint32 Std_.Word32
-    | Value'uint64 Std_.Word64
-    | Value'float32 Std_.Float
-    | Value'float64 Std_.Double
-    | Value'text (Basics.Text mut)
-    | Value'data_ (Basics.Data mut)
-    | Value'list (Std_.Maybe (Untyped.Ptr mut))
-    | Value'enum Std_.Word16
-    | Value'struct (Std_.Maybe (Untyped.Ptr mut))
-    | Value'interface 
-    | Value'anyPointer (Std_.Maybe (Untyped.Ptr mut))
-    | Value'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Value' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 0)
-        case tag of
-            0 ->
-                (Std_.pure Value'void)
-            1 ->
-                (Value'bool <$> (GenHelpers.getWordField struct 0 16 0))
-            2 ->
-                (Value'int8 <$> (GenHelpers.getWordField struct 0 16 0))
-            3 ->
-                (Value'int16 <$> (GenHelpers.getWordField struct 0 16 0))
-            4 ->
-                (Value'int32 <$> (GenHelpers.getWordField struct 0 32 0))
-            5 ->
-                (Value'int64 <$> (GenHelpers.getWordField struct 1 0 0))
-            6 ->
-                (Value'uint8 <$> (GenHelpers.getWordField struct 0 16 0))
-            7 ->
-                (Value'uint16 <$> (GenHelpers.getWordField struct 0 16 0))
-            8 ->
-                (Value'uint32 <$> (GenHelpers.getWordField struct 0 32 0))
-            9 ->
-                (Value'uint64 <$> (GenHelpers.getWordField struct 1 0 0))
-            10 ->
-                (Value'float32 <$> (GenHelpers.getWordField struct 0 32 0))
-            11 ->
-                (Value'float64 <$> (GenHelpers.getWordField struct 1 0 0))
-            12 ->
-                (Value'text <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            13 ->
-                (Value'data_ <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            14 ->
-                (Value'list <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            15 ->
-                (Value'enum <$> (GenHelpers.getWordField struct 0 16 0))
-            16 ->
-                (Value'struct <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            17 ->
-                (Std_.pure Value'interface)
-            18 ->
-                (Value'anyPointer <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            _ ->
-                (Std_.pure (Value'unknown' (Std_.fromIntegral tag)))
-        )
-get_Value' :: ((Untyped.ReadCtx m msg)
-              ,(Classes.FromStruct msg (Value' msg))) => (Value msg) -> (m (Value' msg))
-get_Value' (Value'newtype_ struct) = (Classes.fromStruct struct)
-set_Value'void :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> (m ())
-set_Value'void (Value'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Value'bool :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Value'bool (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 0 16 0)
-    )
-set_Value'int8 :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> Std_.Int8 -> (m ())
-set_Value'int8 (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (2 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word8) 0 16 0)
-    )
-set_Value'int16 :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> Std_.Int16 -> (m ())
-set_Value'int16 (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (3 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 16 0)
-    )
-set_Value'int32 :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> Std_.Int32 -> (m ())
-set_Value'int32 (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (4 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 32 0)
-    )
-set_Value'int64 :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> Std_.Int64 -> (m ())
-set_Value'int64 (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (5 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-    )
-set_Value'uint8 :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> Std_.Word8 -> (m ())
-set_Value'uint8 (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (6 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word8) 0 16 0)
-    )
-set_Value'uint16 :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Value'uint16 (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (7 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 16 0)
-    )
-set_Value'uint32 :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Value'uint32 (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (8 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 32 0)
-    )
-set_Value'uint64 :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Value'uint64 (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (9 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-    )
-set_Value'float32 :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> Std_.Float -> (m ())
-set_Value'float32 (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (10 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 32 0)
-    )
-set_Value'float64 :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> Std_.Double -> (m ())
-set_Value'float64 (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (11 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-    )
-set_Value'text :: ((Untyped.RWCtx m s)
-                  ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Value (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Value'text (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (12 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Value'data_ :: ((Untyped.RWCtx m s)
-                   ,(Classes.ToPtr s (Basics.Data (Message.Mut s)))) => (Value (Message.Mut s)) -> (Basics.Data (Message.Mut s)) -> (m ())
-set_Value'data_ (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (13 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Value'list :: ((Untyped.RWCtx m s)
-                  ,(Classes.ToPtr s (Std_.Maybe (Untyped.Ptr (Message.Mut s))))) => (Value (Message.Mut s)) -> (Std_.Maybe (Untyped.Ptr (Message.Mut s))) -> (m ())
-set_Value'list (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (14 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Value'enum :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Value'enum (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (15 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 16 0)
-    )
-set_Value'struct :: ((Untyped.RWCtx m s)
-                    ,(Classes.ToPtr s (Std_.Maybe (Untyped.Ptr (Message.Mut s))))) => (Value (Message.Mut s)) -> (Std_.Maybe (Untyped.Ptr (Message.Mut s))) -> (m ())
-set_Value'struct (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (16 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Value'interface :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> (m ())
-set_Value'interface (Value'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (17 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Value'anyPointer :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Std_.Maybe (Untyped.Ptr (Message.Mut s))))) => (Value (Message.Mut s)) -> (Std_.Maybe (Untyped.Ptr (Message.Mut s))) -> (m ())
-set_Value'anyPointer (Value'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (18 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Value'unknown' :: ((Untyped.RWCtx m s)) => (Value (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Value'unknown' (Value'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-newtype Annotation msg
-    = Annotation'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Annotation msg)) where
-    fromStruct struct = (Std_.pure (Annotation'newtype_ struct))
-instance (Classes.ToStruct msg (Annotation msg)) where
-    toStruct (Annotation'newtype_ struct) = struct
-instance (Untyped.HasMessage (Annotation mut) mut) where
-    message (Annotation'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Annotation mut) mut) where
-    messageDefault msg = (Annotation'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Annotation msg)) where
-    fromPtr msg ptr = (Annotation'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Annotation (Message.Mut s))) where
-    toPtr msg (Annotation'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Annotation (Message.Mut s))) where
-    new msg = (Annotation'newtype_ <$> (Untyped.allocStruct msg 1 2))
-instance (Basics.ListElem mut (Annotation mut)) where
-    newtype List mut (Annotation mut)
-        = Annotation'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Annotation'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Annotation'List_ l) = (Untyped.ListStruct l)
-    length (Annotation'List_ l) = (Untyped.length l)
-    index i (Annotation'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Annotation (Message.Mut s))) where
-    setIndex (Annotation'newtype_ elt) i (Annotation'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Annotation'List_ <$> (Untyped.allocCompositeList msg 1 2 len))
-get_Annotation'id :: ((Untyped.ReadCtx m msg)) => (Annotation msg) -> (m Std_.Word64)
-get_Annotation'id (Annotation'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Annotation'id :: ((Untyped.RWCtx m s)) => (Annotation (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Annotation'id (Annotation'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 0 0 0)
-get_Annotation'value :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Value msg))) => (Annotation msg) -> (m (Value msg))
-get_Annotation'value (Annotation'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Annotation'value :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Value (Message.Mut s)))) => (Annotation (Message.Mut s)) -> (Value (Message.Mut s)) -> (m ())
-set_Annotation'value (Annotation'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Annotation'value :: ((Untyped.ReadCtx m msg)) => (Annotation msg) -> (m Std_.Bool)
-has_Annotation'value (Annotation'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Annotation'value :: ((Untyped.RWCtx m s)) => (Annotation (Message.Mut s)) -> (m (Value (Message.Mut s)))
-new_Annotation'value struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Annotation'value struct result)
-    (Std_.pure result)
-    )
-get_Annotation'brand :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Brand msg))) => (Annotation msg) -> (m (Brand msg))
-get_Annotation'brand (Annotation'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Annotation'brand :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Brand (Message.Mut s)))) => (Annotation (Message.Mut s)) -> (Brand (Message.Mut s)) -> (m ())
-set_Annotation'brand (Annotation'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Annotation'brand :: ((Untyped.ReadCtx m msg)) => (Annotation msg) -> (m Std_.Bool)
-has_Annotation'brand (Annotation'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_Annotation'brand :: ((Untyped.RWCtx m s)) => (Annotation (Message.Mut s)) -> (m (Brand (Message.Mut s)))
-new_Annotation'brand struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Annotation'brand struct result)
-    (Std_.pure result)
-    )
-data ElementSize 
-    = ElementSize'empty 
-    | ElementSize'bit 
-    | ElementSize'byte 
-    | ElementSize'twoBytes 
-    | ElementSize'fourBytes 
-    | ElementSize'eightBytes 
-    | ElementSize'pointer 
-    | ElementSize'inlineComposite 
-    | ElementSize'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Read
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Classes.IsWord ElementSize) where
-    fromWord n = case ((Std_.fromIntegral n) :: Std_.Word16) of
-        0 ->
-            ElementSize'empty
-        1 ->
-            ElementSize'bit
-        2 ->
-            ElementSize'byte
-        3 ->
-            ElementSize'twoBytes
-        4 ->
-            ElementSize'fourBytes
-        5 ->
-            ElementSize'eightBytes
-        6 ->
-            ElementSize'pointer
-        7 ->
-            ElementSize'inlineComposite
-        tag ->
-            (ElementSize'unknown' tag)
-    toWord (ElementSize'empty) = 0
-    toWord (ElementSize'bit) = 1
-    toWord (ElementSize'byte) = 2
-    toWord (ElementSize'twoBytes) = 3
-    toWord (ElementSize'fourBytes) = 4
-    toWord (ElementSize'eightBytes) = 5
-    toWord (ElementSize'pointer) = 6
-    toWord (ElementSize'inlineComposite) = 7
-    toWord (ElementSize'unknown' tag) = (Std_.fromIntegral tag)
-instance (Std_.Enum ElementSize) where
-    fromEnum x = (Std_.fromIntegral (Classes.toWord x))
-    toEnum x = (Classes.fromWord (Std_.fromIntegral x))
-instance (Basics.ListElem mut ElementSize) where
-    newtype List mut ElementSize
-        = ElementSize'List_ (Untyped.ListOf mut Std_.Word16)
-    index i (ElementSize'List_ l) = (Classes.fromWord <$> (Std_.fromIntegral <$> (Untyped.index i l)))
-    listFromPtr msg ptr = (ElementSize'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (ElementSize'List_ l) = (Untyped.List16 l)
-    length (ElementSize'List_ l) = (Untyped.length l)
-instance (Classes.MutListElem s ElementSize) where
-    setIndex elt i (ElementSize'List_ l) = (Untyped.setIndex (Std_.fromIntegral (Classes.toWord elt)) i l)
-    newList msg size = (ElementSize'List_ <$> (Untyped.allocList16 msg size))
-newtype CapnpVersion msg
-    = CapnpVersion'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (CapnpVersion msg)) where
-    fromStruct struct = (Std_.pure (CapnpVersion'newtype_ struct))
-instance (Classes.ToStruct msg (CapnpVersion msg)) where
-    toStruct (CapnpVersion'newtype_ struct) = struct
-instance (Untyped.HasMessage (CapnpVersion mut) mut) where
-    message (CapnpVersion'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (CapnpVersion mut) mut) where
-    messageDefault msg = (CapnpVersion'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (CapnpVersion msg)) where
-    fromPtr msg ptr = (CapnpVersion'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (CapnpVersion (Message.Mut s))) where
-    toPtr msg (CapnpVersion'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (CapnpVersion (Message.Mut s))) where
-    new msg = (CapnpVersion'newtype_ <$> (Untyped.allocStruct msg 1 0))
-instance (Basics.ListElem mut (CapnpVersion mut)) where
-    newtype List mut (CapnpVersion mut)
-        = CapnpVersion'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (CapnpVersion'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (CapnpVersion'List_ l) = (Untyped.ListStruct l)
-    length (CapnpVersion'List_ l) = (Untyped.length l)
-    index i (CapnpVersion'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (CapnpVersion (Message.Mut s))) where
-    setIndex (CapnpVersion'newtype_ elt) i (CapnpVersion'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (CapnpVersion'List_ <$> (Untyped.allocCompositeList msg 1 0 len))
-get_CapnpVersion'major :: ((Untyped.ReadCtx m msg)) => (CapnpVersion msg) -> (m Std_.Word16)
-get_CapnpVersion'major (CapnpVersion'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_CapnpVersion'major :: ((Untyped.RWCtx m s)) => (CapnpVersion (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_CapnpVersion'major (CapnpVersion'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-get_CapnpVersion'minor :: ((Untyped.ReadCtx m msg)) => (CapnpVersion msg) -> (m Std_.Word8)
-get_CapnpVersion'minor (CapnpVersion'newtype_ struct) = (GenHelpers.getWordField struct 0 16 0)
-set_CapnpVersion'minor :: ((Untyped.RWCtx m s)) => (CapnpVersion (Message.Mut s)) -> Std_.Word8 -> (m ())
-set_CapnpVersion'minor (CapnpVersion'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word8) 0 16 0)
-get_CapnpVersion'micro :: ((Untyped.ReadCtx m msg)) => (CapnpVersion msg) -> (m Std_.Word8)
-get_CapnpVersion'micro (CapnpVersion'newtype_ struct) = (GenHelpers.getWordField struct 0 24 0)
-set_CapnpVersion'micro :: ((Untyped.RWCtx m s)) => (CapnpVersion (Message.Mut s)) -> Std_.Word8 -> (m ())
-set_CapnpVersion'micro (CapnpVersion'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word8) 0 24 0)
-newtype CodeGeneratorRequest msg
-    = CodeGeneratorRequest'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (CodeGeneratorRequest msg)) where
-    fromStruct struct = (Std_.pure (CodeGeneratorRequest'newtype_ struct))
-instance (Classes.ToStruct msg (CodeGeneratorRequest msg)) where
-    toStruct (CodeGeneratorRequest'newtype_ struct) = struct
-instance (Untyped.HasMessage (CodeGeneratorRequest mut) mut) where
-    message (CodeGeneratorRequest'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (CodeGeneratorRequest mut) mut) where
-    messageDefault msg = (CodeGeneratorRequest'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (CodeGeneratorRequest msg)) where
-    fromPtr msg ptr = (CodeGeneratorRequest'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (CodeGeneratorRequest (Message.Mut s))) where
-    toPtr msg (CodeGeneratorRequest'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (CodeGeneratorRequest (Message.Mut s))) where
-    new msg = (CodeGeneratorRequest'newtype_ <$> (Untyped.allocStruct msg 0 4))
-instance (Basics.ListElem mut (CodeGeneratorRequest mut)) where
-    newtype List mut (CodeGeneratorRequest mut)
-        = CodeGeneratorRequest'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (CodeGeneratorRequest'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (CodeGeneratorRequest'List_ l) = (Untyped.ListStruct l)
-    length (CodeGeneratorRequest'List_ l) = (Untyped.length l)
-    index i (CodeGeneratorRequest'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (CodeGeneratorRequest (Message.Mut s))) where
-    setIndex (CodeGeneratorRequest'newtype_ elt) i (CodeGeneratorRequest'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (CodeGeneratorRequest'List_ <$> (Untyped.allocCompositeList msg 0 4 len))
-get_CodeGeneratorRequest'nodes :: ((Untyped.ReadCtx m msg)
-                                  ,(Classes.FromPtr msg (Basics.List msg (Node msg)))) => (CodeGeneratorRequest msg) -> (m (Basics.List msg (Node msg)))
-get_CodeGeneratorRequest'nodes (CodeGeneratorRequest'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_CodeGeneratorRequest'nodes :: ((Untyped.RWCtx m s)
-                                  ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Node (Message.Mut s))))) => (CodeGeneratorRequest (Message.Mut s)) -> (Basics.List (Message.Mut s) (Node (Message.Mut s))) -> (m ())
-set_CodeGeneratorRequest'nodes (CodeGeneratorRequest'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_CodeGeneratorRequest'nodes :: ((Untyped.ReadCtx m msg)) => (CodeGeneratorRequest msg) -> (m Std_.Bool)
-has_CodeGeneratorRequest'nodes (CodeGeneratorRequest'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_CodeGeneratorRequest'nodes :: ((Untyped.RWCtx m s)) => Std_.Int -> (CodeGeneratorRequest (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Node (Message.Mut s))))
-new_CodeGeneratorRequest'nodes len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_CodeGeneratorRequest'nodes struct result)
-    (Std_.pure result)
-    )
-get_CodeGeneratorRequest'requestedFiles :: ((Untyped.ReadCtx m msg)
-                                           ,(Classes.FromPtr msg (Basics.List msg (CodeGeneratorRequest'RequestedFile msg)))) => (CodeGeneratorRequest msg) -> (m (Basics.List msg (CodeGeneratorRequest'RequestedFile msg)))
-get_CodeGeneratorRequest'requestedFiles (CodeGeneratorRequest'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_CodeGeneratorRequest'requestedFiles :: ((Untyped.RWCtx m s)
-                                           ,(Classes.ToPtr s (Basics.List (Message.Mut s) (CodeGeneratorRequest'RequestedFile (Message.Mut s))))) => (CodeGeneratorRequest (Message.Mut s)) -> (Basics.List (Message.Mut s) (CodeGeneratorRequest'RequestedFile (Message.Mut s))) -> (m ())
-set_CodeGeneratorRequest'requestedFiles (CodeGeneratorRequest'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_CodeGeneratorRequest'requestedFiles :: ((Untyped.ReadCtx m msg)) => (CodeGeneratorRequest msg) -> (m Std_.Bool)
-has_CodeGeneratorRequest'requestedFiles (CodeGeneratorRequest'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_CodeGeneratorRequest'requestedFiles :: ((Untyped.RWCtx m s)) => Std_.Int -> (CodeGeneratorRequest (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (CodeGeneratorRequest'RequestedFile (Message.Mut s))))
-new_CodeGeneratorRequest'requestedFiles len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_CodeGeneratorRequest'requestedFiles struct result)
-    (Std_.pure result)
-    )
-get_CodeGeneratorRequest'capnpVersion :: ((Untyped.ReadCtx m msg)
-                                         ,(Classes.FromPtr msg (CapnpVersion msg))) => (CodeGeneratorRequest msg) -> (m (CapnpVersion msg))
-get_CodeGeneratorRequest'capnpVersion (CodeGeneratorRequest'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 2 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_CodeGeneratorRequest'capnpVersion :: ((Untyped.RWCtx m s)
-                                         ,(Classes.ToPtr s (CapnpVersion (Message.Mut s)))) => (CodeGeneratorRequest (Message.Mut s)) -> (CapnpVersion (Message.Mut s)) -> (m ())
-set_CodeGeneratorRequest'capnpVersion (CodeGeneratorRequest'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 2 struct)
-    )
-has_CodeGeneratorRequest'capnpVersion :: ((Untyped.ReadCtx m msg)) => (CodeGeneratorRequest msg) -> (m Std_.Bool)
-has_CodeGeneratorRequest'capnpVersion (CodeGeneratorRequest'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 2 struct))
-new_CodeGeneratorRequest'capnpVersion :: ((Untyped.RWCtx m s)) => (CodeGeneratorRequest (Message.Mut s)) -> (m (CapnpVersion (Message.Mut s)))
-new_CodeGeneratorRequest'capnpVersion struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_CodeGeneratorRequest'capnpVersion struct result)
-    (Std_.pure result)
-    )
-get_CodeGeneratorRequest'sourceInfo :: ((Untyped.ReadCtx m msg)
-                                       ,(Classes.FromPtr msg (Basics.List msg (Node'SourceInfo msg)))) => (CodeGeneratorRequest msg) -> (m (Basics.List msg (Node'SourceInfo msg)))
-get_CodeGeneratorRequest'sourceInfo (CodeGeneratorRequest'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 3 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_CodeGeneratorRequest'sourceInfo :: ((Untyped.RWCtx m s)
-                                       ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Node'SourceInfo (Message.Mut s))))) => (CodeGeneratorRequest (Message.Mut s)) -> (Basics.List (Message.Mut s) (Node'SourceInfo (Message.Mut s))) -> (m ())
-set_CodeGeneratorRequest'sourceInfo (CodeGeneratorRequest'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 3 struct)
-    )
-has_CodeGeneratorRequest'sourceInfo :: ((Untyped.ReadCtx m msg)) => (CodeGeneratorRequest msg) -> (m Std_.Bool)
-has_CodeGeneratorRequest'sourceInfo (CodeGeneratorRequest'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 3 struct))
-new_CodeGeneratorRequest'sourceInfo :: ((Untyped.RWCtx m s)) => Std_.Int -> (CodeGeneratorRequest (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Node'SourceInfo (Message.Mut s))))
-new_CodeGeneratorRequest'sourceInfo len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_CodeGeneratorRequest'sourceInfo struct result)
-    (Std_.pure result)
-    )
-newtype CodeGeneratorRequest'RequestedFile msg
-    = CodeGeneratorRequest'RequestedFile'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (CodeGeneratorRequest'RequestedFile msg)) where
-    fromStruct struct = (Std_.pure (CodeGeneratorRequest'RequestedFile'newtype_ struct))
-instance (Classes.ToStruct msg (CodeGeneratorRequest'RequestedFile msg)) where
-    toStruct (CodeGeneratorRequest'RequestedFile'newtype_ struct) = struct
-instance (Untyped.HasMessage (CodeGeneratorRequest'RequestedFile mut) mut) where
-    message (CodeGeneratorRequest'RequestedFile'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (CodeGeneratorRequest'RequestedFile mut) mut) where
-    messageDefault msg = (CodeGeneratorRequest'RequestedFile'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (CodeGeneratorRequest'RequestedFile msg)) where
-    fromPtr msg ptr = (CodeGeneratorRequest'RequestedFile'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (CodeGeneratorRequest'RequestedFile (Message.Mut s))) where
-    toPtr msg (CodeGeneratorRequest'RequestedFile'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (CodeGeneratorRequest'RequestedFile (Message.Mut s))) where
-    new msg = (CodeGeneratorRequest'RequestedFile'newtype_ <$> (Untyped.allocStruct msg 1 2))
-instance (Basics.ListElem mut (CodeGeneratorRequest'RequestedFile mut)) where
-    newtype List mut (CodeGeneratorRequest'RequestedFile mut)
-        = CodeGeneratorRequest'RequestedFile'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (CodeGeneratorRequest'RequestedFile'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (CodeGeneratorRequest'RequestedFile'List_ l) = (Untyped.ListStruct l)
-    length (CodeGeneratorRequest'RequestedFile'List_ l) = (Untyped.length l)
-    index i (CodeGeneratorRequest'RequestedFile'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (CodeGeneratorRequest'RequestedFile (Message.Mut s))) where
-    setIndex (CodeGeneratorRequest'RequestedFile'newtype_ elt) i (CodeGeneratorRequest'RequestedFile'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (CodeGeneratorRequest'RequestedFile'List_ <$> (Untyped.allocCompositeList msg 1 2 len))
-get_CodeGeneratorRequest'RequestedFile'id :: ((Untyped.ReadCtx m msg)) => (CodeGeneratorRequest'RequestedFile msg) -> (m Std_.Word64)
-get_CodeGeneratorRequest'RequestedFile'id (CodeGeneratorRequest'RequestedFile'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_CodeGeneratorRequest'RequestedFile'id :: ((Untyped.RWCtx m s)) => (CodeGeneratorRequest'RequestedFile (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_CodeGeneratorRequest'RequestedFile'id (CodeGeneratorRequest'RequestedFile'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 0 0 0)
-get_CodeGeneratorRequest'RequestedFile'filename :: ((Untyped.ReadCtx m msg)
-                                                   ,(Classes.FromPtr msg (Basics.Text msg))) => (CodeGeneratorRequest'RequestedFile msg) -> (m (Basics.Text msg))
-get_CodeGeneratorRequest'RequestedFile'filename (CodeGeneratorRequest'RequestedFile'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_CodeGeneratorRequest'RequestedFile'filename :: ((Untyped.RWCtx m s)
-                                                   ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (CodeGeneratorRequest'RequestedFile (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_CodeGeneratorRequest'RequestedFile'filename (CodeGeneratorRequest'RequestedFile'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_CodeGeneratorRequest'RequestedFile'filename :: ((Untyped.ReadCtx m msg)) => (CodeGeneratorRequest'RequestedFile msg) -> (m Std_.Bool)
-has_CodeGeneratorRequest'RequestedFile'filename (CodeGeneratorRequest'RequestedFile'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_CodeGeneratorRequest'RequestedFile'filename :: ((Untyped.RWCtx m s)) => Std_.Int -> (CodeGeneratorRequest'RequestedFile (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_CodeGeneratorRequest'RequestedFile'filename len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_CodeGeneratorRequest'RequestedFile'filename struct result)
-    (Std_.pure result)
-    )
-get_CodeGeneratorRequest'RequestedFile'imports :: ((Untyped.ReadCtx m msg)
-                                                  ,(Classes.FromPtr msg (Basics.List msg (CodeGeneratorRequest'RequestedFile'Import msg)))) => (CodeGeneratorRequest'RequestedFile msg) -> (m (Basics.List msg (CodeGeneratorRequest'RequestedFile'Import msg)))
-get_CodeGeneratorRequest'RequestedFile'imports (CodeGeneratorRequest'RequestedFile'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_CodeGeneratorRequest'RequestedFile'imports :: ((Untyped.RWCtx m s)
-                                                  ,(Classes.ToPtr s (Basics.List (Message.Mut s) (CodeGeneratorRequest'RequestedFile'Import (Message.Mut s))))) => (CodeGeneratorRequest'RequestedFile (Message.Mut s)) -> (Basics.List (Message.Mut s) (CodeGeneratorRequest'RequestedFile'Import (Message.Mut s))) -> (m ())
-set_CodeGeneratorRequest'RequestedFile'imports (CodeGeneratorRequest'RequestedFile'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_CodeGeneratorRequest'RequestedFile'imports :: ((Untyped.ReadCtx m msg)) => (CodeGeneratorRequest'RequestedFile msg) -> (m Std_.Bool)
-has_CodeGeneratorRequest'RequestedFile'imports (CodeGeneratorRequest'RequestedFile'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_CodeGeneratorRequest'RequestedFile'imports :: ((Untyped.RWCtx m s)) => Std_.Int -> (CodeGeneratorRequest'RequestedFile (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (CodeGeneratorRequest'RequestedFile'Import (Message.Mut s))))
-new_CodeGeneratorRequest'RequestedFile'imports len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_CodeGeneratorRequest'RequestedFile'imports struct result)
-    (Std_.pure result)
-    )
-newtype CodeGeneratorRequest'RequestedFile'Import msg
-    = CodeGeneratorRequest'RequestedFile'Import'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (CodeGeneratorRequest'RequestedFile'Import msg)) where
-    fromStruct struct = (Std_.pure (CodeGeneratorRequest'RequestedFile'Import'newtype_ struct))
-instance (Classes.ToStruct msg (CodeGeneratorRequest'RequestedFile'Import msg)) where
-    toStruct (CodeGeneratorRequest'RequestedFile'Import'newtype_ struct) = struct
-instance (Untyped.HasMessage (CodeGeneratorRequest'RequestedFile'Import mut) mut) where
-    message (CodeGeneratorRequest'RequestedFile'Import'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (CodeGeneratorRequest'RequestedFile'Import mut) mut) where
-    messageDefault msg = (CodeGeneratorRequest'RequestedFile'Import'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (CodeGeneratorRequest'RequestedFile'Import msg)) where
-    fromPtr msg ptr = (CodeGeneratorRequest'RequestedFile'Import'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (CodeGeneratorRequest'RequestedFile'Import (Message.Mut s))) where
-    toPtr msg (CodeGeneratorRequest'RequestedFile'Import'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (CodeGeneratorRequest'RequestedFile'Import (Message.Mut s))) where
-    new msg = (CodeGeneratorRequest'RequestedFile'Import'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (CodeGeneratorRequest'RequestedFile'Import mut)) where
-    newtype List mut (CodeGeneratorRequest'RequestedFile'Import mut)
-        = CodeGeneratorRequest'RequestedFile'Import'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (CodeGeneratorRequest'RequestedFile'Import'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (CodeGeneratorRequest'RequestedFile'Import'List_ l) = (Untyped.ListStruct l)
-    length (CodeGeneratorRequest'RequestedFile'Import'List_ l) = (Untyped.length l)
-    index i (CodeGeneratorRequest'RequestedFile'Import'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (CodeGeneratorRequest'RequestedFile'Import (Message.Mut s))) where
-    setIndex (CodeGeneratorRequest'RequestedFile'Import'newtype_ elt) i (CodeGeneratorRequest'RequestedFile'Import'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (CodeGeneratorRequest'RequestedFile'Import'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-get_CodeGeneratorRequest'RequestedFile'Import'id :: ((Untyped.ReadCtx m msg)) => (CodeGeneratorRequest'RequestedFile'Import msg) -> (m Std_.Word64)
-get_CodeGeneratorRequest'RequestedFile'Import'id (CodeGeneratorRequest'RequestedFile'Import'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_CodeGeneratorRequest'RequestedFile'Import'id :: ((Untyped.RWCtx m s)) => (CodeGeneratorRequest'RequestedFile'Import (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_CodeGeneratorRequest'RequestedFile'Import'id (CodeGeneratorRequest'RequestedFile'Import'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 0 0 0)
-get_CodeGeneratorRequest'RequestedFile'Import'name :: ((Untyped.ReadCtx m msg)
-                                                      ,(Classes.FromPtr msg (Basics.Text msg))) => (CodeGeneratorRequest'RequestedFile'Import msg) -> (m (Basics.Text msg))
-get_CodeGeneratorRequest'RequestedFile'Import'name (CodeGeneratorRequest'RequestedFile'Import'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_CodeGeneratorRequest'RequestedFile'Import'name :: ((Untyped.RWCtx m s)
-                                                      ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (CodeGeneratorRequest'RequestedFile'Import (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_CodeGeneratorRequest'RequestedFile'Import'name (CodeGeneratorRequest'RequestedFile'Import'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_CodeGeneratorRequest'RequestedFile'Import'name :: ((Untyped.ReadCtx m msg)) => (CodeGeneratorRequest'RequestedFile'Import msg) -> (m Std_.Bool)
-has_CodeGeneratorRequest'RequestedFile'Import'name (CodeGeneratorRequest'RequestedFile'Import'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_CodeGeneratorRequest'RequestedFile'Import'name :: ((Untyped.RWCtx m s)) => Std_.Int -> (CodeGeneratorRequest'RequestedFile'Import (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_CodeGeneratorRequest'RequestedFile'Import'name len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_CodeGeneratorRequest'RequestedFile'Import'name struct result)
-    (Std_.pure result)
-    )
diff --git a/gen/lib/Capnp/Gen/Capnp/Schema/New.hs b/gen/lib/Capnp/Gen/Capnp/Schema/New.hs
--- a/gen/lib/Capnp/Gen/Capnp/Schema/New.hs
+++ b/gen/lib/Capnp/Gen/Capnp/Schema/New.hs
@@ -27,7 +27,6 @@
 import qualified Capnp.GenHelpers.New as GH
 import qualified Capnp.New.Classes as C
 import qualified GHC.Generics as Generics
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
 import qualified Prelude as Std_
 import qualified Data.Word as Std_
 import qualified Data.Int as Std_
diff --git a/gen/lib/Capnp/Gen/Capnp/Schema/Pure.hs b/gen/lib/Capnp/Gen/Capnp/Schema/Pure.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/Capnp/Schema/Pure.hs
+++ /dev/null
@@ -1,1685 +0,0 @@
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE RecordWildCards #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Capnp.Schema.Pure(Capnp.Gen.ById.Xa93fc509624c72d9.ElementSize(..)
-                                  ,Node(..)
-                                  ,Node'(..)
-                                  ,Node'struct(..)
-                                  ,Node'enum(..)
-                                  ,Node'interface(..)
-                                  ,Node'const(..)
-                                  ,Node'annotation(..)
-                                  ,Node'Parameter(..)
-                                  ,Node'NestedNode(..)
-                                  ,Node'SourceInfo(..)
-                                  ,Node'SourceInfo'Member(..)
-                                  ,Field(..)
-                                  ,Field'(..)
-                                  ,Field'slot(..)
-                                  ,Field'group(..)
-                                  ,Field'ordinal(..)
-                                  ,Capnp.Gen.ById.Xa93fc509624c72d9.field'noDiscriminant
-                                  ,Enumerant(..)
-                                  ,Superclass(..)
-                                  ,Method(..)
-                                  ,Type(..)
-                                  ,Type'list(..)
-                                  ,Type'enum(..)
-                                  ,Type'struct(..)
-                                  ,Type'interface(..)
-                                  ,Type'anyPointer(..)
-                                  ,Type'anyPointer'unconstrained(..)
-                                  ,Type'anyPointer'parameter(..)
-                                  ,Type'anyPointer'implicitMethodParameter(..)
-                                  ,Brand(..)
-                                  ,Brand'Scope(..)
-                                  ,Brand'Scope'(..)
-                                  ,Brand'Binding(..)
-                                  ,Value(..)
-                                  ,Annotation(..)
-                                  ,CapnpVersion(..)
-                                  ,CodeGeneratorRequest(..)
-                                  ,CodeGeneratorRequest'RequestedFile(..)
-                                  ,CodeGeneratorRequest'RequestedFile'Import(..)) where
-import qualified Capnp.GenHelpers.ReExports.Data.Vector as V
-import qualified Capnp.GenHelpers.ReExports.Data.Text as T
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Capnp.GenHelpers.ReExports.Data.Default as Default
-import qualified GHC.Generics as Generics
-import qualified Control.Monad.IO.Class as MonadIO
-import qualified Capnp.Untyped.Pure as UntypedPure
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Message as Message
-import qualified Capnp.Classes as Classes
-import qualified Capnp.Basics.Pure as BasicsPure
-import qualified Capnp.GenHelpers.Pure as GenHelpersPure
-import qualified Capnp.Gen.ById.Xa93fc509624c72d9
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-data Node 
-    = Node 
-        {id :: Std_.Word64
-        ,displayName :: T.Text
-        ,displayNamePrefixLength :: Std_.Word32
-        ,scopeId :: Std_.Word64
-        ,nestedNodes :: (V.Vector Node'NestedNode)
-        ,annotations :: (V.Vector Annotation)
-        ,parameters :: (V.Vector Node'Parameter)
-        ,isGeneric :: Std_.Bool
-        ,union' :: Node'}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Node) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Node) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Node) where
-    type Cerial msg Node = (Capnp.Gen.ById.Xa93fc509624c72d9.Node msg)
-    decerialize raw = (Node <$> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'id raw)
-                            <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'displayName raw) >>= Classes.decerialize)
-                            <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'displayNamePrefixLength raw)
-                            <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'scopeId raw)
-                            <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'nestedNodes raw) >>= Classes.decerialize)
-                            <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'annotations raw) >>= Classes.decerialize)
-                            <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'parameters raw) >>= Classes.decerialize)
-                            <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'isGeneric raw)
-                            <*> (Classes.decerialize raw))
-instance (Classes.Marshal s Node) where
-    marshalInto raw_ value_ = case value_ of
-        Node{..} ->
-            (do
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'id raw_ id)
-                ((Classes.cerialize (Untyped.message raw_) displayName) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'displayName raw_))
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'displayNamePrefixLength raw_ displayNamePrefixLength)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'scopeId raw_ scopeId)
-                ((Classes.cerialize (Untyped.message raw_) nestedNodes) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'nestedNodes raw_))
-                ((Classes.cerialize (Untyped.message raw_) annotations) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'annotations raw_))
-                ((Classes.cerialize (Untyped.message raw_) parameters) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'parameters raw_))
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'isGeneric raw_ isGeneric)
-                (do
-                    (Classes.marshalInto raw_ union')
-                    )
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Node)
-instance (Classes.Cerialize s (V.Vector Node)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Node))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Node)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Node))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Node)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Node))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Node)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Node' 
-    = Node'file 
-    | Node'struct Node'struct
-    | Node'enum Node'enum
-    | Node'interface Node'interface
-    | Node'const Node'const
-    | Node'annotation Node'annotation
-    | Node'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Node') where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Node') where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Node') where
-    type Cerial msg Node' = (Capnp.Gen.ById.Xa93fc509624c72d9.Node msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node' raw)
-        case raw of
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Node'file) ->
-                (Std_.pure Node'file)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Node'struct raw) ->
-                (Node'struct <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Node'enum raw) ->
-                (Node'enum <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Node'interface raw) ->
-                (Node'interface <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Node'const raw) ->
-                (Node'const <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Node'annotation raw) ->
-                (Node'annotation <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Node'unknown' tag) ->
-                (Std_.pure (Node'unknown' tag))
-        )
-instance (Classes.Marshal s Node') where
-    marshalInto raw_ value_ = case value_ of
-        (Node'file) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'file raw_)
-        (Node'struct arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'struct raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Node'enum arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'enum raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Node'interface arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'interface raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Node'const arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'const raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Node'annotation arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'annotation raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Node'unknown' tag) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'unknown' raw_ tag)
-data Node'struct 
-    = Node'struct' 
-        {dataWordCount :: Std_.Word16
-        ,pointerCount :: Std_.Word16
-        ,preferredListEncoding :: Capnp.Gen.ById.Xa93fc509624c72d9.ElementSize
-        ,isGroup :: Std_.Bool
-        ,discriminantCount :: Std_.Word16
-        ,discriminantOffset :: Std_.Word32
-        ,fields :: (V.Vector Field)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Node'struct) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Node'struct) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Node'struct) where
-    type Cerial msg Node'struct = (Capnp.Gen.ById.Xa93fc509624c72d9.Node'struct msg)
-    decerialize raw = (Node'struct' <$> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'struct'dataWordCount raw)
-                                    <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'struct'pointerCount raw)
-                                    <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'struct'preferredListEncoding raw)
-                                    <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'struct'isGroup raw)
-                                    <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'struct'discriminantCount raw)
-                                    <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'struct'discriminantOffset raw)
-                                    <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'struct'fields raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Node'struct) where
-    marshalInto raw_ value_ = case value_ of
-        Node'struct'{..} ->
-            (do
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'struct'dataWordCount raw_ dataWordCount)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'struct'pointerCount raw_ pointerCount)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'struct'preferredListEncoding raw_ preferredListEncoding)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'struct'isGroup raw_ isGroup)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'struct'discriminantCount raw_ discriminantCount)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'struct'discriminantOffset raw_ discriminantOffset)
-                ((Classes.cerialize (Untyped.message raw_) fields) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'struct'fields raw_))
-                (Std_.pure ())
-                )
-data Node'enum 
-    = Node'enum' 
-        {enumerants :: (V.Vector Enumerant)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Node'enum) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Node'enum) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Node'enum) where
-    type Cerial msg Node'enum = (Capnp.Gen.ById.Xa93fc509624c72d9.Node'enum msg)
-    decerialize raw = (Node'enum' <$> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'enum'enumerants raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Node'enum) where
-    marshalInto raw_ value_ = case value_ of
-        Node'enum'{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) enumerants) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'enum'enumerants raw_))
-                (Std_.pure ())
-                )
-data Node'interface 
-    = Node'interface' 
-        {methods :: (V.Vector Method)
-        ,superclasses :: (V.Vector Superclass)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Node'interface) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Node'interface) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Node'interface) where
-    type Cerial msg Node'interface = (Capnp.Gen.ById.Xa93fc509624c72d9.Node'interface msg)
-    decerialize raw = (Node'interface' <$> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'interface'methods raw) >>= Classes.decerialize)
-                                       <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'interface'superclasses raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Node'interface) where
-    marshalInto raw_ value_ = case value_ of
-        Node'interface'{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) methods) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'interface'methods raw_))
-                ((Classes.cerialize (Untyped.message raw_) superclasses) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'interface'superclasses raw_))
-                (Std_.pure ())
-                )
-data Node'const 
-    = Node'const' 
-        {type_ :: Type
-        ,value :: Value}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Node'const) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Node'const) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Node'const) where
-    type Cerial msg Node'const = (Capnp.Gen.ById.Xa93fc509624c72d9.Node'const msg)
-    decerialize raw = (Node'const' <$> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'const'type_ raw) >>= Classes.decerialize)
-                                   <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'const'value raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Node'const) where
-    marshalInto raw_ value_ = case value_ of
-        Node'const'{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) type_) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'const'type_ raw_))
-                ((Classes.cerialize (Untyped.message raw_) value) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'const'value raw_))
-                (Std_.pure ())
-                )
-data Node'annotation 
-    = Node'annotation' 
-        {type_ :: Type
-        ,targetsFile :: Std_.Bool
-        ,targetsConst :: Std_.Bool
-        ,targetsEnum :: Std_.Bool
-        ,targetsEnumerant :: Std_.Bool
-        ,targetsStruct :: Std_.Bool
-        ,targetsField :: Std_.Bool
-        ,targetsUnion :: Std_.Bool
-        ,targetsGroup :: Std_.Bool
-        ,targetsInterface :: Std_.Bool
-        ,targetsMethod :: Std_.Bool
-        ,targetsParam :: Std_.Bool
-        ,targetsAnnotation :: Std_.Bool}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Node'annotation) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Node'annotation) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Node'annotation) where
-    type Cerial msg Node'annotation = (Capnp.Gen.ById.Xa93fc509624c72d9.Node'annotation msg)
-    decerialize raw = (Node'annotation' <$> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'annotation'type_ raw) >>= Classes.decerialize)
-                                        <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'annotation'targetsFile raw)
-                                        <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'annotation'targetsConst raw)
-                                        <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'annotation'targetsEnum raw)
-                                        <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'annotation'targetsEnumerant raw)
-                                        <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'annotation'targetsStruct raw)
-                                        <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'annotation'targetsField raw)
-                                        <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'annotation'targetsUnion raw)
-                                        <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'annotation'targetsGroup raw)
-                                        <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'annotation'targetsInterface raw)
-                                        <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'annotation'targetsMethod raw)
-                                        <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'annotation'targetsParam raw)
-                                        <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'annotation'targetsAnnotation raw))
-instance (Classes.Marshal s Node'annotation) where
-    marshalInto raw_ value_ = case value_ of
-        Node'annotation'{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) type_) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'annotation'type_ raw_))
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'annotation'targetsFile raw_ targetsFile)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'annotation'targetsConst raw_ targetsConst)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'annotation'targetsEnum raw_ targetsEnum)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'annotation'targetsEnumerant raw_ targetsEnumerant)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'annotation'targetsStruct raw_ targetsStruct)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'annotation'targetsField raw_ targetsField)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'annotation'targetsUnion raw_ targetsUnion)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'annotation'targetsGroup raw_ targetsGroup)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'annotation'targetsInterface raw_ targetsInterface)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'annotation'targetsMethod raw_ targetsMethod)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'annotation'targetsParam raw_ targetsParam)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'annotation'targetsAnnotation raw_ targetsAnnotation)
-                (Std_.pure ())
-                )
-data Node'Parameter 
-    = Node'Parameter 
-        {name :: T.Text}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Node'Parameter) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Node'Parameter) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Node'Parameter) where
-    type Cerial msg Node'Parameter = (Capnp.Gen.ById.Xa93fc509624c72d9.Node'Parameter msg)
-    decerialize raw = (Node'Parameter <$> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'Parameter'name raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Node'Parameter) where
-    marshalInto raw_ value_ = case value_ of
-        Node'Parameter{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) name) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'Parameter'name raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Node'Parameter)
-instance (Classes.Cerialize s (V.Vector Node'Parameter)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Node'Parameter))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Node'Parameter)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Node'Parameter))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Node'Parameter)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Node'Parameter))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Node'Parameter)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Node'NestedNode 
-    = Node'NestedNode 
-        {name :: T.Text
-        ,id :: Std_.Word64}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Node'NestedNode) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Node'NestedNode) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Node'NestedNode) where
-    type Cerial msg Node'NestedNode = (Capnp.Gen.ById.Xa93fc509624c72d9.Node'NestedNode msg)
-    decerialize raw = (Node'NestedNode <$> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'NestedNode'name raw) >>= Classes.decerialize)
-                                       <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'NestedNode'id raw))
-instance (Classes.Marshal s Node'NestedNode) where
-    marshalInto raw_ value_ = case value_ of
-        Node'NestedNode{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) name) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'NestedNode'name raw_))
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'NestedNode'id raw_ id)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Node'NestedNode)
-instance (Classes.Cerialize s (V.Vector Node'NestedNode)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Node'NestedNode))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Node'NestedNode)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Node'NestedNode))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Node'NestedNode)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Node'NestedNode))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Node'NestedNode)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Node'SourceInfo 
-    = Node'SourceInfo 
-        {id :: Std_.Word64
-        ,docComment :: T.Text
-        ,members :: (V.Vector Node'SourceInfo'Member)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Node'SourceInfo) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Node'SourceInfo) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Node'SourceInfo) where
-    type Cerial msg Node'SourceInfo = (Capnp.Gen.ById.Xa93fc509624c72d9.Node'SourceInfo msg)
-    decerialize raw = (Node'SourceInfo <$> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'SourceInfo'id raw)
-                                       <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'SourceInfo'docComment raw) >>= Classes.decerialize)
-                                       <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'SourceInfo'members raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Node'SourceInfo) where
-    marshalInto raw_ value_ = case value_ of
-        Node'SourceInfo{..} ->
-            (do
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'SourceInfo'id raw_ id)
-                ((Classes.cerialize (Untyped.message raw_) docComment) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'SourceInfo'docComment raw_))
-                ((Classes.cerialize (Untyped.message raw_) members) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'SourceInfo'members raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Node'SourceInfo)
-instance (Classes.Cerialize s (V.Vector Node'SourceInfo)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Node'SourceInfo))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Node'SourceInfo)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Node'SourceInfo))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Node'SourceInfo)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Node'SourceInfo))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Node'SourceInfo)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Node'SourceInfo'Member 
-    = Node'SourceInfo'Member 
-        {docComment :: T.Text}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Node'SourceInfo'Member) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Node'SourceInfo'Member) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Node'SourceInfo'Member) where
-    type Cerial msg Node'SourceInfo'Member = (Capnp.Gen.ById.Xa93fc509624c72d9.Node'SourceInfo'Member msg)
-    decerialize raw = (Node'SourceInfo'Member <$> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Node'SourceInfo'Member'docComment raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Node'SourceInfo'Member) where
-    marshalInto raw_ value_ = case value_ of
-        Node'SourceInfo'Member{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) docComment) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Node'SourceInfo'Member'docComment raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Node'SourceInfo'Member)
-instance (Classes.Cerialize s (V.Vector Node'SourceInfo'Member)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Node'SourceInfo'Member))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Node'SourceInfo'Member)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Node'SourceInfo'Member))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Node'SourceInfo'Member)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Node'SourceInfo'Member))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Node'SourceInfo'Member)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Field 
-    = Field 
-        {name :: T.Text
-        ,codeOrder :: Std_.Word16
-        ,annotations :: (V.Vector Annotation)
-        ,discriminantValue :: Std_.Word16
-        ,ordinal :: Field'ordinal
-        ,union' :: Field'}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Field) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Field) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Field) where
-    type Cerial msg Field = (Capnp.Gen.ById.Xa93fc509624c72d9.Field msg)
-    decerialize raw = (Field <$> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Field'name raw) >>= Classes.decerialize)
-                             <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Field'codeOrder raw)
-                             <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Field'annotations raw) >>= Classes.decerialize)
-                             <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Field'discriminantValue raw)
-                             <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Field'ordinal raw) >>= Classes.decerialize)
-                             <*> (Classes.decerialize raw))
-instance (Classes.Marshal s Field) where
-    marshalInto raw_ value_ = case value_ of
-        Field{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) name) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Field'name raw_))
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Field'codeOrder raw_ codeOrder)
-                ((Classes.cerialize (Untyped.message raw_) annotations) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Field'annotations raw_))
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Field'discriminantValue raw_ discriminantValue)
-                (do
-                    raw_ <- (Capnp.Gen.ById.Xa93fc509624c72d9.get_Field'ordinal raw_)
-                    (Classes.marshalInto raw_ ordinal)
-                    )
-                (do
-                    (Classes.marshalInto raw_ union')
-                    )
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Field)
-instance (Classes.Cerialize s (V.Vector Field)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Field))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Field)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Field))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Field)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Field))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Field)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Field' 
-    = Field'slot Field'slot
-    | Field'group Field'group
-    | Field'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Field') where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Field') where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Field') where
-    type Cerial msg Field' = (Capnp.Gen.ById.Xa93fc509624c72d9.Field msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xa93fc509624c72d9.get_Field' raw)
-        case raw of
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Field'slot raw) ->
-                (Field'slot <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Field'group raw) ->
-                (Field'group <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Field'unknown' tag) ->
-                (Std_.pure (Field'unknown' tag))
-        )
-instance (Classes.Marshal s Field') where
-    marshalInto raw_ value_ = case value_ of
-        (Field'slot arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.Xa93fc509624c72d9.set_Field'slot raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Field'group arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.Xa93fc509624c72d9.set_Field'group raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Field'unknown' tag) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Field'unknown' raw_ tag)
-data Field'slot 
-    = Field'slot' 
-        {offset :: Std_.Word32
-        ,type_ :: Type
-        ,defaultValue :: Value
-        ,hadExplicitDefault :: Std_.Bool}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Field'slot) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Field'slot) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Field'slot) where
-    type Cerial msg Field'slot = (Capnp.Gen.ById.Xa93fc509624c72d9.Field'slot msg)
-    decerialize raw = (Field'slot' <$> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Field'slot'offset raw)
-                                   <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Field'slot'type_ raw) >>= Classes.decerialize)
-                                   <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Field'slot'defaultValue raw) >>= Classes.decerialize)
-                                   <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Field'slot'hadExplicitDefault raw))
-instance (Classes.Marshal s Field'slot) where
-    marshalInto raw_ value_ = case value_ of
-        Field'slot'{..} ->
-            (do
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Field'slot'offset raw_ offset)
-                ((Classes.cerialize (Untyped.message raw_) type_) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Field'slot'type_ raw_))
-                ((Classes.cerialize (Untyped.message raw_) defaultValue) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Field'slot'defaultValue raw_))
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Field'slot'hadExplicitDefault raw_ hadExplicitDefault)
-                (Std_.pure ())
-                )
-data Field'group 
-    = Field'group' 
-        {typeId :: Std_.Word64}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Field'group) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Field'group) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Field'group) where
-    type Cerial msg Field'group = (Capnp.Gen.ById.Xa93fc509624c72d9.Field'group msg)
-    decerialize raw = (Field'group' <$> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Field'group'typeId raw))
-instance (Classes.Marshal s Field'group) where
-    marshalInto raw_ value_ = case value_ of
-        Field'group'{..} ->
-            (do
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Field'group'typeId raw_ typeId)
-                (Std_.pure ())
-                )
-data Field'ordinal 
-    = Field'ordinal'implicit 
-    | Field'ordinal'explicit Std_.Word16
-    | Field'ordinal'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Field'ordinal) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Field'ordinal) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Field'ordinal) where
-    type Cerial msg Field'ordinal = (Capnp.Gen.ById.Xa93fc509624c72d9.Field'ordinal msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xa93fc509624c72d9.get_Field'ordinal' raw)
-        case raw of
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Field'ordinal'implicit) ->
-                (Std_.pure Field'ordinal'implicit)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Field'ordinal'explicit raw) ->
-                (Std_.pure (Field'ordinal'explicit raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Field'ordinal'unknown' tag) ->
-                (Std_.pure (Field'ordinal'unknown' tag))
-        )
-instance (Classes.Marshal s Field'ordinal) where
-    marshalInto raw_ value_ = case value_ of
-        (Field'ordinal'implicit) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Field'ordinal'implicit raw_)
-        (Field'ordinal'explicit arg_) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Field'ordinal'explicit raw_ arg_)
-        (Field'ordinal'unknown' tag) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Field'ordinal'unknown' raw_ tag)
-data Enumerant 
-    = Enumerant 
-        {name :: T.Text
-        ,codeOrder :: Std_.Word16
-        ,annotations :: (V.Vector Annotation)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Enumerant) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Enumerant) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Enumerant) where
-    type Cerial msg Enumerant = (Capnp.Gen.ById.Xa93fc509624c72d9.Enumerant msg)
-    decerialize raw = (Enumerant <$> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Enumerant'name raw) >>= Classes.decerialize)
-                                 <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Enumerant'codeOrder raw)
-                                 <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Enumerant'annotations raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Enumerant) where
-    marshalInto raw_ value_ = case value_ of
-        Enumerant{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) name) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Enumerant'name raw_))
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Enumerant'codeOrder raw_ codeOrder)
-                ((Classes.cerialize (Untyped.message raw_) annotations) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Enumerant'annotations raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Enumerant)
-instance (Classes.Cerialize s (V.Vector Enumerant)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Enumerant))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Enumerant)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Enumerant))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Enumerant)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Enumerant))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Enumerant)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Superclass 
-    = Superclass 
-        {id :: Std_.Word64
-        ,brand :: Brand}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Superclass) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Superclass) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Superclass) where
-    type Cerial msg Superclass = (Capnp.Gen.ById.Xa93fc509624c72d9.Superclass msg)
-    decerialize raw = (Superclass <$> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Superclass'id raw)
-                                  <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Superclass'brand raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Superclass) where
-    marshalInto raw_ value_ = case value_ of
-        Superclass{..} ->
-            (do
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Superclass'id raw_ id)
-                ((Classes.cerialize (Untyped.message raw_) brand) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Superclass'brand raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Superclass)
-instance (Classes.Cerialize s (V.Vector Superclass)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Superclass))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Superclass)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Superclass))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Superclass)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Superclass))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Superclass)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Method 
-    = Method 
-        {name :: T.Text
-        ,codeOrder :: Std_.Word16
-        ,paramStructType :: Std_.Word64
-        ,resultStructType :: Std_.Word64
-        ,annotations :: (V.Vector Annotation)
-        ,paramBrand :: Brand
-        ,resultBrand :: Brand
-        ,implicitParameters :: (V.Vector Node'Parameter)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Method) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Method) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Method) where
-    type Cerial msg Method = (Capnp.Gen.ById.Xa93fc509624c72d9.Method msg)
-    decerialize raw = (Method <$> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Method'name raw) >>= Classes.decerialize)
-                              <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Method'codeOrder raw)
-                              <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Method'paramStructType raw)
-                              <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Method'resultStructType raw)
-                              <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Method'annotations raw) >>= Classes.decerialize)
-                              <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Method'paramBrand raw) >>= Classes.decerialize)
-                              <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Method'resultBrand raw) >>= Classes.decerialize)
-                              <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Method'implicitParameters raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Method) where
-    marshalInto raw_ value_ = case value_ of
-        Method{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) name) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Method'name raw_))
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Method'codeOrder raw_ codeOrder)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Method'paramStructType raw_ paramStructType)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Method'resultStructType raw_ resultStructType)
-                ((Classes.cerialize (Untyped.message raw_) annotations) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Method'annotations raw_))
-                ((Classes.cerialize (Untyped.message raw_) paramBrand) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Method'paramBrand raw_))
-                ((Classes.cerialize (Untyped.message raw_) resultBrand) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Method'resultBrand raw_))
-                ((Classes.cerialize (Untyped.message raw_) implicitParameters) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Method'implicitParameters raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Method)
-instance (Classes.Cerialize s (V.Vector Method)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Method))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Method)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Method))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Method)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Method))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Method)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Type 
-    = Type'void 
-    | Type'bool 
-    | Type'int8 
-    | Type'int16 
-    | Type'int32 
-    | Type'int64 
-    | Type'uint8 
-    | Type'uint16 
-    | Type'uint32 
-    | Type'uint64 
-    | Type'float32 
-    | Type'float64 
-    | Type'text 
-    | Type'data_ 
-    | Type'list Type'list
-    | Type'enum Type'enum
-    | Type'struct Type'struct
-    | Type'interface Type'interface
-    | Type'anyPointer Type'anyPointer
-    | Type'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Type) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Type) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Type) where
-    type Cerial msg Type = (Capnp.Gen.ById.Xa93fc509624c72d9.Type msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xa93fc509624c72d9.get_Type' raw)
-        case raw of
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'void) ->
-                (Std_.pure Type'void)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'bool) ->
-                (Std_.pure Type'bool)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'int8) ->
-                (Std_.pure Type'int8)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'int16) ->
-                (Std_.pure Type'int16)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'int32) ->
-                (Std_.pure Type'int32)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'int64) ->
-                (Std_.pure Type'int64)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'uint8) ->
-                (Std_.pure Type'uint8)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'uint16) ->
-                (Std_.pure Type'uint16)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'uint32) ->
-                (Std_.pure Type'uint32)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'uint64) ->
-                (Std_.pure Type'uint64)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'float32) ->
-                (Std_.pure Type'float32)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'float64) ->
-                (Std_.pure Type'float64)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'text) ->
-                (Std_.pure Type'text)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'data_) ->
-                (Std_.pure Type'data_)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'list raw) ->
-                (Type'list <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'enum raw) ->
-                (Type'enum <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'struct raw) ->
-                (Type'struct <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'interface raw) ->
-                (Type'interface <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'anyPointer raw) ->
-                (Type'anyPointer <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'unknown' tag) ->
-                (Std_.pure (Type'unknown' tag))
-        )
-instance (Classes.Marshal s Type) where
-    marshalInto raw_ value_ = case value_ of
-        (Type'void) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'void raw_)
-        (Type'bool) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'bool raw_)
-        (Type'int8) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'int8 raw_)
-        (Type'int16) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'int16 raw_)
-        (Type'int32) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'int32 raw_)
-        (Type'int64) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'int64 raw_)
-        (Type'uint8) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'uint8 raw_)
-        (Type'uint16) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'uint16 raw_)
-        (Type'uint32) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'uint32 raw_)
-        (Type'uint64) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'uint64 raw_)
-        (Type'float32) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'float32 raw_)
-        (Type'float64) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'float64 raw_)
-        (Type'text) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'text raw_)
-        (Type'data_) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'data_ raw_)
-        (Type'list arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'list raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Type'enum arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'enum raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Type'struct arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'struct raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Type'interface arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'interface raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Type'anyPointer arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'anyPointer raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Type'unknown' tag) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'unknown' raw_ tag)
-instance (Classes.Cerialize s Type)
-instance (Classes.Cerialize s (V.Vector Type)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Type))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Type)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Type))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Type)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Type))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Type)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Type'list 
-    = Type'list' 
-        {elementType :: Type}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Type'list) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Type'list) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Type'list) where
-    type Cerial msg Type'list = (Capnp.Gen.ById.Xa93fc509624c72d9.Type'list msg)
-    decerialize raw = (Type'list' <$> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Type'list'elementType raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Type'list) where
-    marshalInto raw_ value_ = case value_ of
-        Type'list'{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) elementType) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'list'elementType raw_))
-                (Std_.pure ())
-                )
-data Type'enum 
-    = Type'enum' 
-        {typeId :: Std_.Word64
-        ,brand :: Brand}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Type'enum) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Type'enum) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Type'enum) where
-    type Cerial msg Type'enum = (Capnp.Gen.ById.Xa93fc509624c72d9.Type'enum msg)
-    decerialize raw = (Type'enum' <$> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Type'enum'typeId raw)
-                                  <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Type'enum'brand raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Type'enum) where
-    marshalInto raw_ value_ = case value_ of
-        Type'enum'{..} ->
-            (do
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'enum'typeId raw_ typeId)
-                ((Classes.cerialize (Untyped.message raw_) brand) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'enum'brand raw_))
-                (Std_.pure ())
-                )
-data Type'struct 
-    = Type'struct' 
-        {typeId :: Std_.Word64
-        ,brand :: Brand}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Type'struct) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Type'struct) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Type'struct) where
-    type Cerial msg Type'struct = (Capnp.Gen.ById.Xa93fc509624c72d9.Type'struct msg)
-    decerialize raw = (Type'struct' <$> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Type'struct'typeId raw)
-                                    <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Type'struct'brand raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Type'struct) where
-    marshalInto raw_ value_ = case value_ of
-        Type'struct'{..} ->
-            (do
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'struct'typeId raw_ typeId)
-                ((Classes.cerialize (Untyped.message raw_) brand) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'struct'brand raw_))
-                (Std_.pure ())
-                )
-data Type'interface 
-    = Type'interface' 
-        {typeId :: Std_.Word64
-        ,brand :: Brand}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Type'interface) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Type'interface) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Type'interface) where
-    type Cerial msg Type'interface = (Capnp.Gen.ById.Xa93fc509624c72d9.Type'interface msg)
-    decerialize raw = (Type'interface' <$> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Type'interface'typeId raw)
-                                       <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Type'interface'brand raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Type'interface) where
-    marshalInto raw_ value_ = case value_ of
-        Type'interface'{..} ->
-            (do
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'interface'typeId raw_ typeId)
-                ((Classes.cerialize (Untyped.message raw_) brand) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'interface'brand raw_))
-                (Std_.pure ())
-                )
-data Type'anyPointer 
-    = Type'anyPointer'unconstrained Type'anyPointer'unconstrained
-    | Type'anyPointer'parameter Type'anyPointer'parameter
-    | Type'anyPointer'implicitMethodParameter Type'anyPointer'implicitMethodParameter
-    | Type'anyPointer'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Type'anyPointer) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Type'anyPointer) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Type'anyPointer) where
-    type Cerial msg Type'anyPointer = (Capnp.Gen.ById.Xa93fc509624c72d9.Type'anyPointer msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xa93fc509624c72d9.get_Type'anyPointer' raw)
-        case raw of
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'anyPointer'unconstrained raw) ->
-                (Type'anyPointer'unconstrained <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'anyPointer'parameter raw) ->
-                (Type'anyPointer'parameter <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'anyPointer'implicitMethodParameter raw) ->
-                (Type'anyPointer'implicitMethodParameter <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'anyPointer'unknown' tag) ->
-                (Std_.pure (Type'anyPointer'unknown' tag))
-        )
-instance (Classes.Marshal s Type'anyPointer) where
-    marshalInto raw_ value_ = case value_ of
-        (Type'anyPointer'unconstrained arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'anyPointer'unconstrained raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Type'anyPointer'parameter arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'anyPointer'parameter raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Type'anyPointer'implicitMethodParameter arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'anyPointer'implicitMethodParameter raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Type'anyPointer'unknown' tag) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'anyPointer'unknown' raw_ tag)
-data Type'anyPointer'unconstrained 
-    = Type'anyPointer'unconstrained'anyKind 
-    | Type'anyPointer'unconstrained'struct 
-    | Type'anyPointer'unconstrained'list 
-    | Type'anyPointer'unconstrained'capability 
-    | Type'anyPointer'unconstrained'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Type'anyPointer'unconstrained) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Type'anyPointer'unconstrained) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Type'anyPointer'unconstrained) where
-    type Cerial msg Type'anyPointer'unconstrained = (Capnp.Gen.ById.Xa93fc509624c72d9.Type'anyPointer'unconstrained msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xa93fc509624c72d9.get_Type'anyPointer'unconstrained' raw)
-        case raw of
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'anyPointer'unconstrained'anyKind) ->
-                (Std_.pure Type'anyPointer'unconstrained'anyKind)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'anyPointer'unconstrained'struct) ->
-                (Std_.pure Type'anyPointer'unconstrained'struct)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'anyPointer'unconstrained'list) ->
-                (Std_.pure Type'anyPointer'unconstrained'list)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'anyPointer'unconstrained'capability) ->
-                (Std_.pure Type'anyPointer'unconstrained'capability)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Type'anyPointer'unconstrained'unknown' tag) ->
-                (Std_.pure (Type'anyPointer'unconstrained'unknown' tag))
-        )
-instance (Classes.Marshal s Type'anyPointer'unconstrained) where
-    marshalInto raw_ value_ = case value_ of
-        (Type'anyPointer'unconstrained'anyKind) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'anyPointer'unconstrained'anyKind raw_)
-        (Type'anyPointer'unconstrained'struct) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'anyPointer'unconstrained'struct raw_)
-        (Type'anyPointer'unconstrained'list) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'anyPointer'unconstrained'list raw_)
-        (Type'anyPointer'unconstrained'capability) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'anyPointer'unconstrained'capability raw_)
-        (Type'anyPointer'unconstrained'unknown' tag) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'anyPointer'unconstrained'unknown' raw_ tag)
-data Type'anyPointer'parameter 
-    = Type'anyPointer'parameter' 
-        {scopeId :: Std_.Word64
-        ,parameterIndex :: Std_.Word16}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Type'anyPointer'parameter) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Type'anyPointer'parameter) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Type'anyPointer'parameter) where
-    type Cerial msg Type'anyPointer'parameter = (Capnp.Gen.ById.Xa93fc509624c72d9.Type'anyPointer'parameter msg)
-    decerialize raw = (Type'anyPointer'parameter' <$> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Type'anyPointer'parameter'scopeId raw)
-                                                  <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Type'anyPointer'parameter'parameterIndex raw))
-instance (Classes.Marshal s Type'anyPointer'parameter) where
-    marshalInto raw_ value_ = case value_ of
-        Type'anyPointer'parameter'{..} ->
-            (do
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'anyPointer'parameter'scopeId raw_ scopeId)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'anyPointer'parameter'parameterIndex raw_ parameterIndex)
-                (Std_.pure ())
-                )
-data Type'anyPointer'implicitMethodParameter 
-    = Type'anyPointer'implicitMethodParameter' 
-        {parameterIndex :: Std_.Word16}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Type'anyPointer'implicitMethodParameter) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Type'anyPointer'implicitMethodParameter) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Type'anyPointer'implicitMethodParameter) where
-    type Cerial msg Type'anyPointer'implicitMethodParameter = (Capnp.Gen.ById.Xa93fc509624c72d9.Type'anyPointer'implicitMethodParameter msg)
-    decerialize raw = (Type'anyPointer'implicitMethodParameter' <$> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Type'anyPointer'implicitMethodParameter'parameterIndex raw))
-instance (Classes.Marshal s Type'anyPointer'implicitMethodParameter) where
-    marshalInto raw_ value_ = case value_ of
-        Type'anyPointer'implicitMethodParameter'{..} ->
-            (do
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Type'anyPointer'implicitMethodParameter'parameterIndex raw_ parameterIndex)
-                (Std_.pure ())
-                )
-data Brand 
-    = Brand 
-        {scopes :: (V.Vector Brand'Scope)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Brand) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Brand) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Brand) where
-    type Cerial msg Brand = (Capnp.Gen.ById.Xa93fc509624c72d9.Brand msg)
-    decerialize raw = (Brand <$> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Brand'scopes raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Brand) where
-    marshalInto raw_ value_ = case value_ of
-        Brand{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) scopes) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Brand'scopes raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Brand)
-instance (Classes.Cerialize s (V.Vector Brand)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Brand))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Brand)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Brand))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Brand)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Brand))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Brand)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Brand'Scope 
-    = Brand'Scope 
-        {scopeId :: Std_.Word64
-        ,union' :: Brand'Scope'}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Brand'Scope) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Brand'Scope) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Brand'Scope) where
-    type Cerial msg Brand'Scope = (Capnp.Gen.ById.Xa93fc509624c72d9.Brand'Scope msg)
-    decerialize raw = (Brand'Scope <$> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Brand'Scope'scopeId raw)
-                                   <*> (Classes.decerialize raw))
-instance (Classes.Marshal s Brand'Scope) where
-    marshalInto raw_ value_ = case value_ of
-        Brand'Scope{..} ->
-            (do
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Brand'Scope'scopeId raw_ scopeId)
-                (do
-                    (Classes.marshalInto raw_ union')
-                    )
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Brand'Scope)
-instance (Classes.Cerialize s (V.Vector Brand'Scope)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Brand'Scope))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Brand'Scope)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Brand'Scope))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Brand'Scope)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Brand'Scope))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Brand'Scope)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Brand'Scope' 
-    = Brand'Scope'bind (V.Vector Brand'Binding)
-    | Brand'Scope'inherit 
-    | Brand'Scope'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Brand'Scope') where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Brand'Scope') where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Brand'Scope') where
-    type Cerial msg Brand'Scope' = (Capnp.Gen.ById.Xa93fc509624c72d9.Brand'Scope msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xa93fc509624c72d9.get_Brand'Scope' raw)
-        case raw of
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Brand'Scope'bind raw) ->
-                (Brand'Scope'bind <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Brand'Scope'inherit) ->
-                (Std_.pure Brand'Scope'inherit)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Brand'Scope'unknown' tag) ->
-                (Std_.pure (Brand'Scope'unknown' tag))
-        )
-instance (Classes.Marshal s Brand'Scope') where
-    marshalInto raw_ value_ = case value_ of
-        (Brand'Scope'bind arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Brand'Scope'bind raw_))
-        (Brand'Scope'inherit) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Brand'Scope'inherit raw_)
-        (Brand'Scope'unknown' tag) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Brand'Scope'unknown' raw_ tag)
-data Brand'Binding 
-    = Brand'Binding'unbound 
-    | Brand'Binding'type_ Type
-    | Brand'Binding'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Brand'Binding) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Brand'Binding) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Brand'Binding) where
-    type Cerial msg Brand'Binding = (Capnp.Gen.ById.Xa93fc509624c72d9.Brand'Binding msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xa93fc509624c72d9.get_Brand'Binding' raw)
-        case raw of
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Brand'Binding'unbound) ->
-                (Std_.pure Brand'Binding'unbound)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Brand'Binding'type_ raw) ->
-                (Brand'Binding'type_ <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Brand'Binding'unknown' tag) ->
-                (Std_.pure (Brand'Binding'unknown' tag))
-        )
-instance (Classes.Marshal s Brand'Binding) where
-    marshalInto raw_ value_ = case value_ of
-        (Brand'Binding'unbound) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Brand'Binding'unbound raw_)
-        (Brand'Binding'type_ arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Brand'Binding'type_ raw_))
-        (Brand'Binding'unknown' tag) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Brand'Binding'unknown' raw_ tag)
-instance (Classes.Cerialize s Brand'Binding)
-instance (Classes.Cerialize s (V.Vector Brand'Binding)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Brand'Binding))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Brand'Binding)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Brand'Binding))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Brand'Binding)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Brand'Binding))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Brand'Binding)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Value 
-    = Value'void 
-    | Value'bool Std_.Bool
-    | Value'int8 Std_.Int8
-    | Value'int16 Std_.Int16
-    | Value'int32 Std_.Int32
-    | Value'int64 Std_.Int64
-    | Value'uint8 Std_.Word8
-    | Value'uint16 Std_.Word16
-    | Value'uint32 Std_.Word32
-    | Value'uint64 Std_.Word64
-    | Value'float32 Std_.Float
-    | Value'float64 Std_.Double
-    | Value'text T.Text
-    | Value'data_ BS.ByteString
-    | Value'list (Std_.Maybe UntypedPure.Ptr)
-    | Value'enum Std_.Word16
-    | Value'struct (Std_.Maybe UntypedPure.Ptr)
-    | Value'interface 
-    | Value'anyPointer (Std_.Maybe UntypedPure.Ptr)
-    | Value'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Value) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Value) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Value) where
-    type Cerial msg Value = (Capnp.Gen.ById.Xa93fc509624c72d9.Value msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xa93fc509624c72d9.get_Value' raw)
-        case raw of
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'void) ->
-                (Std_.pure Value'void)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'bool raw) ->
-                (Std_.pure (Value'bool raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'int8 raw) ->
-                (Std_.pure (Value'int8 raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'int16 raw) ->
-                (Std_.pure (Value'int16 raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'int32 raw) ->
-                (Std_.pure (Value'int32 raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'int64 raw) ->
-                (Std_.pure (Value'int64 raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'uint8 raw) ->
-                (Std_.pure (Value'uint8 raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'uint16 raw) ->
-                (Std_.pure (Value'uint16 raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'uint32 raw) ->
-                (Std_.pure (Value'uint32 raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'uint64 raw) ->
-                (Std_.pure (Value'uint64 raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'float32 raw) ->
-                (Std_.pure (Value'float32 raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'float64 raw) ->
-                (Std_.pure (Value'float64 raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'text raw) ->
-                (Value'text <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'data_ raw) ->
-                (Value'data_ <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'list raw) ->
-                (Value'list <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'enum raw) ->
-                (Std_.pure (Value'enum raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'struct raw) ->
-                (Value'struct <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'interface) ->
-                (Std_.pure Value'interface)
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'anyPointer raw) ->
-                (Value'anyPointer <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xa93fc509624c72d9.Value'unknown' tag) ->
-                (Std_.pure (Value'unknown' tag))
-        )
-instance (Classes.Marshal s Value) where
-    marshalInto raw_ value_ = case value_ of
-        (Value'void) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'void raw_)
-        (Value'bool arg_) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'bool raw_ arg_)
-        (Value'int8 arg_) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'int8 raw_ arg_)
-        (Value'int16 arg_) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'int16 raw_ arg_)
-        (Value'int32 arg_) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'int32 raw_ arg_)
-        (Value'int64 arg_) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'int64 raw_ arg_)
-        (Value'uint8 arg_) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'uint8 raw_ arg_)
-        (Value'uint16 arg_) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'uint16 raw_ arg_)
-        (Value'uint32 arg_) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'uint32 raw_ arg_)
-        (Value'uint64 arg_) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'uint64 raw_ arg_)
-        (Value'float32 arg_) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'float32 raw_ arg_)
-        (Value'float64 arg_) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'float64 raw_ arg_)
-        (Value'text arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'text raw_))
-        (Value'data_ arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'data_ raw_))
-        (Value'list arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'list raw_))
-        (Value'enum arg_) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'enum raw_ arg_)
-        (Value'struct arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'struct raw_))
-        (Value'interface) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'interface raw_)
-        (Value'anyPointer arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'anyPointer raw_))
-        (Value'unknown' tag) ->
-            (Capnp.Gen.ById.Xa93fc509624c72d9.set_Value'unknown' raw_ tag)
-instance (Classes.Cerialize s Value)
-instance (Classes.Cerialize s (V.Vector Value)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Value))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Value)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Value))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Value)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Annotation 
-    = Annotation 
-        {id :: Std_.Word64
-        ,value :: Value
-        ,brand :: Brand}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Annotation) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Annotation) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Annotation) where
-    type Cerial msg Annotation = (Capnp.Gen.ById.Xa93fc509624c72d9.Annotation msg)
-    decerialize raw = (Annotation <$> (Capnp.Gen.ById.Xa93fc509624c72d9.get_Annotation'id raw)
-                                  <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Annotation'value raw) >>= Classes.decerialize)
-                                  <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_Annotation'brand raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Annotation) where
-    marshalInto raw_ value_ = case value_ of
-        Annotation{..} ->
-            (do
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_Annotation'id raw_ id)
-                ((Classes.cerialize (Untyped.message raw_) value) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Annotation'value raw_))
-                ((Classes.cerialize (Untyped.message raw_) brand) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_Annotation'brand raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Annotation)
-instance (Classes.Cerialize s (V.Vector Annotation)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Annotation))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Annotation)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Annotation))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Annotation)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Annotation))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Annotation)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data CapnpVersion 
-    = CapnpVersion 
-        {major :: Std_.Word16
-        ,minor :: Std_.Word8
-        ,micro :: Std_.Word8}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default CapnpVersion) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const CapnpVersion) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize CapnpVersion) where
-    type Cerial msg CapnpVersion = (Capnp.Gen.ById.Xa93fc509624c72d9.CapnpVersion msg)
-    decerialize raw = (CapnpVersion <$> (Capnp.Gen.ById.Xa93fc509624c72d9.get_CapnpVersion'major raw)
-                                    <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_CapnpVersion'minor raw)
-                                    <*> (Capnp.Gen.ById.Xa93fc509624c72d9.get_CapnpVersion'micro raw))
-instance (Classes.Marshal s CapnpVersion) where
-    marshalInto raw_ value_ = case value_ of
-        CapnpVersion{..} ->
-            (do
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_CapnpVersion'major raw_ major)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_CapnpVersion'minor raw_ minor)
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_CapnpVersion'micro raw_ micro)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s CapnpVersion)
-instance (Classes.Cerialize s (V.Vector CapnpVersion)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector CapnpVersion))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector CapnpVersion)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector CapnpVersion))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CapnpVersion)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CapnpVersion))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CapnpVersion)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data CodeGeneratorRequest 
-    = CodeGeneratorRequest 
-        {nodes :: (V.Vector Node)
-        ,requestedFiles :: (V.Vector CodeGeneratorRequest'RequestedFile)
-        ,capnpVersion :: CapnpVersion
-        ,sourceInfo :: (V.Vector Node'SourceInfo)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default CodeGeneratorRequest) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const CodeGeneratorRequest) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize CodeGeneratorRequest) where
-    type Cerial msg CodeGeneratorRequest = (Capnp.Gen.ById.Xa93fc509624c72d9.CodeGeneratorRequest msg)
-    decerialize raw = (CodeGeneratorRequest <$> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_CodeGeneratorRequest'nodes raw) >>= Classes.decerialize)
-                                            <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_CodeGeneratorRequest'requestedFiles raw) >>= Classes.decerialize)
-                                            <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_CodeGeneratorRequest'capnpVersion raw) >>= Classes.decerialize)
-                                            <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_CodeGeneratorRequest'sourceInfo raw) >>= Classes.decerialize))
-instance (Classes.Marshal s CodeGeneratorRequest) where
-    marshalInto raw_ value_ = case value_ of
-        CodeGeneratorRequest{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) nodes) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_CodeGeneratorRequest'nodes raw_))
-                ((Classes.cerialize (Untyped.message raw_) requestedFiles) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_CodeGeneratorRequest'requestedFiles raw_))
-                ((Classes.cerialize (Untyped.message raw_) capnpVersion) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_CodeGeneratorRequest'capnpVersion raw_))
-                ((Classes.cerialize (Untyped.message raw_) sourceInfo) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_CodeGeneratorRequest'sourceInfo raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s CodeGeneratorRequest)
-instance (Classes.Cerialize s (V.Vector CodeGeneratorRequest)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector CodeGeneratorRequest))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector CodeGeneratorRequest)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector CodeGeneratorRequest))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CodeGeneratorRequest)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CodeGeneratorRequest))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CodeGeneratorRequest)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data CodeGeneratorRequest'RequestedFile 
-    = CodeGeneratorRequest'RequestedFile 
-        {id :: Std_.Word64
-        ,filename :: T.Text
-        ,imports :: (V.Vector CodeGeneratorRequest'RequestedFile'Import)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default CodeGeneratorRequest'RequestedFile) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const CodeGeneratorRequest'RequestedFile) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize CodeGeneratorRequest'RequestedFile) where
-    type Cerial msg CodeGeneratorRequest'RequestedFile = (Capnp.Gen.ById.Xa93fc509624c72d9.CodeGeneratorRequest'RequestedFile msg)
-    decerialize raw = (CodeGeneratorRequest'RequestedFile <$> (Capnp.Gen.ById.Xa93fc509624c72d9.get_CodeGeneratorRequest'RequestedFile'id raw)
-                                                          <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_CodeGeneratorRequest'RequestedFile'filename raw) >>= Classes.decerialize)
-                                                          <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_CodeGeneratorRequest'RequestedFile'imports raw) >>= Classes.decerialize))
-instance (Classes.Marshal s CodeGeneratorRequest'RequestedFile) where
-    marshalInto raw_ value_ = case value_ of
-        CodeGeneratorRequest'RequestedFile{..} ->
-            (do
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_CodeGeneratorRequest'RequestedFile'id raw_ id)
-                ((Classes.cerialize (Untyped.message raw_) filename) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_CodeGeneratorRequest'RequestedFile'filename raw_))
-                ((Classes.cerialize (Untyped.message raw_) imports) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_CodeGeneratorRequest'RequestedFile'imports raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s CodeGeneratorRequest'RequestedFile)
-instance (Classes.Cerialize s (V.Vector CodeGeneratorRequest'RequestedFile)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector CodeGeneratorRequest'RequestedFile))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector CodeGeneratorRequest'RequestedFile)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector CodeGeneratorRequest'RequestedFile))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CodeGeneratorRequest'RequestedFile)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CodeGeneratorRequest'RequestedFile))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CodeGeneratorRequest'RequestedFile)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data CodeGeneratorRequest'RequestedFile'Import 
-    = CodeGeneratorRequest'RequestedFile'Import 
-        {id :: Std_.Word64
-        ,name :: T.Text}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default CodeGeneratorRequest'RequestedFile'Import) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const CodeGeneratorRequest'RequestedFile'Import) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize CodeGeneratorRequest'RequestedFile'Import) where
-    type Cerial msg CodeGeneratorRequest'RequestedFile'Import = (Capnp.Gen.ById.Xa93fc509624c72d9.CodeGeneratorRequest'RequestedFile'Import msg)
-    decerialize raw = (CodeGeneratorRequest'RequestedFile'Import <$> (Capnp.Gen.ById.Xa93fc509624c72d9.get_CodeGeneratorRequest'RequestedFile'Import'id raw)
-                                                                 <*> ((Capnp.Gen.ById.Xa93fc509624c72d9.get_CodeGeneratorRequest'RequestedFile'Import'name raw) >>= Classes.decerialize))
-instance (Classes.Marshal s CodeGeneratorRequest'RequestedFile'Import) where
-    marshalInto raw_ value_ = case value_ of
-        CodeGeneratorRequest'RequestedFile'Import{..} ->
-            (do
-                (Capnp.Gen.ById.Xa93fc509624c72d9.set_CodeGeneratorRequest'RequestedFile'Import'id raw_ id)
-                ((Classes.cerialize (Untyped.message raw_) name) >>= (Capnp.Gen.ById.Xa93fc509624c72d9.set_CodeGeneratorRequest'RequestedFile'Import'name raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s CodeGeneratorRequest'RequestedFile'Import)
-instance (Classes.Cerialize s (V.Vector CodeGeneratorRequest'RequestedFile'Import)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector CodeGeneratorRequest'RequestedFile'Import))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector CodeGeneratorRequest'RequestedFile'Import)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector CodeGeneratorRequest'RequestedFile'Import))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CodeGeneratorRequest'RequestedFile'Import)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CodeGeneratorRequest'RequestedFile'Import))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CodeGeneratorRequest'RequestedFile'Import)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Decerialize Capnp.Gen.ById.Xa93fc509624c72d9.ElementSize) where
-    type Cerial msg Capnp.Gen.ById.Xa93fc509624c72d9.ElementSize = Capnp.Gen.ById.Xa93fc509624c72d9.ElementSize
-    decerialize  = Std_.pure
-instance (Classes.Cerialize s Capnp.Gen.ById.Xa93fc509624c72d9.ElementSize) where
-    cerialize _ = Std_.pure
-instance (Classes.Cerialize s (V.Vector Capnp.Gen.ById.Xa93fc509624c72d9.ElementSize)) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Capnp.Gen.ById.Xa93fc509624c72d9.ElementSize))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.Xa93fc509624c72d9.ElementSize)))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.Xa93fc509624c72d9.ElementSize))))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.Xa93fc509624c72d9.ElementSize)))))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.Xa93fc509624c72d9.ElementSize))))))) where
-    cerialize  = Classes.cerializeBasicVec
diff --git a/gen/lib/Capnp/Gen/Capnp/Stream.hs b/gen/lib/Capnp/Gen/Capnp/Stream.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/Capnp/Stream.hs
+++ /dev/null
@@ -1,56 +0,0 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Capnp.Stream where
-import qualified Capnp.Message as Message
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Basics as Basics
-import qualified Capnp.GenHelpers as GenHelpers
-import qualified Capnp.Classes as Classes
-import qualified GHC.Generics as Generics
-import qualified Capnp.Bits as Std_
-import qualified Data.Maybe as Std_
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-newtype StreamResult msg
-    = StreamResult'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (StreamResult msg)) where
-    fromStruct struct = (Std_.pure (StreamResult'newtype_ struct))
-instance (Classes.ToStruct msg (StreamResult msg)) where
-    toStruct (StreamResult'newtype_ struct) = struct
-instance (Untyped.HasMessage (StreamResult mut) mut) where
-    message (StreamResult'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (StreamResult mut) mut) where
-    messageDefault msg = (StreamResult'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (StreamResult msg)) where
-    fromPtr msg ptr = (StreamResult'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (StreamResult (Message.Mut s))) where
-    toPtr msg (StreamResult'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (StreamResult (Message.Mut s))) where
-    new msg = (StreamResult'newtype_ <$> (Untyped.allocStruct msg 0 0))
-instance (Basics.ListElem mut (StreamResult mut)) where
-    newtype List mut (StreamResult mut)
-        = StreamResult'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (StreamResult'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (StreamResult'List_ l) = (Untyped.ListStruct l)
-    length (StreamResult'List_ l) = (Untyped.length l)
-    index i (StreamResult'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (StreamResult (Message.Mut s))) where
-    setIndex (StreamResult'newtype_ elt) i (StreamResult'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (StreamResult'List_ <$> (Untyped.allocCompositeList msg 0 0 len))
diff --git a/gen/lib/Capnp/Gen/Capnp/Stream/New.hs b/gen/lib/Capnp/Gen/Capnp/Stream/New.hs
--- a/gen/lib/Capnp/Gen/Capnp/Stream/New.hs
+++ b/gen/lib/Capnp/Gen/Capnp/Stream/New.hs
@@ -27,7 +27,6 @@
 import qualified Capnp.GenHelpers.New as GH
 import qualified Capnp.New.Classes as C
 import qualified GHC.Generics as Generics
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
 import qualified Prelude as Std_
 import qualified Data.Word as Std_
 import qualified Data.Int as Std_
diff --git a/gen/lib/Capnp/Gen/Capnp/Stream/Pure.hs b/gen/lib/Capnp/Gen/Capnp/Stream/Pure.hs
deleted file mode 100644
--- a/gen/lib/Capnp/Gen/Capnp/Stream/Pure.hs
+++ /dev/null
@@ -1,68 +0,0 @@
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE RecordWildCards #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Capnp.Stream.Pure(StreamResult(..)) where
-import qualified Capnp.GenHelpers.ReExports.Data.Vector as V
-import qualified Capnp.GenHelpers.ReExports.Data.Text as T
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Capnp.GenHelpers.ReExports.Data.Default as Default
-import qualified GHC.Generics as Generics
-import qualified Control.Monad.IO.Class as MonadIO
-import qualified Capnp.Untyped.Pure as UntypedPure
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Message as Message
-import qualified Capnp.Classes as Classes
-import qualified Capnp.Basics.Pure as BasicsPure
-import qualified Capnp.GenHelpers.Pure as GenHelpersPure
-import qualified Capnp.Gen.ById.X86c366a91393f3f8
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-data StreamResult 
-    = StreamResult 
-        {}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default StreamResult) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const StreamResult) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize StreamResult) where
-    type Cerial msg StreamResult = (Capnp.Gen.ById.X86c366a91393f3f8.StreamResult msg)
-    decerialize raw = (Std_.pure StreamResult)
-instance (Classes.Marshal s StreamResult) where
-    marshalInto raw_ value_ = case value_ of
-        (StreamResult) ->
-            (do
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s StreamResult)
-instance (Classes.Cerialize s (V.Vector StreamResult)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector StreamResult))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector StreamResult)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector StreamResult))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector StreamResult)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector StreamResult))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector StreamResult)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
diff --git a/gen/lib/Internal/Gen/Instances.hs b/gen/lib/Internal/Gen/Instances.hs
deleted file mode 100644
--- a/gen/lib/Internal/Gen/Instances.hs
+++ /dev/null
@@ -1,308 +0,0 @@
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-module Internal.Gen.Instances where
--- This module is auto-generated by gen-builtintypes-lists.hs; DO NOT EDIT.
-
-import Data.Int
-import Data.Word
-
-import Capnp.Classes
-    ( ListElem(..)
-    , MutListElem(..)
-    , FromPtr(..)
-    , Decerialize(..)
-    , Cerialize(..)
-    , cerializeBasicVec
-    )
-
-import qualified Capnp.Untyped as U
-import qualified Data.Vector as V
-import qualified GHC.Float as F
-
-instance ListElem msg Int8 where
-    newtype List msg Int8 = ListInt8 (U.ListOf msg Word8)
-    listFromPtr msg ptr = ListInt8 <$> fromPtr msg ptr
-    toUntypedList (ListInt8 l) = U.List8 l
-    length (ListInt8 l) = U.length l
-    index i (ListInt8 l) = fromIntegral <$> U.index i l
-instance MutListElem s Int8 where
-    setIndex elt i (ListInt8 l) = U.setIndex (fromIntegral elt) i l
-    newList msg size = ListInt8 <$> U.allocList8 msg size
-instance Decerialize Int8 where
-    type Cerial msg Int8 = Int8
-    decerialize val = pure val
-instance Cerialize s Int8 where
-    cerialize _ val = pure val
-instance Cerialize s (V.Vector Int8) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector Int8)) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector Int8))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Int8)))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Int8))))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Int8)))))) where
-    cerialize = cerializeBasicVec
-instance ListElem msg Int16 where
-    newtype List msg Int16 = ListInt16 (U.ListOf msg Word16)
-    listFromPtr msg ptr = ListInt16 <$> fromPtr msg ptr
-    toUntypedList (ListInt16 l) = U.List16 l
-    length (ListInt16 l) = U.length l
-    index i (ListInt16 l) = fromIntegral <$> U.index i l
-instance MutListElem s Int16 where
-    setIndex elt i (ListInt16 l) = U.setIndex (fromIntegral elt) i l
-    newList msg size = ListInt16 <$> U.allocList16 msg size
-instance Decerialize Int16 where
-    type Cerial msg Int16 = Int16
-    decerialize val = pure val
-instance Cerialize s Int16 where
-    cerialize _ val = pure val
-instance Cerialize s (V.Vector Int16) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector Int16)) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector Int16))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Int16)))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Int16))))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Int16)))))) where
-    cerialize = cerializeBasicVec
-instance ListElem msg Int32 where
-    newtype List msg Int32 = ListInt32 (U.ListOf msg Word32)
-    listFromPtr msg ptr = ListInt32 <$> fromPtr msg ptr
-    toUntypedList (ListInt32 l) = U.List32 l
-    length (ListInt32 l) = U.length l
-    index i (ListInt32 l) = fromIntegral <$> U.index i l
-instance MutListElem s Int32 where
-    setIndex elt i (ListInt32 l) = U.setIndex (fromIntegral elt) i l
-    newList msg size = ListInt32 <$> U.allocList32 msg size
-instance Decerialize Int32 where
-    type Cerial msg Int32 = Int32
-    decerialize val = pure val
-instance Cerialize s Int32 where
-    cerialize _ val = pure val
-instance Cerialize s (V.Vector Int32) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector Int32)) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector Int32))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Int32)))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Int32))))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Int32)))))) where
-    cerialize = cerializeBasicVec
-instance ListElem msg Int64 where
-    newtype List msg Int64 = ListInt64 (U.ListOf msg Word64)
-    listFromPtr msg ptr = ListInt64 <$> fromPtr msg ptr
-    toUntypedList (ListInt64 l) = U.List64 l
-    length (ListInt64 l) = U.length l
-    index i (ListInt64 l) = fromIntegral <$> U.index i l
-instance MutListElem s Int64 where
-    setIndex elt i (ListInt64 l) = U.setIndex (fromIntegral elt) i l
-    newList msg size = ListInt64 <$> U.allocList64 msg size
-instance Decerialize Int64 where
-    type Cerial msg Int64 = Int64
-    decerialize val = pure val
-instance Cerialize s Int64 where
-    cerialize _ val = pure val
-instance Cerialize s (V.Vector Int64) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector Int64)) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector Int64))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Int64)))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Int64))))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Int64)))))) where
-    cerialize = cerializeBasicVec
-instance ListElem msg Word8 where
-    newtype List msg Word8 = ListWord8 (U.ListOf msg Word8)
-    listFromPtr msg ptr = ListWord8 <$> fromPtr msg ptr
-    toUntypedList (ListWord8 l) = U.List8 l
-    length (ListWord8 l) = U.length l
-    index i (ListWord8 l) = id <$> U.index i l
-instance MutListElem s Word8 where
-    setIndex elt i (ListWord8 l) = U.setIndex (id elt) i l
-    newList msg size = ListWord8 <$> U.allocList8 msg size
-instance Decerialize Word8 where
-    type Cerial msg Word8 = Word8
-    decerialize val = pure val
-instance Cerialize s Word8 where
-    cerialize _ val = pure val
-instance Cerialize s (V.Vector Word8) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector Word8)) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector Word8))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Word8)))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Word8))))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Word8)))))) where
-    cerialize = cerializeBasicVec
-instance ListElem msg Word16 where
-    newtype List msg Word16 = ListWord16 (U.ListOf msg Word16)
-    listFromPtr msg ptr = ListWord16 <$> fromPtr msg ptr
-    toUntypedList (ListWord16 l) = U.List16 l
-    length (ListWord16 l) = U.length l
-    index i (ListWord16 l) = id <$> U.index i l
-instance MutListElem s Word16 where
-    setIndex elt i (ListWord16 l) = U.setIndex (id elt) i l
-    newList msg size = ListWord16 <$> U.allocList16 msg size
-instance Decerialize Word16 where
-    type Cerial msg Word16 = Word16
-    decerialize val = pure val
-instance Cerialize s Word16 where
-    cerialize _ val = pure val
-instance Cerialize s (V.Vector Word16) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector Word16)) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector Word16))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Word16)))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Word16))))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Word16)))))) where
-    cerialize = cerializeBasicVec
-instance ListElem msg Word32 where
-    newtype List msg Word32 = ListWord32 (U.ListOf msg Word32)
-    listFromPtr msg ptr = ListWord32 <$> fromPtr msg ptr
-    toUntypedList (ListWord32 l) = U.List32 l
-    length (ListWord32 l) = U.length l
-    index i (ListWord32 l) = id <$> U.index i l
-instance MutListElem s Word32 where
-    setIndex elt i (ListWord32 l) = U.setIndex (id elt) i l
-    newList msg size = ListWord32 <$> U.allocList32 msg size
-instance Decerialize Word32 where
-    type Cerial msg Word32 = Word32
-    decerialize val = pure val
-instance Cerialize s Word32 where
-    cerialize _ val = pure val
-instance Cerialize s (V.Vector Word32) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector Word32)) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector Word32))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Word32)))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Word32))))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Word32)))))) where
-    cerialize = cerializeBasicVec
-instance ListElem msg Word64 where
-    newtype List msg Word64 = ListWord64 (U.ListOf msg Word64)
-    listFromPtr msg ptr = ListWord64 <$> fromPtr msg ptr
-    toUntypedList (ListWord64 l) = U.List64 l
-    length (ListWord64 l) = U.length l
-    index i (ListWord64 l) = id <$> U.index i l
-instance MutListElem s Word64 where
-    setIndex elt i (ListWord64 l) = U.setIndex (id elt) i l
-    newList msg size = ListWord64 <$> U.allocList64 msg size
-instance Decerialize Word64 where
-    type Cerial msg Word64 = Word64
-    decerialize val = pure val
-instance Cerialize s Word64 where
-    cerialize _ val = pure val
-instance Cerialize s (V.Vector Word64) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector Word64)) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector Word64))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Word64)))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Word64))))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Word64)))))) where
-    cerialize = cerializeBasicVec
-instance ListElem msg Float where
-    newtype List msg Float = ListFloat (U.ListOf msg Word32)
-    listFromPtr msg ptr = ListFloat <$> fromPtr msg ptr
-    toUntypedList (ListFloat l) = U.List32 l
-    length (ListFloat l) = U.length l
-    index i (ListFloat l) = F.castWord32ToFloat <$> U.index i l
-instance MutListElem s Float where
-    setIndex elt i (ListFloat l) = U.setIndex (F.castFloatToWord32 elt) i l
-    newList msg size = ListFloat <$> U.allocList32 msg size
-instance Decerialize Float where
-    type Cerial msg Float = Float
-    decerialize val = pure val
-instance Cerialize s Float where
-    cerialize _ val = pure val
-instance Cerialize s (V.Vector Float) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector Float)) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector Float))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Float)))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Float))))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Float)))))) where
-    cerialize = cerializeBasicVec
-instance ListElem msg Double where
-    newtype List msg Double = ListDouble (U.ListOf msg Word64)
-    listFromPtr msg ptr = ListDouble <$> fromPtr msg ptr
-    toUntypedList (ListDouble l) = U.List64 l
-    length (ListDouble l) = U.length l
-    index i (ListDouble l) = F.castWord64ToDouble <$> U.index i l
-instance MutListElem s Double where
-    setIndex elt i (ListDouble l) = U.setIndex (F.castDoubleToWord64 elt) i l
-    newList msg size = ListDouble <$> U.allocList64 msg size
-instance Decerialize Double where
-    type Cerial msg Double = Double
-    decerialize val = pure val
-instance Cerialize s Double where
-    cerialize _ val = pure val
-instance Cerialize s (V.Vector Double) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector Double)) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector Double))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Double)))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Double))))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Double)))))) where
-    cerialize = cerializeBasicVec
-instance ListElem msg Bool where
-    newtype List msg Bool = ListBool (U.ListOf msg Bool)
-    listFromPtr msg ptr = ListBool <$> fromPtr msg ptr
-    toUntypedList (ListBool l) = U.List1 l
-    length (ListBool l) = U.length l
-    index i (ListBool l) = id <$> U.index i l
-instance MutListElem s Bool where
-    setIndex elt i (ListBool l) = U.setIndex (id elt) i l
-    newList msg size = ListBool <$> U.allocList1 msg size
-instance Decerialize Bool where
-    type Cerial msg Bool = Bool
-    decerialize val = pure val
-instance Cerialize s Bool where
-    cerialize _ val = pure val
-instance Cerialize s (V.Vector Bool) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector Bool)) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector Bool))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Bool)))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Bool))))) where
-    cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Bool)))))) where
-    cerialize = cerializeBasicVec
diff --git a/gen/tests/Capnp/Gen/Aircraft.hs b/gen/tests/Capnp/Gen/Aircraft.hs
deleted file mode 100644
--- a/gen/tests/Capnp/Gen/Aircraft.hs
+++ /dev/null
@@ -1,3721 +0,0 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Aircraft where
-import qualified Capnp.Message as Message
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Basics as Basics
-import qualified Capnp.GenHelpers as GenHelpers
-import qualified Capnp.Classes as Classes
-import qualified GHC.Generics as Generics
-import qualified Capnp.Bits as Std_
-import qualified Data.Maybe as Std_
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-constDate :: (Zdate Message.Const)
-constDate  = (GenHelpers.getPtrConst ("\NUL\NUL\NUL\NUL\ETX\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\SOH\NUL\NUL\NUL\NUL\NUL\SOH\NUL\NUL\NUL\223\a\b\ESC\NUL\NUL\NUL\NUL" :: BS.ByteString))
-constList :: (Basics.List Message.Const (Zdate Message.Const))
-constList  = (GenHelpers.getPtrConst ("\NUL\NUL\NUL\NUL\ENQ\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\SOH\NUL\SOH\NUL\NUL\NUL\ETB\NUL\NUL\NUL\b\NUL\NUL\NUL\SOH\NUL\NUL\NUL\223\a\b\ESC\NUL\NUL\NUL\NUL\223\a\b\FS\NUL\NUL\NUL\NUL" :: BS.ByteString))
-constEnum :: Airport
-constEnum  = (Classes.fromWord 1)
-newtype Zdate msg
-    = Zdate'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Zdate msg)) where
-    fromStruct struct = (Std_.pure (Zdate'newtype_ struct))
-instance (Classes.ToStruct msg (Zdate msg)) where
-    toStruct (Zdate'newtype_ struct) = struct
-instance (Untyped.HasMessage (Zdate mut) mut) where
-    message (Zdate'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Zdate mut) mut) where
-    messageDefault msg = (Zdate'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Zdate msg)) where
-    fromPtr msg ptr = (Zdate'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Zdate (Message.Mut s))) where
-    toPtr msg (Zdate'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Zdate (Message.Mut s))) where
-    new msg = (Zdate'newtype_ <$> (Untyped.allocStruct msg 1 0))
-instance (Basics.ListElem mut (Zdate mut)) where
-    newtype List mut (Zdate mut)
-        = Zdate'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Zdate'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Zdate'List_ l) = (Untyped.ListStruct l)
-    length (Zdate'List_ l) = (Untyped.length l)
-    index i (Zdate'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Zdate (Message.Mut s))) where
-    setIndex (Zdate'newtype_ elt) i (Zdate'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Zdate'List_ <$> (Untyped.allocCompositeList msg 1 0 len))
-get_Zdate'year :: ((Untyped.ReadCtx m msg)) => (Zdate msg) -> (m Std_.Int16)
-get_Zdate'year (Zdate'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Zdate'year :: ((Untyped.RWCtx m s)) => (Zdate (Message.Mut s)) -> Std_.Int16 -> (m ())
-set_Zdate'year (Zdate'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-get_Zdate'month :: ((Untyped.ReadCtx m msg)) => (Zdate msg) -> (m Std_.Word8)
-get_Zdate'month (Zdate'newtype_ struct) = (GenHelpers.getWordField struct 0 16 0)
-set_Zdate'month :: ((Untyped.RWCtx m s)) => (Zdate (Message.Mut s)) -> Std_.Word8 -> (m ())
-set_Zdate'month (Zdate'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word8) 0 16 0)
-get_Zdate'day :: ((Untyped.ReadCtx m msg)) => (Zdate msg) -> (m Std_.Word8)
-get_Zdate'day (Zdate'newtype_ struct) = (GenHelpers.getWordField struct 0 24 0)
-set_Zdate'day :: ((Untyped.RWCtx m s)) => (Zdate (Message.Mut s)) -> Std_.Word8 -> (m ())
-set_Zdate'day (Zdate'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word8) 0 24 0)
-newtype Zdata msg
-    = Zdata'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Zdata msg)) where
-    fromStruct struct = (Std_.pure (Zdata'newtype_ struct))
-instance (Classes.ToStruct msg (Zdata msg)) where
-    toStruct (Zdata'newtype_ struct) = struct
-instance (Untyped.HasMessage (Zdata mut) mut) where
-    message (Zdata'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Zdata mut) mut) where
-    messageDefault msg = (Zdata'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Zdata msg)) where
-    fromPtr msg ptr = (Zdata'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Zdata (Message.Mut s))) where
-    toPtr msg (Zdata'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Zdata (Message.Mut s))) where
-    new msg = (Zdata'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Zdata mut)) where
-    newtype List mut (Zdata mut)
-        = Zdata'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Zdata'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Zdata'List_ l) = (Untyped.ListStruct l)
-    length (Zdata'List_ l) = (Untyped.length l)
-    index i (Zdata'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Zdata (Message.Mut s))) where
-    setIndex (Zdata'newtype_ elt) i (Zdata'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Zdata'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Zdata'data_ :: ((Untyped.ReadCtx m msg)
-                   ,(Classes.FromPtr msg (Basics.Data msg))) => (Zdata msg) -> (m (Basics.Data msg))
-get_Zdata'data_ (Zdata'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Zdata'data_ :: ((Untyped.RWCtx m s)
-                   ,(Classes.ToPtr s (Basics.Data (Message.Mut s)))) => (Zdata (Message.Mut s)) -> (Basics.Data (Message.Mut s)) -> (m ())
-set_Zdata'data_ (Zdata'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Zdata'data_ :: ((Untyped.ReadCtx m msg)) => (Zdata msg) -> (m Std_.Bool)
-has_Zdata'data_ (Zdata'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Zdata'data_ :: ((Untyped.RWCtx m s)) => Std_.Int -> (Zdata (Message.Mut s)) -> (m (Basics.Data (Message.Mut s)))
-new_Zdata'data_ len struct = (do
-    result <- (Basics.newData (Untyped.message struct) len)
-    (set_Zdata'data_ struct result)
-    (Std_.pure result)
-    )
-data Airport 
-    = Airport'none 
-    | Airport'jfk 
-    | Airport'lax 
-    | Airport'sfo 
-    | Airport'luv 
-    | Airport'dfw 
-    | Airport'test 
-    | Airport'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Read
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Classes.IsWord Airport) where
-    fromWord n = case ((Std_.fromIntegral n) :: Std_.Word16) of
-        0 ->
-            Airport'none
-        1 ->
-            Airport'jfk
-        2 ->
-            Airport'lax
-        3 ->
-            Airport'sfo
-        4 ->
-            Airport'luv
-        5 ->
-            Airport'dfw
-        6 ->
-            Airport'test
-        tag ->
-            (Airport'unknown' tag)
-    toWord (Airport'none) = 0
-    toWord (Airport'jfk) = 1
-    toWord (Airport'lax) = 2
-    toWord (Airport'sfo) = 3
-    toWord (Airport'luv) = 4
-    toWord (Airport'dfw) = 5
-    toWord (Airport'test) = 6
-    toWord (Airport'unknown' tag) = (Std_.fromIntegral tag)
-instance (Std_.Enum Airport) where
-    fromEnum x = (Std_.fromIntegral (Classes.toWord x))
-    toEnum x = (Classes.fromWord (Std_.fromIntegral x))
-instance (Basics.ListElem mut Airport) where
-    newtype List mut Airport
-        = Airport'List_ (Untyped.ListOf mut Std_.Word16)
-    index i (Airport'List_ l) = (Classes.fromWord <$> (Std_.fromIntegral <$> (Untyped.index i l)))
-    listFromPtr msg ptr = (Airport'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Airport'List_ l) = (Untyped.List16 l)
-    length (Airport'List_ l) = (Untyped.length l)
-instance (Classes.MutListElem s Airport) where
-    setIndex elt i (Airport'List_ l) = (Untyped.setIndex (Std_.fromIntegral (Classes.toWord elt)) i l)
-    newList msg size = (Airport'List_ <$> (Untyped.allocList16 msg size))
-newtype PlaneBase msg
-    = PlaneBase'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (PlaneBase msg)) where
-    fromStruct struct = (Std_.pure (PlaneBase'newtype_ struct))
-instance (Classes.ToStruct msg (PlaneBase msg)) where
-    toStruct (PlaneBase'newtype_ struct) = struct
-instance (Untyped.HasMessage (PlaneBase mut) mut) where
-    message (PlaneBase'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (PlaneBase mut) mut) where
-    messageDefault msg = (PlaneBase'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (PlaneBase msg)) where
-    fromPtr msg ptr = (PlaneBase'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (PlaneBase (Message.Mut s))) where
-    toPtr msg (PlaneBase'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (PlaneBase (Message.Mut s))) where
-    new msg = (PlaneBase'newtype_ <$> (Untyped.allocStruct msg 4 2))
-instance (Basics.ListElem mut (PlaneBase mut)) where
-    newtype List mut (PlaneBase mut)
-        = PlaneBase'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (PlaneBase'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (PlaneBase'List_ l) = (Untyped.ListStruct l)
-    length (PlaneBase'List_ l) = (Untyped.length l)
-    index i (PlaneBase'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (PlaneBase (Message.Mut s))) where
-    setIndex (PlaneBase'newtype_ elt) i (PlaneBase'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (PlaneBase'List_ <$> (Untyped.allocCompositeList msg 4 2 len))
-get_PlaneBase'name :: ((Untyped.ReadCtx m msg)
-                      ,(Classes.FromPtr msg (Basics.Text msg))) => (PlaneBase msg) -> (m (Basics.Text msg))
-get_PlaneBase'name (PlaneBase'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_PlaneBase'name :: ((Untyped.RWCtx m s)
-                      ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (PlaneBase (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_PlaneBase'name (PlaneBase'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_PlaneBase'name :: ((Untyped.ReadCtx m msg)) => (PlaneBase msg) -> (m Std_.Bool)
-has_PlaneBase'name (PlaneBase'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_PlaneBase'name :: ((Untyped.RWCtx m s)) => Std_.Int -> (PlaneBase (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_PlaneBase'name len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_PlaneBase'name struct result)
-    (Std_.pure result)
-    )
-get_PlaneBase'homes :: ((Untyped.ReadCtx m msg)
-                       ,(Classes.FromPtr msg (Basics.List msg Airport))) => (PlaneBase msg) -> (m (Basics.List msg Airport))
-get_PlaneBase'homes (PlaneBase'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_PlaneBase'homes :: ((Untyped.RWCtx m s)
-                       ,(Classes.ToPtr s (Basics.List (Message.Mut s) Airport))) => (PlaneBase (Message.Mut s)) -> (Basics.List (Message.Mut s) Airport) -> (m ())
-set_PlaneBase'homes (PlaneBase'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_PlaneBase'homes :: ((Untyped.ReadCtx m msg)) => (PlaneBase msg) -> (m Std_.Bool)
-has_PlaneBase'homes (PlaneBase'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_PlaneBase'homes :: ((Untyped.RWCtx m s)) => Std_.Int -> (PlaneBase (Message.Mut s)) -> (m (Basics.List (Message.Mut s) Airport))
-new_PlaneBase'homes len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_PlaneBase'homes struct result)
-    (Std_.pure result)
-    )
-get_PlaneBase'rating :: ((Untyped.ReadCtx m msg)) => (PlaneBase msg) -> (m Std_.Int64)
-get_PlaneBase'rating (PlaneBase'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_PlaneBase'rating :: ((Untyped.RWCtx m s)) => (PlaneBase (Message.Mut s)) -> Std_.Int64 -> (m ())
-set_PlaneBase'rating (PlaneBase'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 0 0 0)
-get_PlaneBase'canFly :: ((Untyped.ReadCtx m msg)) => (PlaneBase msg) -> (m Std_.Bool)
-get_PlaneBase'canFly (PlaneBase'newtype_ struct) = (GenHelpers.getWordField struct 1 0 0)
-set_PlaneBase'canFly :: ((Untyped.RWCtx m s)) => (PlaneBase (Message.Mut s)) -> Std_.Bool -> (m ())
-set_PlaneBase'canFly (PlaneBase'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 1 0 0)
-get_PlaneBase'capacity :: ((Untyped.ReadCtx m msg)) => (PlaneBase msg) -> (m Std_.Int64)
-get_PlaneBase'capacity (PlaneBase'newtype_ struct) = (GenHelpers.getWordField struct 2 0 0)
-set_PlaneBase'capacity :: ((Untyped.RWCtx m s)) => (PlaneBase (Message.Mut s)) -> Std_.Int64 -> (m ())
-set_PlaneBase'capacity (PlaneBase'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 2 0 0)
-get_PlaneBase'maxSpeed :: ((Untyped.ReadCtx m msg)) => (PlaneBase msg) -> (m Std_.Double)
-get_PlaneBase'maxSpeed (PlaneBase'newtype_ struct) = (GenHelpers.getWordField struct 3 0 0)
-set_PlaneBase'maxSpeed :: ((Untyped.RWCtx m s)) => (PlaneBase (Message.Mut s)) -> Std_.Double -> (m ())
-set_PlaneBase'maxSpeed (PlaneBase'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 3 0 0)
-newtype B737 msg
-    = B737'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (B737 msg)) where
-    fromStruct struct = (Std_.pure (B737'newtype_ struct))
-instance (Classes.ToStruct msg (B737 msg)) where
-    toStruct (B737'newtype_ struct) = struct
-instance (Untyped.HasMessage (B737 mut) mut) where
-    message (B737'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (B737 mut) mut) where
-    messageDefault msg = (B737'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (B737 msg)) where
-    fromPtr msg ptr = (B737'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (B737 (Message.Mut s))) where
-    toPtr msg (B737'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (B737 (Message.Mut s))) where
-    new msg = (B737'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (B737 mut)) where
-    newtype List mut (B737 mut)
-        = B737'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (B737'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (B737'List_ l) = (Untyped.ListStruct l)
-    length (B737'List_ l) = (Untyped.length l)
-    index i (B737'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (B737 (Message.Mut s))) where
-    setIndex (B737'newtype_ elt) i (B737'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (B737'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_B737'base :: ((Untyped.ReadCtx m msg)
-                 ,(Classes.FromPtr msg (PlaneBase msg))) => (B737 msg) -> (m (PlaneBase msg))
-get_B737'base (B737'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_B737'base :: ((Untyped.RWCtx m s)
-                 ,(Classes.ToPtr s (PlaneBase (Message.Mut s)))) => (B737 (Message.Mut s)) -> (PlaneBase (Message.Mut s)) -> (m ())
-set_B737'base (B737'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_B737'base :: ((Untyped.ReadCtx m msg)) => (B737 msg) -> (m Std_.Bool)
-has_B737'base (B737'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_B737'base :: ((Untyped.RWCtx m s)) => (B737 (Message.Mut s)) -> (m (PlaneBase (Message.Mut s)))
-new_B737'base struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_B737'base struct result)
-    (Std_.pure result)
-    )
-newtype A320 msg
-    = A320'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (A320 msg)) where
-    fromStruct struct = (Std_.pure (A320'newtype_ struct))
-instance (Classes.ToStruct msg (A320 msg)) where
-    toStruct (A320'newtype_ struct) = struct
-instance (Untyped.HasMessage (A320 mut) mut) where
-    message (A320'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (A320 mut) mut) where
-    messageDefault msg = (A320'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (A320 msg)) where
-    fromPtr msg ptr = (A320'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (A320 (Message.Mut s))) where
-    toPtr msg (A320'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (A320 (Message.Mut s))) where
-    new msg = (A320'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (A320 mut)) where
-    newtype List mut (A320 mut)
-        = A320'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (A320'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (A320'List_ l) = (Untyped.ListStruct l)
-    length (A320'List_ l) = (Untyped.length l)
-    index i (A320'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (A320 (Message.Mut s))) where
-    setIndex (A320'newtype_ elt) i (A320'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (A320'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_A320'base :: ((Untyped.ReadCtx m msg)
-                 ,(Classes.FromPtr msg (PlaneBase msg))) => (A320 msg) -> (m (PlaneBase msg))
-get_A320'base (A320'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_A320'base :: ((Untyped.RWCtx m s)
-                 ,(Classes.ToPtr s (PlaneBase (Message.Mut s)))) => (A320 (Message.Mut s)) -> (PlaneBase (Message.Mut s)) -> (m ())
-set_A320'base (A320'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_A320'base :: ((Untyped.ReadCtx m msg)) => (A320 msg) -> (m Std_.Bool)
-has_A320'base (A320'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_A320'base :: ((Untyped.RWCtx m s)) => (A320 (Message.Mut s)) -> (m (PlaneBase (Message.Mut s)))
-new_A320'base struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_A320'base struct result)
-    (Std_.pure result)
-    )
-newtype F16 msg
-    = F16'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (F16 msg)) where
-    fromStruct struct = (Std_.pure (F16'newtype_ struct))
-instance (Classes.ToStruct msg (F16 msg)) where
-    toStruct (F16'newtype_ struct) = struct
-instance (Untyped.HasMessage (F16 mut) mut) where
-    message (F16'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (F16 mut) mut) where
-    messageDefault msg = (F16'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (F16 msg)) where
-    fromPtr msg ptr = (F16'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (F16 (Message.Mut s))) where
-    toPtr msg (F16'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (F16 (Message.Mut s))) where
-    new msg = (F16'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (F16 mut)) where
-    newtype List mut (F16 mut)
-        = F16'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (F16'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (F16'List_ l) = (Untyped.ListStruct l)
-    length (F16'List_ l) = (Untyped.length l)
-    index i (F16'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (F16 (Message.Mut s))) where
-    setIndex (F16'newtype_ elt) i (F16'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (F16'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_F16'base :: ((Untyped.ReadCtx m msg)
-                ,(Classes.FromPtr msg (PlaneBase msg))) => (F16 msg) -> (m (PlaneBase msg))
-get_F16'base (F16'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_F16'base :: ((Untyped.RWCtx m s)
-                ,(Classes.ToPtr s (PlaneBase (Message.Mut s)))) => (F16 (Message.Mut s)) -> (PlaneBase (Message.Mut s)) -> (m ())
-set_F16'base (F16'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_F16'base :: ((Untyped.ReadCtx m msg)) => (F16 msg) -> (m Std_.Bool)
-has_F16'base (F16'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_F16'base :: ((Untyped.RWCtx m s)) => (F16 (Message.Mut s)) -> (m (PlaneBase (Message.Mut s)))
-new_F16'base struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_F16'base struct result)
-    (Std_.pure result)
-    )
-newtype Regression msg
-    = Regression'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Regression msg)) where
-    fromStruct struct = (Std_.pure (Regression'newtype_ struct))
-instance (Classes.ToStruct msg (Regression msg)) where
-    toStruct (Regression'newtype_ struct) = struct
-instance (Untyped.HasMessage (Regression mut) mut) where
-    message (Regression'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Regression mut) mut) where
-    messageDefault msg = (Regression'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Regression msg)) where
-    fromPtr msg ptr = (Regression'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Regression (Message.Mut s))) where
-    toPtr msg (Regression'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Regression (Message.Mut s))) where
-    new msg = (Regression'newtype_ <$> (Untyped.allocStruct msg 3 3))
-instance (Basics.ListElem mut (Regression mut)) where
-    newtype List mut (Regression mut)
-        = Regression'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Regression'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Regression'List_ l) = (Untyped.ListStruct l)
-    length (Regression'List_ l) = (Untyped.length l)
-    index i (Regression'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Regression (Message.Mut s))) where
-    setIndex (Regression'newtype_ elt) i (Regression'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Regression'List_ <$> (Untyped.allocCompositeList msg 3 3 len))
-get_Regression'base :: ((Untyped.ReadCtx m msg)
-                       ,(Classes.FromPtr msg (PlaneBase msg))) => (Regression msg) -> (m (PlaneBase msg))
-get_Regression'base (Regression'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Regression'base :: ((Untyped.RWCtx m s)
-                       ,(Classes.ToPtr s (PlaneBase (Message.Mut s)))) => (Regression (Message.Mut s)) -> (PlaneBase (Message.Mut s)) -> (m ())
-set_Regression'base (Regression'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Regression'base :: ((Untyped.ReadCtx m msg)) => (Regression msg) -> (m Std_.Bool)
-has_Regression'base (Regression'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Regression'base :: ((Untyped.RWCtx m s)) => (Regression (Message.Mut s)) -> (m (PlaneBase (Message.Mut s)))
-new_Regression'base struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Regression'base struct result)
-    (Std_.pure result)
-    )
-get_Regression'b0 :: ((Untyped.ReadCtx m msg)) => (Regression msg) -> (m Std_.Double)
-get_Regression'b0 (Regression'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Regression'b0 :: ((Untyped.RWCtx m s)) => (Regression (Message.Mut s)) -> Std_.Double -> (m ())
-set_Regression'b0 (Regression'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 0 0 0)
-get_Regression'beta :: ((Untyped.ReadCtx m msg)
-                       ,(Classes.FromPtr msg (Basics.List msg Std_.Double))) => (Regression msg) -> (m (Basics.List msg Std_.Double))
-get_Regression'beta (Regression'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Regression'beta :: ((Untyped.RWCtx m s)
-                       ,(Classes.ToPtr s (Basics.List (Message.Mut s) Std_.Double))) => (Regression (Message.Mut s)) -> (Basics.List (Message.Mut s) Std_.Double) -> (m ())
-set_Regression'beta (Regression'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Regression'beta :: ((Untyped.ReadCtx m msg)) => (Regression msg) -> (m Std_.Bool)
-has_Regression'beta (Regression'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_Regression'beta :: ((Untyped.RWCtx m s)) => Std_.Int -> (Regression (Message.Mut s)) -> (m (Basics.List (Message.Mut s) Std_.Double))
-new_Regression'beta len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Regression'beta struct result)
-    (Std_.pure result)
-    )
-get_Regression'planes :: ((Untyped.ReadCtx m msg)
-                         ,(Classes.FromPtr msg (Basics.List msg (Aircraft msg)))) => (Regression msg) -> (m (Basics.List msg (Aircraft msg)))
-get_Regression'planes (Regression'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 2 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Regression'planes :: ((Untyped.RWCtx m s)
-                         ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Aircraft (Message.Mut s))))) => (Regression (Message.Mut s)) -> (Basics.List (Message.Mut s) (Aircraft (Message.Mut s))) -> (m ())
-set_Regression'planes (Regression'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 2 struct)
-    )
-has_Regression'planes :: ((Untyped.ReadCtx m msg)) => (Regression msg) -> (m Std_.Bool)
-has_Regression'planes (Regression'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 2 struct))
-new_Regression'planes :: ((Untyped.RWCtx m s)) => Std_.Int -> (Regression (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Aircraft (Message.Mut s))))
-new_Regression'planes len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Regression'planes struct result)
-    (Std_.pure result)
-    )
-get_Regression'ymu :: ((Untyped.ReadCtx m msg)) => (Regression msg) -> (m Std_.Double)
-get_Regression'ymu (Regression'newtype_ struct) = (GenHelpers.getWordField struct 1 0 0)
-set_Regression'ymu :: ((Untyped.RWCtx m s)) => (Regression (Message.Mut s)) -> Std_.Double -> (m ())
-set_Regression'ymu (Regression'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-get_Regression'ysd :: ((Untyped.ReadCtx m msg)) => (Regression msg) -> (m Std_.Double)
-get_Regression'ysd (Regression'newtype_ struct) = (GenHelpers.getWordField struct 2 0 0)
-set_Regression'ysd :: ((Untyped.RWCtx m s)) => (Regression (Message.Mut s)) -> Std_.Double -> (m ())
-set_Regression'ysd (Regression'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 2 0 0)
-newtype Aircraft msg
-    = Aircraft'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Aircraft msg)) where
-    fromStruct struct = (Std_.pure (Aircraft'newtype_ struct))
-instance (Classes.ToStruct msg (Aircraft msg)) where
-    toStruct (Aircraft'newtype_ struct) = struct
-instance (Untyped.HasMessage (Aircraft mut) mut) where
-    message (Aircraft'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Aircraft mut) mut) where
-    messageDefault msg = (Aircraft'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Aircraft msg)) where
-    fromPtr msg ptr = (Aircraft'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Aircraft (Message.Mut s))) where
-    toPtr msg (Aircraft'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Aircraft (Message.Mut s))) where
-    new msg = (Aircraft'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (Aircraft mut)) where
-    newtype List mut (Aircraft mut)
-        = Aircraft'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Aircraft'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Aircraft'List_ l) = (Untyped.ListStruct l)
-    length (Aircraft'List_ l) = (Untyped.length l)
-    index i (Aircraft'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Aircraft (Message.Mut s))) where
-    setIndex (Aircraft'newtype_ elt) i (Aircraft'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Aircraft'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-data Aircraft' (mut :: Message.Mutability)
-    = Aircraft'void 
-    | Aircraft'b737 (B737 mut)
-    | Aircraft'a320 (A320 mut)
-    | Aircraft'f16 (F16 mut)
-    | Aircraft'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Aircraft' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 0)
-        case tag of
-            0 ->
-                (Std_.pure Aircraft'void)
-            1 ->
-                (Aircraft'b737 <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            2 ->
-                (Aircraft'a320 <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            3 ->
-                (Aircraft'f16 <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            _ ->
-                (Std_.pure (Aircraft'unknown' (Std_.fromIntegral tag)))
-        )
-get_Aircraft' :: ((Untyped.ReadCtx m msg)
-                 ,(Classes.FromStruct msg (Aircraft' msg))) => (Aircraft msg) -> (m (Aircraft' msg))
-get_Aircraft' (Aircraft'newtype_ struct) = (Classes.fromStruct struct)
-set_Aircraft'void :: ((Untyped.RWCtx m s)) => (Aircraft (Message.Mut s)) -> (m ())
-set_Aircraft'void (Aircraft'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Aircraft'b737 :: ((Untyped.RWCtx m s)
-                     ,(Classes.ToPtr s (B737 (Message.Mut s)))) => (Aircraft (Message.Mut s)) -> (B737 (Message.Mut s)) -> (m ())
-set_Aircraft'b737 (Aircraft'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Aircraft'a320 :: ((Untyped.RWCtx m s)
-                     ,(Classes.ToPtr s (A320 (Message.Mut s)))) => (Aircraft (Message.Mut s)) -> (A320 (Message.Mut s)) -> (m ())
-set_Aircraft'a320 (Aircraft'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (2 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Aircraft'f16 :: ((Untyped.RWCtx m s)
-                    ,(Classes.ToPtr s (F16 (Message.Mut s)))) => (Aircraft (Message.Mut s)) -> (F16 (Message.Mut s)) -> (m ())
-set_Aircraft'f16 (Aircraft'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (3 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Aircraft'unknown' :: ((Untyped.RWCtx m s)) => (Aircraft (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Aircraft'unknown' (Aircraft'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-newtype Z msg
-    = Z'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Z msg)) where
-    fromStruct struct = (Std_.pure (Z'newtype_ struct))
-instance (Classes.ToStruct msg (Z msg)) where
-    toStruct (Z'newtype_ struct) = struct
-instance (Untyped.HasMessage (Z mut) mut) where
-    message (Z'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Z mut) mut) where
-    messageDefault msg = (Z'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Z msg)) where
-    fromPtr msg ptr = (Z'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Z (Message.Mut s))) where
-    toPtr msg (Z'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Z (Message.Mut s))) where
-    new msg = (Z'newtype_ <$> (Untyped.allocStruct msg 3 1))
-instance (Basics.ListElem mut (Z mut)) where
-    newtype List mut (Z mut)
-        = Z'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Z'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Z'List_ l) = (Untyped.ListStruct l)
-    length (Z'List_ l) = (Untyped.length l)
-    index i (Z'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Z (Message.Mut s))) where
-    setIndex (Z'newtype_ elt) i (Z'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Z'List_ <$> (Untyped.allocCompositeList msg 3 1 len))
-data Z' (mut :: Message.Mutability)
-    = Z'void 
-    | Z'zz (Z mut)
-    | Z'f64 Std_.Double
-    | Z'f32 Std_.Float
-    | Z'i64 Std_.Int64
-    | Z'i32 Std_.Int32
-    | Z'i16 Std_.Int16
-    | Z'i8 Std_.Int8
-    | Z'u64 Std_.Word64
-    | Z'u32 Std_.Word32
-    | Z'u16 Std_.Word16
-    | Z'u8 Std_.Word8
-    | Z'bool Std_.Bool
-    | Z'text (Basics.Text mut)
-    | Z'blob (Basics.Data mut)
-    | Z'f64vec (Basics.List mut Std_.Double)
-    | Z'f32vec (Basics.List mut Std_.Float)
-    | Z'i64vec (Basics.List mut Std_.Int64)
-    | Z'i32vec (Basics.List mut Std_.Int32)
-    | Z'i16vec (Basics.List mut Std_.Int16)
-    | Z'i8vec (Basics.List mut Std_.Int8)
-    | Z'u64vec (Basics.List mut Std_.Word64)
-    | Z'u32vec (Basics.List mut Std_.Word32)
-    | Z'u16vec (Basics.List mut Std_.Word16)
-    | Z'u8vec (Basics.List mut Std_.Word8)
-    | Z'zvec (Basics.List mut (Z mut))
-    | Z'zvecvec (Basics.List mut (Basics.List mut (Z mut)))
-    | Z'zdate (Zdate mut)
-    | Z'zdata (Zdata mut)
-    | Z'aircraftvec (Basics.List mut (Aircraft mut))
-    | Z'aircraft (Aircraft mut)
-    | Z'regression (Regression mut)
-    | Z'planebase (PlaneBase mut)
-    | Z'airport Airport
-    | Z'b737 (B737 mut)
-    | Z'a320 (A320 mut)
-    | Z'f16 (F16 mut)
-    | Z'zdatevec (Basics.List mut (Zdate mut))
-    | Z'zdatavec (Basics.List mut (Zdata mut))
-    | Z'boolvec (Basics.List mut Std_.Bool)
-    | Z'datavec (Basics.List mut (Basics.Data mut))
-    | Z'textvec (Basics.List mut (Basics.Text mut))
-    | Z'grp (Z'grp mut)
-    | Z'echo (Echo mut)
-    | Z'echoBases (EchoBases mut)
-    | Z'unknown' Std_.Word16
-instance (Classes.FromStruct mut (Z' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 0)
-        case tag of
-            0 ->
-                (Std_.pure Z'void)
-            1 ->
-                (Z'zz <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            2 ->
-                (Z'f64 <$> (GenHelpers.getWordField struct 1 0 0))
-            3 ->
-                (Z'f32 <$> (GenHelpers.getWordField struct 1 0 0))
-            4 ->
-                (Z'i64 <$> (GenHelpers.getWordField struct 1 0 0))
-            5 ->
-                (Z'i32 <$> (GenHelpers.getWordField struct 1 0 0))
-            6 ->
-                (Z'i16 <$> (GenHelpers.getWordField struct 1 0 0))
-            7 ->
-                (Z'i8 <$> (GenHelpers.getWordField struct 1 0 0))
-            8 ->
-                (Z'u64 <$> (GenHelpers.getWordField struct 1 0 0))
-            9 ->
-                (Z'u32 <$> (GenHelpers.getWordField struct 1 0 0))
-            10 ->
-                (Z'u16 <$> (GenHelpers.getWordField struct 1 0 0))
-            11 ->
-                (Z'u8 <$> (GenHelpers.getWordField struct 1 0 0))
-            12 ->
-                (Z'bool <$> (GenHelpers.getWordField struct 1 0 0))
-            13 ->
-                (Z'text <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            14 ->
-                (Z'blob <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            15 ->
-                (Z'f64vec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            16 ->
-                (Z'f32vec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            17 ->
-                (Z'i64vec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            18 ->
-                (Z'i32vec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            19 ->
-                (Z'i16vec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            20 ->
-                (Z'i8vec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            21 ->
-                (Z'u64vec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            22 ->
-                (Z'u32vec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            23 ->
-                (Z'u16vec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            24 ->
-                (Z'u8vec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            25 ->
-                (Z'zvec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            26 ->
-                (Z'zvecvec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            27 ->
-                (Z'zdate <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            28 ->
-                (Z'zdata <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            29 ->
-                (Z'aircraftvec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            30 ->
-                (Z'aircraft <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            31 ->
-                (Z'regression <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            32 ->
-                (Z'planebase <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            33 ->
-                (Z'airport <$> (GenHelpers.getWordField struct 1 0 0))
-            34 ->
-                (Z'b737 <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            35 ->
-                (Z'a320 <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            36 ->
-                (Z'f16 <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            37 ->
-                (Z'zdatevec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            38 ->
-                (Z'zdatavec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            39 ->
-                (Z'boolvec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            40 ->
-                (Z'datavec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            41 ->
-                (Z'textvec <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            42 ->
-                (Z'grp <$> (Classes.fromStruct struct))
-            43 ->
-                (Z'echo <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            44 ->
-                (Z'echoBases <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            _ ->
-                (Std_.pure (Z'unknown' (Std_.fromIntegral tag)))
-        )
-get_Z' :: ((Untyped.ReadCtx m msg)
-          ,(Classes.FromStruct msg (Z' msg))) => (Z msg) -> (m (Z' msg))
-get_Z' (Z'newtype_ struct) = (Classes.fromStruct struct)
-set_Z'void :: ((Untyped.RWCtx m s)) => (Z (Message.Mut s)) -> (m ())
-set_Z'void (Z'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Z'zz :: ((Untyped.RWCtx m s)
-            ,(Classes.ToPtr s (Z (Message.Mut s)))) => (Z (Message.Mut s)) -> (Z (Message.Mut s)) -> (m ())
-set_Z'zz (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'f64 :: ((Untyped.RWCtx m s)) => (Z (Message.Mut s)) -> Std_.Double -> (m ())
-set_Z'f64 (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (2 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-    )
-set_Z'f32 :: ((Untyped.RWCtx m s)) => (Z (Message.Mut s)) -> Std_.Float -> (m ())
-set_Z'f32 (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (3 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 1 0 0)
-    )
-set_Z'i64 :: ((Untyped.RWCtx m s)) => (Z (Message.Mut s)) -> Std_.Int64 -> (m ())
-set_Z'i64 (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (4 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-    )
-set_Z'i32 :: ((Untyped.RWCtx m s)) => (Z (Message.Mut s)) -> Std_.Int32 -> (m ())
-set_Z'i32 (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (5 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 1 0 0)
-    )
-set_Z'i16 :: ((Untyped.RWCtx m s)) => (Z (Message.Mut s)) -> Std_.Int16 -> (m ())
-set_Z'i16 (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (6 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 1 0 0)
-    )
-set_Z'i8 :: ((Untyped.RWCtx m s)) => (Z (Message.Mut s)) -> Std_.Int8 -> (m ())
-set_Z'i8 (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (7 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word8) 1 0 0)
-    )
-set_Z'u64 :: ((Untyped.RWCtx m s)) => (Z (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Z'u64 (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (8 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-    )
-set_Z'u32 :: ((Untyped.RWCtx m s)) => (Z (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Z'u32 (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (9 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 1 0 0)
-    )
-set_Z'u16 :: ((Untyped.RWCtx m s)) => (Z (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Z'u16 (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (10 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 1 0 0)
-    )
-set_Z'u8 :: ((Untyped.RWCtx m s)) => (Z (Message.Mut s)) -> Std_.Word8 -> (m ())
-set_Z'u8 (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (11 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word8) 1 0 0)
-    )
-set_Z'bool :: ((Untyped.RWCtx m s)) => (Z (Message.Mut s)) -> Std_.Bool -> (m ())
-set_Z'bool (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (12 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 1 0 0)
-    )
-set_Z'text :: ((Untyped.RWCtx m s)
-              ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Z (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Z'text (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (13 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'blob :: ((Untyped.RWCtx m s)
-              ,(Classes.ToPtr s (Basics.Data (Message.Mut s)))) => (Z (Message.Mut s)) -> (Basics.Data (Message.Mut s)) -> (m ())
-set_Z'blob (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (14 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'f64vec :: ((Untyped.RWCtx m s)
-                ,(Classes.ToPtr s (Basics.List (Message.Mut s) Std_.Double))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) Std_.Double) -> (m ())
-set_Z'f64vec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (15 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'f32vec :: ((Untyped.RWCtx m s)
-                ,(Classes.ToPtr s (Basics.List (Message.Mut s) Std_.Float))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) Std_.Float) -> (m ())
-set_Z'f32vec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (16 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'i64vec :: ((Untyped.RWCtx m s)
-                ,(Classes.ToPtr s (Basics.List (Message.Mut s) Std_.Int64))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) Std_.Int64) -> (m ())
-set_Z'i64vec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (17 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'i32vec :: ((Untyped.RWCtx m s)
-                ,(Classes.ToPtr s (Basics.List (Message.Mut s) Std_.Int32))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) Std_.Int32) -> (m ())
-set_Z'i32vec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (18 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'i16vec :: ((Untyped.RWCtx m s)
-                ,(Classes.ToPtr s (Basics.List (Message.Mut s) Std_.Int16))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) Std_.Int16) -> (m ())
-set_Z'i16vec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (19 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'i8vec :: ((Untyped.RWCtx m s)
-               ,(Classes.ToPtr s (Basics.List (Message.Mut s) Std_.Int8))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) Std_.Int8) -> (m ())
-set_Z'i8vec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (20 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'u64vec :: ((Untyped.RWCtx m s)
-                ,(Classes.ToPtr s (Basics.List (Message.Mut s) Std_.Word64))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) Std_.Word64) -> (m ())
-set_Z'u64vec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (21 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'u32vec :: ((Untyped.RWCtx m s)
-                ,(Classes.ToPtr s (Basics.List (Message.Mut s) Std_.Word32))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) Std_.Word32) -> (m ())
-set_Z'u32vec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (22 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'u16vec :: ((Untyped.RWCtx m s)
-                ,(Classes.ToPtr s (Basics.List (Message.Mut s) Std_.Word16))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) Std_.Word16) -> (m ())
-set_Z'u16vec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (23 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'u8vec :: ((Untyped.RWCtx m s)
-               ,(Classes.ToPtr s (Basics.List (Message.Mut s) Std_.Word8))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) Std_.Word8) -> (m ())
-set_Z'u8vec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (24 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'zvec :: ((Untyped.RWCtx m s)
-              ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Z (Message.Mut s))))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) (Z (Message.Mut s))) -> (m ())
-set_Z'zvec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (25 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'zvecvec :: ((Untyped.RWCtx m s)
-                 ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Basics.List (Message.Mut s) (Z (Message.Mut s)))))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) (Basics.List (Message.Mut s) (Z (Message.Mut s)))) -> (m ())
-set_Z'zvecvec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (26 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'zdate :: ((Untyped.RWCtx m s)
-               ,(Classes.ToPtr s (Zdate (Message.Mut s)))) => (Z (Message.Mut s)) -> (Zdate (Message.Mut s)) -> (m ())
-set_Z'zdate (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (27 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'zdata :: ((Untyped.RWCtx m s)
-               ,(Classes.ToPtr s (Zdata (Message.Mut s)))) => (Z (Message.Mut s)) -> (Zdata (Message.Mut s)) -> (m ())
-set_Z'zdata (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (28 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'aircraftvec :: ((Untyped.RWCtx m s)
-                     ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Aircraft (Message.Mut s))))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) (Aircraft (Message.Mut s))) -> (m ())
-set_Z'aircraftvec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (29 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'aircraft :: ((Untyped.RWCtx m s)
-                  ,(Classes.ToPtr s (Aircraft (Message.Mut s)))) => (Z (Message.Mut s)) -> (Aircraft (Message.Mut s)) -> (m ())
-set_Z'aircraft (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (30 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'regression :: ((Untyped.RWCtx m s)
-                    ,(Classes.ToPtr s (Regression (Message.Mut s)))) => (Z (Message.Mut s)) -> (Regression (Message.Mut s)) -> (m ())
-set_Z'regression (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (31 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'planebase :: ((Untyped.RWCtx m s)
-                   ,(Classes.ToPtr s (PlaneBase (Message.Mut s)))) => (Z (Message.Mut s)) -> (PlaneBase (Message.Mut s)) -> (m ())
-set_Z'planebase (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (32 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'airport :: ((Untyped.RWCtx m s)) => (Z (Message.Mut s)) -> Airport -> (m ())
-set_Z'airport (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (33 :: Std_.Word16) 0 0 0)
-    (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 1 0 0)
-    )
-set_Z'b737 :: ((Untyped.RWCtx m s)
-              ,(Classes.ToPtr s (B737 (Message.Mut s)))) => (Z (Message.Mut s)) -> (B737 (Message.Mut s)) -> (m ())
-set_Z'b737 (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (34 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'a320 :: ((Untyped.RWCtx m s)
-              ,(Classes.ToPtr s (A320 (Message.Mut s)))) => (Z (Message.Mut s)) -> (A320 (Message.Mut s)) -> (m ())
-set_Z'a320 (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (35 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'f16 :: ((Untyped.RWCtx m s)
-             ,(Classes.ToPtr s (F16 (Message.Mut s)))) => (Z (Message.Mut s)) -> (F16 (Message.Mut s)) -> (m ())
-set_Z'f16 (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (36 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'zdatevec :: ((Untyped.RWCtx m s)
-                  ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Zdate (Message.Mut s))))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) (Zdate (Message.Mut s))) -> (m ())
-set_Z'zdatevec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (37 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'zdatavec :: ((Untyped.RWCtx m s)
-                  ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Zdata (Message.Mut s))))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) (Zdata (Message.Mut s))) -> (m ())
-set_Z'zdatavec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (38 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'boolvec :: ((Untyped.RWCtx m s)
-                 ,(Classes.ToPtr s (Basics.List (Message.Mut s) Std_.Bool))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) Std_.Bool) -> (m ())
-set_Z'boolvec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (39 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'datavec :: ((Untyped.RWCtx m s)
-                 ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Basics.Data (Message.Mut s))))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) (Basics.Data (Message.Mut s))) -> (m ())
-set_Z'datavec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (40 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'textvec :: ((Untyped.RWCtx m s)
-                 ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s))))) => (Z (Message.Mut s)) -> (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s))) -> (m ())
-set_Z'textvec (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (41 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'grp :: ((Untyped.RWCtx m s)
-             ,(Classes.FromStruct (Message.Mut s) (Z'grp (Message.Mut s)))) => (Z (Message.Mut s)) -> (m (Z'grp (Message.Mut s)))
-set_Z'grp (Z'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (42 :: Std_.Word16) 0 0 0)
-    (Classes.fromStruct struct)
-    )
-set_Z'echo :: ((Untyped.RWCtx m s)
-              ,(Classes.ToPtr s (Echo (Message.Mut s)))) => (Z (Message.Mut s)) -> (Echo (Message.Mut s)) -> (m ())
-set_Z'echo (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (43 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'echoBases :: ((Untyped.RWCtx m s)
-                   ,(Classes.ToPtr s (EchoBases (Message.Mut s)))) => (Z (Message.Mut s)) -> (EchoBases (Message.Mut s)) -> (m ())
-set_Z'echoBases (Z'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (44 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Z'unknown' :: ((Untyped.RWCtx m s)) => (Z (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Z'unknown' (Z'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-newtype Z'grp msg
-    = Z'grp'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Z'grp msg)) where
-    fromStruct struct = (Std_.pure (Z'grp'newtype_ struct))
-instance (Classes.ToStruct msg (Z'grp msg)) where
-    toStruct (Z'grp'newtype_ struct) = struct
-instance (Untyped.HasMessage (Z'grp mut) mut) where
-    message (Z'grp'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Z'grp mut) mut) where
-    messageDefault msg = (Z'grp'newtype_ <$> (Untyped.messageDefault msg))
-get_Z'grp'first :: ((Untyped.ReadCtx m msg)) => (Z'grp msg) -> (m Std_.Word64)
-get_Z'grp'first (Z'grp'newtype_ struct) = (GenHelpers.getWordField struct 1 0 0)
-set_Z'grp'first :: ((Untyped.RWCtx m s)) => (Z'grp (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Z'grp'first (Z'grp'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-get_Z'grp'second :: ((Untyped.ReadCtx m msg)) => (Z'grp msg) -> (m Std_.Word64)
-get_Z'grp'second (Z'grp'newtype_ struct) = (GenHelpers.getWordField struct 2 0 0)
-set_Z'grp'second :: ((Untyped.RWCtx m s)) => (Z'grp (Message.Mut s)) -> Std_.Word64 -> (m ())
-set_Z'grp'second (Z'grp'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 2 0 0)
-newtype Counter msg
-    = Counter'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Counter msg)) where
-    fromStruct struct = (Std_.pure (Counter'newtype_ struct))
-instance (Classes.ToStruct msg (Counter msg)) where
-    toStruct (Counter'newtype_ struct) = struct
-instance (Untyped.HasMessage (Counter mut) mut) where
-    message (Counter'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Counter mut) mut) where
-    messageDefault msg = (Counter'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Counter msg)) where
-    fromPtr msg ptr = (Counter'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Counter (Message.Mut s))) where
-    toPtr msg (Counter'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Counter (Message.Mut s))) where
-    new msg = (Counter'newtype_ <$> (Untyped.allocStruct msg 1 2))
-instance (Basics.ListElem mut (Counter mut)) where
-    newtype List mut (Counter mut)
-        = Counter'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Counter'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Counter'List_ l) = (Untyped.ListStruct l)
-    length (Counter'List_ l) = (Untyped.length l)
-    index i (Counter'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Counter (Message.Mut s))) where
-    setIndex (Counter'newtype_ elt) i (Counter'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Counter'List_ <$> (Untyped.allocCompositeList msg 1 2 len))
-get_Counter'size :: ((Untyped.ReadCtx m msg)) => (Counter msg) -> (m Std_.Int64)
-get_Counter'size (Counter'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_Counter'size :: ((Untyped.RWCtx m s)) => (Counter (Message.Mut s)) -> Std_.Int64 -> (m ())
-set_Counter'size (Counter'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 0 0 0)
-get_Counter'words :: ((Untyped.ReadCtx m msg)
-                     ,(Classes.FromPtr msg (Basics.Text msg))) => (Counter msg) -> (m (Basics.Text msg))
-get_Counter'words (Counter'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Counter'words :: ((Untyped.RWCtx m s)
-                     ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Counter (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Counter'words (Counter'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Counter'words :: ((Untyped.ReadCtx m msg)) => (Counter msg) -> (m Std_.Bool)
-has_Counter'words (Counter'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Counter'words :: ((Untyped.RWCtx m s)) => Std_.Int -> (Counter (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Counter'words len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Counter'words struct result)
-    (Std_.pure result)
-    )
-get_Counter'wordlist :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Basics.List msg (Basics.Text msg)))) => (Counter msg) -> (m (Basics.List msg (Basics.Text msg)))
-get_Counter'wordlist (Counter'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Counter'wordlist :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s))))) => (Counter (Message.Mut s)) -> (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s))) -> (m ())
-set_Counter'wordlist (Counter'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Counter'wordlist :: ((Untyped.ReadCtx m msg)) => (Counter msg) -> (m Std_.Bool)
-has_Counter'wordlist (Counter'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_Counter'wordlist :: ((Untyped.RWCtx m s)) => Std_.Int -> (Counter (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s))))
-new_Counter'wordlist len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Counter'wordlist struct result)
-    (Std_.pure result)
-    )
-newtype Bag msg
-    = Bag'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Bag msg)) where
-    fromStruct struct = (Std_.pure (Bag'newtype_ struct))
-instance (Classes.ToStruct msg (Bag msg)) where
-    toStruct (Bag'newtype_ struct) = struct
-instance (Untyped.HasMessage (Bag mut) mut) where
-    message (Bag'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Bag mut) mut) where
-    messageDefault msg = (Bag'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Bag msg)) where
-    fromPtr msg ptr = (Bag'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Bag (Message.Mut s))) where
-    toPtr msg (Bag'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Bag (Message.Mut s))) where
-    new msg = (Bag'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Bag mut)) where
-    newtype List mut (Bag mut)
-        = Bag'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Bag'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Bag'List_ l) = (Untyped.ListStruct l)
-    length (Bag'List_ l) = (Untyped.length l)
-    index i (Bag'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Bag (Message.Mut s))) where
-    setIndex (Bag'newtype_ elt) i (Bag'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Bag'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Bag'counter :: ((Untyped.ReadCtx m msg)
-                   ,(Classes.FromPtr msg (Counter msg))) => (Bag msg) -> (m (Counter msg))
-get_Bag'counter (Bag'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Bag'counter :: ((Untyped.RWCtx m s)
-                   ,(Classes.ToPtr s (Counter (Message.Mut s)))) => (Bag (Message.Mut s)) -> (Counter (Message.Mut s)) -> (m ())
-set_Bag'counter (Bag'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Bag'counter :: ((Untyped.ReadCtx m msg)) => (Bag msg) -> (m Std_.Bool)
-has_Bag'counter (Bag'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Bag'counter :: ((Untyped.RWCtx m s)) => (Bag (Message.Mut s)) -> (m (Counter (Message.Mut s)))
-new_Bag'counter struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Bag'counter struct result)
-    (Std_.pure result)
-    )
-newtype Zserver msg
-    = Zserver'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Zserver msg)) where
-    fromStruct struct = (Std_.pure (Zserver'newtype_ struct))
-instance (Classes.ToStruct msg (Zserver msg)) where
-    toStruct (Zserver'newtype_ struct) = struct
-instance (Untyped.HasMessage (Zserver mut) mut) where
-    message (Zserver'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Zserver mut) mut) where
-    messageDefault msg = (Zserver'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Zserver msg)) where
-    fromPtr msg ptr = (Zserver'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Zserver (Message.Mut s))) where
-    toPtr msg (Zserver'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Zserver (Message.Mut s))) where
-    new msg = (Zserver'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Zserver mut)) where
-    newtype List mut (Zserver mut)
-        = Zserver'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Zserver'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Zserver'List_ l) = (Untyped.ListStruct l)
-    length (Zserver'List_ l) = (Untyped.length l)
-    index i (Zserver'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Zserver (Message.Mut s))) where
-    setIndex (Zserver'newtype_ elt) i (Zserver'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Zserver'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Zserver'waitingjobs :: ((Untyped.ReadCtx m msg)
-                           ,(Classes.FromPtr msg (Basics.List msg (Zjob msg)))) => (Zserver msg) -> (m (Basics.List msg (Zjob msg)))
-get_Zserver'waitingjobs (Zserver'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Zserver'waitingjobs :: ((Untyped.RWCtx m s)
-                           ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Zjob (Message.Mut s))))) => (Zserver (Message.Mut s)) -> (Basics.List (Message.Mut s) (Zjob (Message.Mut s))) -> (m ())
-set_Zserver'waitingjobs (Zserver'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Zserver'waitingjobs :: ((Untyped.ReadCtx m msg)) => (Zserver msg) -> (m Std_.Bool)
-has_Zserver'waitingjobs (Zserver'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Zserver'waitingjobs :: ((Untyped.RWCtx m s)) => Std_.Int -> (Zserver (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Zjob (Message.Mut s))))
-new_Zserver'waitingjobs len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Zserver'waitingjobs struct result)
-    (Std_.pure result)
-    )
-newtype Zjob msg
-    = Zjob'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Zjob msg)) where
-    fromStruct struct = (Std_.pure (Zjob'newtype_ struct))
-instance (Classes.ToStruct msg (Zjob msg)) where
-    toStruct (Zjob'newtype_ struct) = struct
-instance (Untyped.HasMessage (Zjob mut) mut) where
-    message (Zjob'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Zjob mut) mut) where
-    messageDefault msg = (Zjob'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Zjob msg)) where
-    fromPtr msg ptr = (Zjob'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Zjob (Message.Mut s))) where
-    toPtr msg (Zjob'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Zjob (Message.Mut s))) where
-    new msg = (Zjob'newtype_ <$> (Untyped.allocStruct msg 0 2))
-instance (Basics.ListElem mut (Zjob mut)) where
-    newtype List mut (Zjob mut)
-        = Zjob'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Zjob'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Zjob'List_ l) = (Untyped.ListStruct l)
-    length (Zjob'List_ l) = (Untyped.length l)
-    index i (Zjob'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Zjob (Message.Mut s))) where
-    setIndex (Zjob'newtype_ elt) i (Zjob'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Zjob'List_ <$> (Untyped.allocCompositeList msg 0 2 len))
-get_Zjob'cmd :: ((Untyped.ReadCtx m msg)
-                ,(Classes.FromPtr msg (Basics.Text msg))) => (Zjob msg) -> (m (Basics.Text msg))
-get_Zjob'cmd (Zjob'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Zjob'cmd :: ((Untyped.RWCtx m s)
-                ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Zjob (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Zjob'cmd (Zjob'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Zjob'cmd :: ((Untyped.ReadCtx m msg)) => (Zjob msg) -> (m Std_.Bool)
-has_Zjob'cmd (Zjob'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Zjob'cmd :: ((Untyped.RWCtx m s)) => Std_.Int -> (Zjob (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Zjob'cmd len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Zjob'cmd struct result)
-    (Std_.pure result)
-    )
-get_Zjob'args :: ((Untyped.ReadCtx m msg)
-                 ,(Classes.FromPtr msg (Basics.List msg (Basics.Text msg)))) => (Zjob msg) -> (m (Basics.List msg (Basics.Text msg)))
-get_Zjob'args (Zjob'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Zjob'args :: ((Untyped.RWCtx m s)
-                 ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s))))) => (Zjob (Message.Mut s)) -> (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s))) -> (m ())
-set_Zjob'args (Zjob'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Zjob'args :: ((Untyped.ReadCtx m msg)) => (Zjob msg) -> (m Std_.Bool)
-has_Zjob'args (Zjob'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_Zjob'args :: ((Untyped.RWCtx m s)) => Std_.Int -> (Zjob (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s))))
-new_Zjob'args len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Zjob'args struct result)
-    (Std_.pure result)
-    )
-newtype VerEmpty msg
-    = VerEmpty'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (VerEmpty msg)) where
-    fromStruct struct = (Std_.pure (VerEmpty'newtype_ struct))
-instance (Classes.ToStruct msg (VerEmpty msg)) where
-    toStruct (VerEmpty'newtype_ struct) = struct
-instance (Untyped.HasMessage (VerEmpty mut) mut) where
-    message (VerEmpty'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (VerEmpty mut) mut) where
-    messageDefault msg = (VerEmpty'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (VerEmpty msg)) where
-    fromPtr msg ptr = (VerEmpty'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (VerEmpty (Message.Mut s))) where
-    toPtr msg (VerEmpty'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (VerEmpty (Message.Mut s))) where
-    new msg = (VerEmpty'newtype_ <$> (Untyped.allocStruct msg 0 0))
-instance (Basics.ListElem mut (VerEmpty mut)) where
-    newtype List mut (VerEmpty mut)
-        = VerEmpty'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (VerEmpty'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (VerEmpty'List_ l) = (Untyped.ListStruct l)
-    length (VerEmpty'List_ l) = (Untyped.length l)
-    index i (VerEmpty'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (VerEmpty (Message.Mut s))) where
-    setIndex (VerEmpty'newtype_ elt) i (VerEmpty'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (VerEmpty'List_ <$> (Untyped.allocCompositeList msg 0 0 len))
-newtype VerOneData msg
-    = VerOneData'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (VerOneData msg)) where
-    fromStruct struct = (Std_.pure (VerOneData'newtype_ struct))
-instance (Classes.ToStruct msg (VerOneData msg)) where
-    toStruct (VerOneData'newtype_ struct) = struct
-instance (Untyped.HasMessage (VerOneData mut) mut) where
-    message (VerOneData'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (VerOneData mut) mut) where
-    messageDefault msg = (VerOneData'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (VerOneData msg)) where
-    fromPtr msg ptr = (VerOneData'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (VerOneData (Message.Mut s))) where
-    toPtr msg (VerOneData'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (VerOneData (Message.Mut s))) where
-    new msg = (VerOneData'newtype_ <$> (Untyped.allocStruct msg 1 0))
-instance (Basics.ListElem mut (VerOneData mut)) where
-    newtype List mut (VerOneData mut)
-        = VerOneData'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (VerOneData'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (VerOneData'List_ l) = (Untyped.ListStruct l)
-    length (VerOneData'List_ l) = (Untyped.length l)
-    index i (VerOneData'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (VerOneData (Message.Mut s))) where
-    setIndex (VerOneData'newtype_ elt) i (VerOneData'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (VerOneData'List_ <$> (Untyped.allocCompositeList msg 1 0 len))
-get_VerOneData'val :: ((Untyped.ReadCtx m msg)) => (VerOneData msg) -> (m Std_.Int16)
-get_VerOneData'val (VerOneData'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_VerOneData'val :: ((Untyped.RWCtx m s)) => (VerOneData (Message.Mut s)) -> Std_.Int16 -> (m ())
-set_VerOneData'val (VerOneData'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-newtype VerTwoData msg
-    = VerTwoData'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (VerTwoData msg)) where
-    fromStruct struct = (Std_.pure (VerTwoData'newtype_ struct))
-instance (Classes.ToStruct msg (VerTwoData msg)) where
-    toStruct (VerTwoData'newtype_ struct) = struct
-instance (Untyped.HasMessage (VerTwoData mut) mut) where
-    message (VerTwoData'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (VerTwoData mut) mut) where
-    messageDefault msg = (VerTwoData'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (VerTwoData msg)) where
-    fromPtr msg ptr = (VerTwoData'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (VerTwoData (Message.Mut s))) where
-    toPtr msg (VerTwoData'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (VerTwoData (Message.Mut s))) where
-    new msg = (VerTwoData'newtype_ <$> (Untyped.allocStruct msg 2 0))
-instance (Basics.ListElem mut (VerTwoData mut)) where
-    newtype List mut (VerTwoData mut)
-        = VerTwoData'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (VerTwoData'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (VerTwoData'List_ l) = (Untyped.ListStruct l)
-    length (VerTwoData'List_ l) = (Untyped.length l)
-    index i (VerTwoData'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (VerTwoData (Message.Mut s))) where
-    setIndex (VerTwoData'newtype_ elt) i (VerTwoData'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (VerTwoData'List_ <$> (Untyped.allocCompositeList msg 2 0 len))
-get_VerTwoData'val :: ((Untyped.ReadCtx m msg)) => (VerTwoData msg) -> (m Std_.Int16)
-get_VerTwoData'val (VerTwoData'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_VerTwoData'val :: ((Untyped.RWCtx m s)) => (VerTwoData (Message.Mut s)) -> Std_.Int16 -> (m ())
-set_VerTwoData'val (VerTwoData'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-get_VerTwoData'duo :: ((Untyped.ReadCtx m msg)) => (VerTwoData msg) -> (m Std_.Int64)
-get_VerTwoData'duo (VerTwoData'newtype_ struct) = (GenHelpers.getWordField struct 1 0 0)
-set_VerTwoData'duo :: ((Untyped.RWCtx m s)) => (VerTwoData (Message.Mut s)) -> Std_.Int64 -> (m ())
-set_VerTwoData'duo (VerTwoData'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-newtype VerOnePtr msg
-    = VerOnePtr'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (VerOnePtr msg)) where
-    fromStruct struct = (Std_.pure (VerOnePtr'newtype_ struct))
-instance (Classes.ToStruct msg (VerOnePtr msg)) where
-    toStruct (VerOnePtr'newtype_ struct) = struct
-instance (Untyped.HasMessage (VerOnePtr mut) mut) where
-    message (VerOnePtr'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (VerOnePtr mut) mut) where
-    messageDefault msg = (VerOnePtr'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (VerOnePtr msg)) where
-    fromPtr msg ptr = (VerOnePtr'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (VerOnePtr (Message.Mut s))) where
-    toPtr msg (VerOnePtr'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (VerOnePtr (Message.Mut s))) where
-    new msg = (VerOnePtr'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (VerOnePtr mut)) where
-    newtype List mut (VerOnePtr mut)
-        = VerOnePtr'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (VerOnePtr'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (VerOnePtr'List_ l) = (Untyped.ListStruct l)
-    length (VerOnePtr'List_ l) = (Untyped.length l)
-    index i (VerOnePtr'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (VerOnePtr (Message.Mut s))) where
-    setIndex (VerOnePtr'newtype_ elt) i (VerOnePtr'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (VerOnePtr'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_VerOnePtr'ptr :: ((Untyped.ReadCtx m msg)
-                     ,(Classes.FromPtr msg (VerOneData msg))) => (VerOnePtr msg) -> (m (VerOneData msg))
-get_VerOnePtr'ptr (VerOnePtr'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_VerOnePtr'ptr :: ((Untyped.RWCtx m s)
-                     ,(Classes.ToPtr s (VerOneData (Message.Mut s)))) => (VerOnePtr (Message.Mut s)) -> (VerOneData (Message.Mut s)) -> (m ())
-set_VerOnePtr'ptr (VerOnePtr'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_VerOnePtr'ptr :: ((Untyped.ReadCtx m msg)) => (VerOnePtr msg) -> (m Std_.Bool)
-has_VerOnePtr'ptr (VerOnePtr'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_VerOnePtr'ptr :: ((Untyped.RWCtx m s)) => (VerOnePtr (Message.Mut s)) -> (m (VerOneData (Message.Mut s)))
-new_VerOnePtr'ptr struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_VerOnePtr'ptr struct result)
-    (Std_.pure result)
-    )
-newtype VerTwoPtr msg
-    = VerTwoPtr'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (VerTwoPtr msg)) where
-    fromStruct struct = (Std_.pure (VerTwoPtr'newtype_ struct))
-instance (Classes.ToStruct msg (VerTwoPtr msg)) where
-    toStruct (VerTwoPtr'newtype_ struct) = struct
-instance (Untyped.HasMessage (VerTwoPtr mut) mut) where
-    message (VerTwoPtr'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (VerTwoPtr mut) mut) where
-    messageDefault msg = (VerTwoPtr'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (VerTwoPtr msg)) where
-    fromPtr msg ptr = (VerTwoPtr'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (VerTwoPtr (Message.Mut s))) where
-    toPtr msg (VerTwoPtr'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (VerTwoPtr (Message.Mut s))) where
-    new msg = (VerTwoPtr'newtype_ <$> (Untyped.allocStruct msg 0 2))
-instance (Basics.ListElem mut (VerTwoPtr mut)) where
-    newtype List mut (VerTwoPtr mut)
-        = VerTwoPtr'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (VerTwoPtr'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (VerTwoPtr'List_ l) = (Untyped.ListStruct l)
-    length (VerTwoPtr'List_ l) = (Untyped.length l)
-    index i (VerTwoPtr'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (VerTwoPtr (Message.Mut s))) where
-    setIndex (VerTwoPtr'newtype_ elt) i (VerTwoPtr'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (VerTwoPtr'List_ <$> (Untyped.allocCompositeList msg 0 2 len))
-get_VerTwoPtr'ptr1 :: ((Untyped.ReadCtx m msg)
-                      ,(Classes.FromPtr msg (VerOneData msg))) => (VerTwoPtr msg) -> (m (VerOneData msg))
-get_VerTwoPtr'ptr1 (VerTwoPtr'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_VerTwoPtr'ptr1 :: ((Untyped.RWCtx m s)
-                      ,(Classes.ToPtr s (VerOneData (Message.Mut s)))) => (VerTwoPtr (Message.Mut s)) -> (VerOneData (Message.Mut s)) -> (m ())
-set_VerTwoPtr'ptr1 (VerTwoPtr'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_VerTwoPtr'ptr1 :: ((Untyped.ReadCtx m msg)) => (VerTwoPtr msg) -> (m Std_.Bool)
-has_VerTwoPtr'ptr1 (VerTwoPtr'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_VerTwoPtr'ptr1 :: ((Untyped.RWCtx m s)) => (VerTwoPtr (Message.Mut s)) -> (m (VerOneData (Message.Mut s)))
-new_VerTwoPtr'ptr1 struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_VerTwoPtr'ptr1 struct result)
-    (Std_.pure result)
-    )
-get_VerTwoPtr'ptr2 :: ((Untyped.ReadCtx m msg)
-                      ,(Classes.FromPtr msg (VerOneData msg))) => (VerTwoPtr msg) -> (m (VerOneData msg))
-get_VerTwoPtr'ptr2 (VerTwoPtr'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_VerTwoPtr'ptr2 :: ((Untyped.RWCtx m s)
-                      ,(Classes.ToPtr s (VerOneData (Message.Mut s)))) => (VerTwoPtr (Message.Mut s)) -> (VerOneData (Message.Mut s)) -> (m ())
-set_VerTwoPtr'ptr2 (VerTwoPtr'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_VerTwoPtr'ptr2 :: ((Untyped.ReadCtx m msg)) => (VerTwoPtr msg) -> (m Std_.Bool)
-has_VerTwoPtr'ptr2 (VerTwoPtr'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_VerTwoPtr'ptr2 :: ((Untyped.RWCtx m s)) => (VerTwoPtr (Message.Mut s)) -> (m (VerOneData (Message.Mut s)))
-new_VerTwoPtr'ptr2 struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_VerTwoPtr'ptr2 struct result)
-    (Std_.pure result)
-    )
-newtype VerTwoDataTwoPtr msg
-    = VerTwoDataTwoPtr'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (VerTwoDataTwoPtr msg)) where
-    fromStruct struct = (Std_.pure (VerTwoDataTwoPtr'newtype_ struct))
-instance (Classes.ToStruct msg (VerTwoDataTwoPtr msg)) where
-    toStruct (VerTwoDataTwoPtr'newtype_ struct) = struct
-instance (Untyped.HasMessage (VerTwoDataTwoPtr mut) mut) where
-    message (VerTwoDataTwoPtr'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (VerTwoDataTwoPtr mut) mut) where
-    messageDefault msg = (VerTwoDataTwoPtr'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (VerTwoDataTwoPtr msg)) where
-    fromPtr msg ptr = (VerTwoDataTwoPtr'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (VerTwoDataTwoPtr (Message.Mut s))) where
-    toPtr msg (VerTwoDataTwoPtr'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (VerTwoDataTwoPtr (Message.Mut s))) where
-    new msg = (VerTwoDataTwoPtr'newtype_ <$> (Untyped.allocStruct msg 2 2))
-instance (Basics.ListElem mut (VerTwoDataTwoPtr mut)) where
-    newtype List mut (VerTwoDataTwoPtr mut)
-        = VerTwoDataTwoPtr'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (VerTwoDataTwoPtr'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (VerTwoDataTwoPtr'List_ l) = (Untyped.ListStruct l)
-    length (VerTwoDataTwoPtr'List_ l) = (Untyped.length l)
-    index i (VerTwoDataTwoPtr'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (VerTwoDataTwoPtr (Message.Mut s))) where
-    setIndex (VerTwoDataTwoPtr'newtype_ elt) i (VerTwoDataTwoPtr'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (VerTwoDataTwoPtr'List_ <$> (Untyped.allocCompositeList msg 2 2 len))
-get_VerTwoDataTwoPtr'val :: ((Untyped.ReadCtx m msg)) => (VerTwoDataTwoPtr msg) -> (m Std_.Int16)
-get_VerTwoDataTwoPtr'val (VerTwoDataTwoPtr'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_VerTwoDataTwoPtr'val :: ((Untyped.RWCtx m s)) => (VerTwoDataTwoPtr (Message.Mut s)) -> Std_.Int16 -> (m ())
-set_VerTwoDataTwoPtr'val (VerTwoDataTwoPtr'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-get_VerTwoDataTwoPtr'duo :: ((Untyped.ReadCtx m msg)) => (VerTwoDataTwoPtr msg) -> (m Std_.Int64)
-get_VerTwoDataTwoPtr'duo (VerTwoDataTwoPtr'newtype_ struct) = (GenHelpers.getWordField struct 1 0 0)
-set_VerTwoDataTwoPtr'duo :: ((Untyped.RWCtx m s)) => (VerTwoDataTwoPtr (Message.Mut s)) -> Std_.Int64 -> (m ())
-set_VerTwoDataTwoPtr'duo (VerTwoDataTwoPtr'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-get_VerTwoDataTwoPtr'ptr1 :: ((Untyped.ReadCtx m msg)
-                             ,(Classes.FromPtr msg (VerOneData msg))) => (VerTwoDataTwoPtr msg) -> (m (VerOneData msg))
-get_VerTwoDataTwoPtr'ptr1 (VerTwoDataTwoPtr'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_VerTwoDataTwoPtr'ptr1 :: ((Untyped.RWCtx m s)
-                             ,(Classes.ToPtr s (VerOneData (Message.Mut s)))) => (VerTwoDataTwoPtr (Message.Mut s)) -> (VerOneData (Message.Mut s)) -> (m ())
-set_VerTwoDataTwoPtr'ptr1 (VerTwoDataTwoPtr'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_VerTwoDataTwoPtr'ptr1 :: ((Untyped.ReadCtx m msg)) => (VerTwoDataTwoPtr msg) -> (m Std_.Bool)
-has_VerTwoDataTwoPtr'ptr1 (VerTwoDataTwoPtr'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_VerTwoDataTwoPtr'ptr1 :: ((Untyped.RWCtx m s)) => (VerTwoDataTwoPtr (Message.Mut s)) -> (m (VerOneData (Message.Mut s)))
-new_VerTwoDataTwoPtr'ptr1 struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_VerTwoDataTwoPtr'ptr1 struct result)
-    (Std_.pure result)
-    )
-get_VerTwoDataTwoPtr'ptr2 :: ((Untyped.ReadCtx m msg)
-                             ,(Classes.FromPtr msg (VerOneData msg))) => (VerTwoDataTwoPtr msg) -> (m (VerOneData msg))
-get_VerTwoDataTwoPtr'ptr2 (VerTwoDataTwoPtr'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_VerTwoDataTwoPtr'ptr2 :: ((Untyped.RWCtx m s)
-                             ,(Classes.ToPtr s (VerOneData (Message.Mut s)))) => (VerTwoDataTwoPtr (Message.Mut s)) -> (VerOneData (Message.Mut s)) -> (m ())
-set_VerTwoDataTwoPtr'ptr2 (VerTwoDataTwoPtr'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_VerTwoDataTwoPtr'ptr2 :: ((Untyped.ReadCtx m msg)) => (VerTwoDataTwoPtr msg) -> (m Std_.Bool)
-has_VerTwoDataTwoPtr'ptr2 (VerTwoDataTwoPtr'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_VerTwoDataTwoPtr'ptr2 :: ((Untyped.RWCtx m s)) => (VerTwoDataTwoPtr (Message.Mut s)) -> (m (VerOneData (Message.Mut s)))
-new_VerTwoDataTwoPtr'ptr2 struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_VerTwoDataTwoPtr'ptr2 struct result)
-    (Std_.pure result)
-    )
-newtype HoldsVerEmptyList msg
-    = HoldsVerEmptyList'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (HoldsVerEmptyList msg)) where
-    fromStruct struct = (Std_.pure (HoldsVerEmptyList'newtype_ struct))
-instance (Classes.ToStruct msg (HoldsVerEmptyList msg)) where
-    toStruct (HoldsVerEmptyList'newtype_ struct) = struct
-instance (Untyped.HasMessage (HoldsVerEmptyList mut) mut) where
-    message (HoldsVerEmptyList'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (HoldsVerEmptyList mut) mut) where
-    messageDefault msg = (HoldsVerEmptyList'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (HoldsVerEmptyList msg)) where
-    fromPtr msg ptr = (HoldsVerEmptyList'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (HoldsVerEmptyList (Message.Mut s))) where
-    toPtr msg (HoldsVerEmptyList'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (HoldsVerEmptyList (Message.Mut s))) where
-    new msg = (HoldsVerEmptyList'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (HoldsVerEmptyList mut)) where
-    newtype List mut (HoldsVerEmptyList mut)
-        = HoldsVerEmptyList'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (HoldsVerEmptyList'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (HoldsVerEmptyList'List_ l) = (Untyped.ListStruct l)
-    length (HoldsVerEmptyList'List_ l) = (Untyped.length l)
-    index i (HoldsVerEmptyList'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (HoldsVerEmptyList (Message.Mut s))) where
-    setIndex (HoldsVerEmptyList'newtype_ elt) i (HoldsVerEmptyList'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (HoldsVerEmptyList'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_HoldsVerEmptyList'mylist :: ((Untyped.ReadCtx m msg)
-                                ,(Classes.FromPtr msg (Basics.List msg (VerEmpty msg)))) => (HoldsVerEmptyList msg) -> (m (Basics.List msg (VerEmpty msg)))
-get_HoldsVerEmptyList'mylist (HoldsVerEmptyList'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_HoldsVerEmptyList'mylist :: ((Untyped.RWCtx m s)
-                                ,(Classes.ToPtr s (Basics.List (Message.Mut s) (VerEmpty (Message.Mut s))))) => (HoldsVerEmptyList (Message.Mut s)) -> (Basics.List (Message.Mut s) (VerEmpty (Message.Mut s))) -> (m ())
-set_HoldsVerEmptyList'mylist (HoldsVerEmptyList'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_HoldsVerEmptyList'mylist :: ((Untyped.ReadCtx m msg)) => (HoldsVerEmptyList msg) -> (m Std_.Bool)
-has_HoldsVerEmptyList'mylist (HoldsVerEmptyList'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_HoldsVerEmptyList'mylist :: ((Untyped.RWCtx m s)) => Std_.Int -> (HoldsVerEmptyList (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (VerEmpty (Message.Mut s))))
-new_HoldsVerEmptyList'mylist len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_HoldsVerEmptyList'mylist struct result)
-    (Std_.pure result)
-    )
-newtype HoldsVerOneDataList msg
-    = HoldsVerOneDataList'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (HoldsVerOneDataList msg)) where
-    fromStruct struct = (Std_.pure (HoldsVerOneDataList'newtype_ struct))
-instance (Classes.ToStruct msg (HoldsVerOneDataList msg)) where
-    toStruct (HoldsVerOneDataList'newtype_ struct) = struct
-instance (Untyped.HasMessage (HoldsVerOneDataList mut) mut) where
-    message (HoldsVerOneDataList'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (HoldsVerOneDataList mut) mut) where
-    messageDefault msg = (HoldsVerOneDataList'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (HoldsVerOneDataList msg)) where
-    fromPtr msg ptr = (HoldsVerOneDataList'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (HoldsVerOneDataList (Message.Mut s))) where
-    toPtr msg (HoldsVerOneDataList'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (HoldsVerOneDataList (Message.Mut s))) where
-    new msg = (HoldsVerOneDataList'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (HoldsVerOneDataList mut)) where
-    newtype List mut (HoldsVerOneDataList mut)
-        = HoldsVerOneDataList'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (HoldsVerOneDataList'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (HoldsVerOneDataList'List_ l) = (Untyped.ListStruct l)
-    length (HoldsVerOneDataList'List_ l) = (Untyped.length l)
-    index i (HoldsVerOneDataList'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (HoldsVerOneDataList (Message.Mut s))) where
-    setIndex (HoldsVerOneDataList'newtype_ elt) i (HoldsVerOneDataList'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (HoldsVerOneDataList'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_HoldsVerOneDataList'mylist :: ((Untyped.ReadCtx m msg)
-                                  ,(Classes.FromPtr msg (Basics.List msg (VerOneData msg)))) => (HoldsVerOneDataList msg) -> (m (Basics.List msg (VerOneData msg)))
-get_HoldsVerOneDataList'mylist (HoldsVerOneDataList'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_HoldsVerOneDataList'mylist :: ((Untyped.RWCtx m s)
-                                  ,(Classes.ToPtr s (Basics.List (Message.Mut s) (VerOneData (Message.Mut s))))) => (HoldsVerOneDataList (Message.Mut s)) -> (Basics.List (Message.Mut s) (VerOneData (Message.Mut s))) -> (m ())
-set_HoldsVerOneDataList'mylist (HoldsVerOneDataList'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_HoldsVerOneDataList'mylist :: ((Untyped.ReadCtx m msg)) => (HoldsVerOneDataList msg) -> (m Std_.Bool)
-has_HoldsVerOneDataList'mylist (HoldsVerOneDataList'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_HoldsVerOneDataList'mylist :: ((Untyped.RWCtx m s)) => Std_.Int -> (HoldsVerOneDataList (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (VerOneData (Message.Mut s))))
-new_HoldsVerOneDataList'mylist len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_HoldsVerOneDataList'mylist struct result)
-    (Std_.pure result)
-    )
-newtype HoldsVerTwoDataList msg
-    = HoldsVerTwoDataList'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (HoldsVerTwoDataList msg)) where
-    fromStruct struct = (Std_.pure (HoldsVerTwoDataList'newtype_ struct))
-instance (Classes.ToStruct msg (HoldsVerTwoDataList msg)) where
-    toStruct (HoldsVerTwoDataList'newtype_ struct) = struct
-instance (Untyped.HasMessage (HoldsVerTwoDataList mut) mut) where
-    message (HoldsVerTwoDataList'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (HoldsVerTwoDataList mut) mut) where
-    messageDefault msg = (HoldsVerTwoDataList'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (HoldsVerTwoDataList msg)) where
-    fromPtr msg ptr = (HoldsVerTwoDataList'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (HoldsVerTwoDataList (Message.Mut s))) where
-    toPtr msg (HoldsVerTwoDataList'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (HoldsVerTwoDataList (Message.Mut s))) where
-    new msg = (HoldsVerTwoDataList'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (HoldsVerTwoDataList mut)) where
-    newtype List mut (HoldsVerTwoDataList mut)
-        = HoldsVerTwoDataList'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (HoldsVerTwoDataList'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (HoldsVerTwoDataList'List_ l) = (Untyped.ListStruct l)
-    length (HoldsVerTwoDataList'List_ l) = (Untyped.length l)
-    index i (HoldsVerTwoDataList'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (HoldsVerTwoDataList (Message.Mut s))) where
-    setIndex (HoldsVerTwoDataList'newtype_ elt) i (HoldsVerTwoDataList'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (HoldsVerTwoDataList'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_HoldsVerTwoDataList'mylist :: ((Untyped.ReadCtx m msg)
-                                  ,(Classes.FromPtr msg (Basics.List msg (VerTwoData msg)))) => (HoldsVerTwoDataList msg) -> (m (Basics.List msg (VerTwoData msg)))
-get_HoldsVerTwoDataList'mylist (HoldsVerTwoDataList'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_HoldsVerTwoDataList'mylist :: ((Untyped.RWCtx m s)
-                                  ,(Classes.ToPtr s (Basics.List (Message.Mut s) (VerTwoData (Message.Mut s))))) => (HoldsVerTwoDataList (Message.Mut s)) -> (Basics.List (Message.Mut s) (VerTwoData (Message.Mut s))) -> (m ())
-set_HoldsVerTwoDataList'mylist (HoldsVerTwoDataList'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_HoldsVerTwoDataList'mylist :: ((Untyped.ReadCtx m msg)) => (HoldsVerTwoDataList msg) -> (m Std_.Bool)
-has_HoldsVerTwoDataList'mylist (HoldsVerTwoDataList'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_HoldsVerTwoDataList'mylist :: ((Untyped.RWCtx m s)) => Std_.Int -> (HoldsVerTwoDataList (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (VerTwoData (Message.Mut s))))
-new_HoldsVerTwoDataList'mylist len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_HoldsVerTwoDataList'mylist struct result)
-    (Std_.pure result)
-    )
-newtype HoldsVerOnePtrList msg
-    = HoldsVerOnePtrList'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (HoldsVerOnePtrList msg)) where
-    fromStruct struct = (Std_.pure (HoldsVerOnePtrList'newtype_ struct))
-instance (Classes.ToStruct msg (HoldsVerOnePtrList msg)) where
-    toStruct (HoldsVerOnePtrList'newtype_ struct) = struct
-instance (Untyped.HasMessage (HoldsVerOnePtrList mut) mut) where
-    message (HoldsVerOnePtrList'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (HoldsVerOnePtrList mut) mut) where
-    messageDefault msg = (HoldsVerOnePtrList'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (HoldsVerOnePtrList msg)) where
-    fromPtr msg ptr = (HoldsVerOnePtrList'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (HoldsVerOnePtrList (Message.Mut s))) where
-    toPtr msg (HoldsVerOnePtrList'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (HoldsVerOnePtrList (Message.Mut s))) where
-    new msg = (HoldsVerOnePtrList'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (HoldsVerOnePtrList mut)) where
-    newtype List mut (HoldsVerOnePtrList mut)
-        = HoldsVerOnePtrList'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (HoldsVerOnePtrList'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (HoldsVerOnePtrList'List_ l) = (Untyped.ListStruct l)
-    length (HoldsVerOnePtrList'List_ l) = (Untyped.length l)
-    index i (HoldsVerOnePtrList'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (HoldsVerOnePtrList (Message.Mut s))) where
-    setIndex (HoldsVerOnePtrList'newtype_ elt) i (HoldsVerOnePtrList'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (HoldsVerOnePtrList'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_HoldsVerOnePtrList'mylist :: ((Untyped.ReadCtx m msg)
-                                 ,(Classes.FromPtr msg (Basics.List msg (VerOnePtr msg)))) => (HoldsVerOnePtrList msg) -> (m (Basics.List msg (VerOnePtr msg)))
-get_HoldsVerOnePtrList'mylist (HoldsVerOnePtrList'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_HoldsVerOnePtrList'mylist :: ((Untyped.RWCtx m s)
-                                 ,(Classes.ToPtr s (Basics.List (Message.Mut s) (VerOnePtr (Message.Mut s))))) => (HoldsVerOnePtrList (Message.Mut s)) -> (Basics.List (Message.Mut s) (VerOnePtr (Message.Mut s))) -> (m ())
-set_HoldsVerOnePtrList'mylist (HoldsVerOnePtrList'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_HoldsVerOnePtrList'mylist :: ((Untyped.ReadCtx m msg)) => (HoldsVerOnePtrList msg) -> (m Std_.Bool)
-has_HoldsVerOnePtrList'mylist (HoldsVerOnePtrList'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_HoldsVerOnePtrList'mylist :: ((Untyped.RWCtx m s)) => Std_.Int -> (HoldsVerOnePtrList (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (VerOnePtr (Message.Mut s))))
-new_HoldsVerOnePtrList'mylist len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_HoldsVerOnePtrList'mylist struct result)
-    (Std_.pure result)
-    )
-newtype HoldsVerTwoPtrList msg
-    = HoldsVerTwoPtrList'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (HoldsVerTwoPtrList msg)) where
-    fromStruct struct = (Std_.pure (HoldsVerTwoPtrList'newtype_ struct))
-instance (Classes.ToStruct msg (HoldsVerTwoPtrList msg)) where
-    toStruct (HoldsVerTwoPtrList'newtype_ struct) = struct
-instance (Untyped.HasMessage (HoldsVerTwoPtrList mut) mut) where
-    message (HoldsVerTwoPtrList'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (HoldsVerTwoPtrList mut) mut) where
-    messageDefault msg = (HoldsVerTwoPtrList'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (HoldsVerTwoPtrList msg)) where
-    fromPtr msg ptr = (HoldsVerTwoPtrList'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (HoldsVerTwoPtrList (Message.Mut s))) where
-    toPtr msg (HoldsVerTwoPtrList'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (HoldsVerTwoPtrList (Message.Mut s))) where
-    new msg = (HoldsVerTwoPtrList'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (HoldsVerTwoPtrList mut)) where
-    newtype List mut (HoldsVerTwoPtrList mut)
-        = HoldsVerTwoPtrList'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (HoldsVerTwoPtrList'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (HoldsVerTwoPtrList'List_ l) = (Untyped.ListStruct l)
-    length (HoldsVerTwoPtrList'List_ l) = (Untyped.length l)
-    index i (HoldsVerTwoPtrList'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (HoldsVerTwoPtrList (Message.Mut s))) where
-    setIndex (HoldsVerTwoPtrList'newtype_ elt) i (HoldsVerTwoPtrList'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (HoldsVerTwoPtrList'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_HoldsVerTwoPtrList'mylist :: ((Untyped.ReadCtx m msg)
-                                 ,(Classes.FromPtr msg (Basics.List msg (VerTwoPtr msg)))) => (HoldsVerTwoPtrList msg) -> (m (Basics.List msg (VerTwoPtr msg)))
-get_HoldsVerTwoPtrList'mylist (HoldsVerTwoPtrList'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_HoldsVerTwoPtrList'mylist :: ((Untyped.RWCtx m s)
-                                 ,(Classes.ToPtr s (Basics.List (Message.Mut s) (VerTwoPtr (Message.Mut s))))) => (HoldsVerTwoPtrList (Message.Mut s)) -> (Basics.List (Message.Mut s) (VerTwoPtr (Message.Mut s))) -> (m ())
-set_HoldsVerTwoPtrList'mylist (HoldsVerTwoPtrList'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_HoldsVerTwoPtrList'mylist :: ((Untyped.ReadCtx m msg)) => (HoldsVerTwoPtrList msg) -> (m Std_.Bool)
-has_HoldsVerTwoPtrList'mylist (HoldsVerTwoPtrList'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_HoldsVerTwoPtrList'mylist :: ((Untyped.RWCtx m s)) => Std_.Int -> (HoldsVerTwoPtrList (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (VerTwoPtr (Message.Mut s))))
-new_HoldsVerTwoPtrList'mylist len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_HoldsVerTwoPtrList'mylist struct result)
-    (Std_.pure result)
-    )
-newtype HoldsVerTwoTwoList msg
-    = HoldsVerTwoTwoList'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (HoldsVerTwoTwoList msg)) where
-    fromStruct struct = (Std_.pure (HoldsVerTwoTwoList'newtype_ struct))
-instance (Classes.ToStruct msg (HoldsVerTwoTwoList msg)) where
-    toStruct (HoldsVerTwoTwoList'newtype_ struct) = struct
-instance (Untyped.HasMessage (HoldsVerTwoTwoList mut) mut) where
-    message (HoldsVerTwoTwoList'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (HoldsVerTwoTwoList mut) mut) where
-    messageDefault msg = (HoldsVerTwoTwoList'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (HoldsVerTwoTwoList msg)) where
-    fromPtr msg ptr = (HoldsVerTwoTwoList'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (HoldsVerTwoTwoList (Message.Mut s))) where
-    toPtr msg (HoldsVerTwoTwoList'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (HoldsVerTwoTwoList (Message.Mut s))) where
-    new msg = (HoldsVerTwoTwoList'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (HoldsVerTwoTwoList mut)) where
-    newtype List mut (HoldsVerTwoTwoList mut)
-        = HoldsVerTwoTwoList'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (HoldsVerTwoTwoList'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (HoldsVerTwoTwoList'List_ l) = (Untyped.ListStruct l)
-    length (HoldsVerTwoTwoList'List_ l) = (Untyped.length l)
-    index i (HoldsVerTwoTwoList'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (HoldsVerTwoTwoList (Message.Mut s))) where
-    setIndex (HoldsVerTwoTwoList'newtype_ elt) i (HoldsVerTwoTwoList'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (HoldsVerTwoTwoList'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_HoldsVerTwoTwoList'mylist :: ((Untyped.ReadCtx m msg)
-                                 ,(Classes.FromPtr msg (Basics.List msg (VerTwoDataTwoPtr msg)))) => (HoldsVerTwoTwoList msg) -> (m (Basics.List msg (VerTwoDataTwoPtr msg)))
-get_HoldsVerTwoTwoList'mylist (HoldsVerTwoTwoList'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_HoldsVerTwoTwoList'mylist :: ((Untyped.RWCtx m s)
-                                 ,(Classes.ToPtr s (Basics.List (Message.Mut s) (VerTwoDataTwoPtr (Message.Mut s))))) => (HoldsVerTwoTwoList (Message.Mut s)) -> (Basics.List (Message.Mut s) (VerTwoDataTwoPtr (Message.Mut s))) -> (m ())
-set_HoldsVerTwoTwoList'mylist (HoldsVerTwoTwoList'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_HoldsVerTwoTwoList'mylist :: ((Untyped.ReadCtx m msg)) => (HoldsVerTwoTwoList msg) -> (m Std_.Bool)
-has_HoldsVerTwoTwoList'mylist (HoldsVerTwoTwoList'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_HoldsVerTwoTwoList'mylist :: ((Untyped.RWCtx m s)) => Std_.Int -> (HoldsVerTwoTwoList (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (VerTwoDataTwoPtr (Message.Mut s))))
-new_HoldsVerTwoTwoList'mylist len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_HoldsVerTwoTwoList'mylist struct result)
-    (Std_.pure result)
-    )
-newtype HoldsVerTwoTwoPlus msg
-    = HoldsVerTwoTwoPlus'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (HoldsVerTwoTwoPlus msg)) where
-    fromStruct struct = (Std_.pure (HoldsVerTwoTwoPlus'newtype_ struct))
-instance (Classes.ToStruct msg (HoldsVerTwoTwoPlus msg)) where
-    toStruct (HoldsVerTwoTwoPlus'newtype_ struct) = struct
-instance (Untyped.HasMessage (HoldsVerTwoTwoPlus mut) mut) where
-    message (HoldsVerTwoTwoPlus'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (HoldsVerTwoTwoPlus mut) mut) where
-    messageDefault msg = (HoldsVerTwoTwoPlus'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (HoldsVerTwoTwoPlus msg)) where
-    fromPtr msg ptr = (HoldsVerTwoTwoPlus'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (HoldsVerTwoTwoPlus (Message.Mut s))) where
-    toPtr msg (HoldsVerTwoTwoPlus'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (HoldsVerTwoTwoPlus (Message.Mut s))) where
-    new msg = (HoldsVerTwoTwoPlus'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (HoldsVerTwoTwoPlus mut)) where
-    newtype List mut (HoldsVerTwoTwoPlus mut)
-        = HoldsVerTwoTwoPlus'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (HoldsVerTwoTwoPlus'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (HoldsVerTwoTwoPlus'List_ l) = (Untyped.ListStruct l)
-    length (HoldsVerTwoTwoPlus'List_ l) = (Untyped.length l)
-    index i (HoldsVerTwoTwoPlus'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (HoldsVerTwoTwoPlus (Message.Mut s))) where
-    setIndex (HoldsVerTwoTwoPlus'newtype_ elt) i (HoldsVerTwoTwoPlus'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (HoldsVerTwoTwoPlus'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_HoldsVerTwoTwoPlus'mylist :: ((Untyped.ReadCtx m msg)
-                                 ,(Classes.FromPtr msg (Basics.List msg (VerTwoTwoPlus msg)))) => (HoldsVerTwoTwoPlus msg) -> (m (Basics.List msg (VerTwoTwoPlus msg)))
-get_HoldsVerTwoTwoPlus'mylist (HoldsVerTwoTwoPlus'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_HoldsVerTwoTwoPlus'mylist :: ((Untyped.RWCtx m s)
-                                 ,(Classes.ToPtr s (Basics.List (Message.Mut s) (VerTwoTwoPlus (Message.Mut s))))) => (HoldsVerTwoTwoPlus (Message.Mut s)) -> (Basics.List (Message.Mut s) (VerTwoTwoPlus (Message.Mut s))) -> (m ())
-set_HoldsVerTwoTwoPlus'mylist (HoldsVerTwoTwoPlus'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_HoldsVerTwoTwoPlus'mylist :: ((Untyped.ReadCtx m msg)) => (HoldsVerTwoTwoPlus msg) -> (m Std_.Bool)
-has_HoldsVerTwoTwoPlus'mylist (HoldsVerTwoTwoPlus'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_HoldsVerTwoTwoPlus'mylist :: ((Untyped.RWCtx m s)) => Std_.Int -> (HoldsVerTwoTwoPlus (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (VerTwoTwoPlus (Message.Mut s))))
-new_HoldsVerTwoTwoPlus'mylist len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_HoldsVerTwoTwoPlus'mylist struct result)
-    (Std_.pure result)
-    )
-newtype VerTwoTwoPlus msg
-    = VerTwoTwoPlus'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (VerTwoTwoPlus msg)) where
-    fromStruct struct = (Std_.pure (VerTwoTwoPlus'newtype_ struct))
-instance (Classes.ToStruct msg (VerTwoTwoPlus msg)) where
-    toStruct (VerTwoTwoPlus'newtype_ struct) = struct
-instance (Untyped.HasMessage (VerTwoTwoPlus mut) mut) where
-    message (VerTwoTwoPlus'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (VerTwoTwoPlus mut) mut) where
-    messageDefault msg = (VerTwoTwoPlus'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (VerTwoTwoPlus msg)) where
-    fromPtr msg ptr = (VerTwoTwoPlus'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (VerTwoTwoPlus (Message.Mut s))) where
-    toPtr msg (VerTwoTwoPlus'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (VerTwoTwoPlus (Message.Mut s))) where
-    new msg = (VerTwoTwoPlus'newtype_ <$> (Untyped.allocStruct msg 3 3))
-instance (Basics.ListElem mut (VerTwoTwoPlus mut)) where
-    newtype List mut (VerTwoTwoPlus mut)
-        = VerTwoTwoPlus'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (VerTwoTwoPlus'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (VerTwoTwoPlus'List_ l) = (Untyped.ListStruct l)
-    length (VerTwoTwoPlus'List_ l) = (Untyped.length l)
-    index i (VerTwoTwoPlus'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (VerTwoTwoPlus (Message.Mut s))) where
-    setIndex (VerTwoTwoPlus'newtype_ elt) i (VerTwoTwoPlus'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (VerTwoTwoPlus'List_ <$> (Untyped.allocCompositeList msg 3 3 len))
-get_VerTwoTwoPlus'val :: ((Untyped.ReadCtx m msg)) => (VerTwoTwoPlus msg) -> (m Std_.Int16)
-get_VerTwoTwoPlus'val (VerTwoTwoPlus'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_VerTwoTwoPlus'val :: ((Untyped.RWCtx m s)) => (VerTwoTwoPlus (Message.Mut s)) -> Std_.Int16 -> (m ())
-set_VerTwoTwoPlus'val (VerTwoTwoPlus'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-get_VerTwoTwoPlus'duo :: ((Untyped.ReadCtx m msg)) => (VerTwoTwoPlus msg) -> (m Std_.Int64)
-get_VerTwoTwoPlus'duo (VerTwoTwoPlus'newtype_ struct) = (GenHelpers.getWordField struct 1 0 0)
-set_VerTwoTwoPlus'duo :: ((Untyped.RWCtx m s)) => (VerTwoTwoPlus (Message.Mut s)) -> Std_.Int64 -> (m ())
-set_VerTwoTwoPlus'duo (VerTwoTwoPlus'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 1 0 0)
-get_VerTwoTwoPlus'ptr1 :: ((Untyped.ReadCtx m msg)
-                          ,(Classes.FromPtr msg (VerTwoDataTwoPtr msg))) => (VerTwoTwoPlus msg) -> (m (VerTwoDataTwoPtr msg))
-get_VerTwoTwoPlus'ptr1 (VerTwoTwoPlus'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_VerTwoTwoPlus'ptr1 :: ((Untyped.RWCtx m s)
-                          ,(Classes.ToPtr s (VerTwoDataTwoPtr (Message.Mut s)))) => (VerTwoTwoPlus (Message.Mut s)) -> (VerTwoDataTwoPtr (Message.Mut s)) -> (m ())
-set_VerTwoTwoPlus'ptr1 (VerTwoTwoPlus'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_VerTwoTwoPlus'ptr1 :: ((Untyped.ReadCtx m msg)) => (VerTwoTwoPlus msg) -> (m Std_.Bool)
-has_VerTwoTwoPlus'ptr1 (VerTwoTwoPlus'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_VerTwoTwoPlus'ptr1 :: ((Untyped.RWCtx m s)) => (VerTwoTwoPlus (Message.Mut s)) -> (m (VerTwoDataTwoPtr (Message.Mut s)))
-new_VerTwoTwoPlus'ptr1 struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_VerTwoTwoPlus'ptr1 struct result)
-    (Std_.pure result)
-    )
-get_VerTwoTwoPlus'ptr2 :: ((Untyped.ReadCtx m msg)
-                          ,(Classes.FromPtr msg (VerTwoDataTwoPtr msg))) => (VerTwoTwoPlus msg) -> (m (VerTwoDataTwoPtr msg))
-get_VerTwoTwoPlus'ptr2 (VerTwoTwoPlus'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_VerTwoTwoPlus'ptr2 :: ((Untyped.RWCtx m s)
-                          ,(Classes.ToPtr s (VerTwoDataTwoPtr (Message.Mut s)))) => (VerTwoTwoPlus (Message.Mut s)) -> (VerTwoDataTwoPtr (Message.Mut s)) -> (m ())
-set_VerTwoTwoPlus'ptr2 (VerTwoTwoPlus'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_VerTwoTwoPlus'ptr2 :: ((Untyped.ReadCtx m msg)) => (VerTwoTwoPlus msg) -> (m Std_.Bool)
-has_VerTwoTwoPlus'ptr2 (VerTwoTwoPlus'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_VerTwoTwoPlus'ptr2 :: ((Untyped.RWCtx m s)) => (VerTwoTwoPlus (Message.Mut s)) -> (m (VerTwoDataTwoPtr (Message.Mut s)))
-new_VerTwoTwoPlus'ptr2 struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_VerTwoTwoPlus'ptr2 struct result)
-    (Std_.pure result)
-    )
-get_VerTwoTwoPlus'tre :: ((Untyped.ReadCtx m msg)) => (VerTwoTwoPlus msg) -> (m Std_.Int64)
-get_VerTwoTwoPlus'tre (VerTwoTwoPlus'newtype_ struct) = (GenHelpers.getWordField struct 2 0 0)
-set_VerTwoTwoPlus'tre :: ((Untyped.RWCtx m s)) => (VerTwoTwoPlus (Message.Mut s)) -> Std_.Int64 -> (m ())
-set_VerTwoTwoPlus'tre (VerTwoTwoPlus'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 2 0 0)
-get_VerTwoTwoPlus'lst3 :: ((Untyped.ReadCtx m msg)
-                          ,(Classes.FromPtr msg (Basics.List msg Std_.Int64))) => (VerTwoTwoPlus msg) -> (m (Basics.List msg Std_.Int64))
-get_VerTwoTwoPlus'lst3 (VerTwoTwoPlus'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 2 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_VerTwoTwoPlus'lst3 :: ((Untyped.RWCtx m s)
-                          ,(Classes.ToPtr s (Basics.List (Message.Mut s) Std_.Int64))) => (VerTwoTwoPlus (Message.Mut s)) -> (Basics.List (Message.Mut s) Std_.Int64) -> (m ())
-set_VerTwoTwoPlus'lst3 (VerTwoTwoPlus'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 2 struct)
-    )
-has_VerTwoTwoPlus'lst3 :: ((Untyped.ReadCtx m msg)) => (VerTwoTwoPlus msg) -> (m Std_.Bool)
-has_VerTwoTwoPlus'lst3 (VerTwoTwoPlus'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 2 struct))
-new_VerTwoTwoPlus'lst3 :: ((Untyped.RWCtx m s)) => Std_.Int -> (VerTwoTwoPlus (Message.Mut s)) -> (m (Basics.List (Message.Mut s) Std_.Int64))
-new_VerTwoTwoPlus'lst3 len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_VerTwoTwoPlus'lst3 struct result)
-    (Std_.pure result)
-    )
-newtype HoldsText msg
-    = HoldsText'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (HoldsText msg)) where
-    fromStruct struct = (Std_.pure (HoldsText'newtype_ struct))
-instance (Classes.ToStruct msg (HoldsText msg)) where
-    toStruct (HoldsText'newtype_ struct) = struct
-instance (Untyped.HasMessage (HoldsText mut) mut) where
-    message (HoldsText'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (HoldsText mut) mut) where
-    messageDefault msg = (HoldsText'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (HoldsText msg)) where
-    fromPtr msg ptr = (HoldsText'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (HoldsText (Message.Mut s))) where
-    toPtr msg (HoldsText'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (HoldsText (Message.Mut s))) where
-    new msg = (HoldsText'newtype_ <$> (Untyped.allocStruct msg 0 3))
-instance (Basics.ListElem mut (HoldsText mut)) where
-    newtype List mut (HoldsText mut)
-        = HoldsText'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (HoldsText'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (HoldsText'List_ l) = (Untyped.ListStruct l)
-    length (HoldsText'List_ l) = (Untyped.length l)
-    index i (HoldsText'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (HoldsText (Message.Mut s))) where
-    setIndex (HoldsText'newtype_ elt) i (HoldsText'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (HoldsText'List_ <$> (Untyped.allocCompositeList msg 0 3 len))
-get_HoldsText'txt :: ((Untyped.ReadCtx m msg)
-                     ,(Classes.FromPtr msg (Basics.Text msg))) => (HoldsText msg) -> (m (Basics.Text msg))
-get_HoldsText'txt (HoldsText'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_HoldsText'txt :: ((Untyped.RWCtx m s)
-                     ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (HoldsText (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_HoldsText'txt (HoldsText'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_HoldsText'txt :: ((Untyped.ReadCtx m msg)) => (HoldsText msg) -> (m Std_.Bool)
-has_HoldsText'txt (HoldsText'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_HoldsText'txt :: ((Untyped.RWCtx m s)) => Std_.Int -> (HoldsText (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_HoldsText'txt len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_HoldsText'txt struct result)
-    (Std_.pure result)
-    )
-get_HoldsText'lst :: ((Untyped.ReadCtx m msg)
-                     ,(Classes.FromPtr msg (Basics.List msg (Basics.Text msg)))) => (HoldsText msg) -> (m (Basics.List msg (Basics.Text msg)))
-get_HoldsText'lst (HoldsText'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_HoldsText'lst :: ((Untyped.RWCtx m s)
-                     ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s))))) => (HoldsText (Message.Mut s)) -> (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s))) -> (m ())
-set_HoldsText'lst (HoldsText'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_HoldsText'lst :: ((Untyped.ReadCtx m msg)) => (HoldsText msg) -> (m Std_.Bool)
-has_HoldsText'lst (HoldsText'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_HoldsText'lst :: ((Untyped.RWCtx m s)) => Std_.Int -> (HoldsText (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s))))
-new_HoldsText'lst len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_HoldsText'lst struct result)
-    (Std_.pure result)
-    )
-get_HoldsText'lstlst :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Basics.List msg (Basics.List msg (Basics.Text msg))))) => (HoldsText msg) -> (m (Basics.List msg (Basics.List msg (Basics.Text msg))))
-get_HoldsText'lstlst (HoldsText'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 2 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_HoldsText'lstlst :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s)))))) => (HoldsText (Message.Mut s)) -> (Basics.List (Message.Mut s) (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s)))) -> (m ())
-set_HoldsText'lstlst (HoldsText'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 2 struct)
-    )
-has_HoldsText'lstlst :: ((Untyped.ReadCtx m msg)) => (HoldsText msg) -> (m Std_.Bool)
-has_HoldsText'lstlst (HoldsText'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 2 struct))
-new_HoldsText'lstlst :: ((Untyped.RWCtx m s)) => Std_.Int -> (HoldsText (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s)))))
-new_HoldsText'lstlst len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_HoldsText'lstlst struct result)
-    (Std_.pure result)
-    )
-newtype WrapEmpty msg
-    = WrapEmpty'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (WrapEmpty msg)) where
-    fromStruct struct = (Std_.pure (WrapEmpty'newtype_ struct))
-instance (Classes.ToStruct msg (WrapEmpty msg)) where
-    toStruct (WrapEmpty'newtype_ struct) = struct
-instance (Untyped.HasMessage (WrapEmpty mut) mut) where
-    message (WrapEmpty'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (WrapEmpty mut) mut) where
-    messageDefault msg = (WrapEmpty'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (WrapEmpty msg)) where
-    fromPtr msg ptr = (WrapEmpty'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (WrapEmpty (Message.Mut s))) where
-    toPtr msg (WrapEmpty'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (WrapEmpty (Message.Mut s))) where
-    new msg = (WrapEmpty'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (WrapEmpty mut)) where
-    newtype List mut (WrapEmpty mut)
-        = WrapEmpty'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (WrapEmpty'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (WrapEmpty'List_ l) = (Untyped.ListStruct l)
-    length (WrapEmpty'List_ l) = (Untyped.length l)
-    index i (WrapEmpty'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (WrapEmpty (Message.Mut s))) where
-    setIndex (WrapEmpty'newtype_ elt) i (WrapEmpty'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (WrapEmpty'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_WrapEmpty'mightNotBeReallyEmpty :: ((Untyped.ReadCtx m msg)
-                                       ,(Classes.FromPtr msg (VerEmpty msg))) => (WrapEmpty msg) -> (m (VerEmpty msg))
-get_WrapEmpty'mightNotBeReallyEmpty (WrapEmpty'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_WrapEmpty'mightNotBeReallyEmpty :: ((Untyped.RWCtx m s)
-                                       ,(Classes.ToPtr s (VerEmpty (Message.Mut s)))) => (WrapEmpty (Message.Mut s)) -> (VerEmpty (Message.Mut s)) -> (m ())
-set_WrapEmpty'mightNotBeReallyEmpty (WrapEmpty'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_WrapEmpty'mightNotBeReallyEmpty :: ((Untyped.ReadCtx m msg)) => (WrapEmpty msg) -> (m Std_.Bool)
-has_WrapEmpty'mightNotBeReallyEmpty (WrapEmpty'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_WrapEmpty'mightNotBeReallyEmpty :: ((Untyped.RWCtx m s)) => (WrapEmpty (Message.Mut s)) -> (m (VerEmpty (Message.Mut s)))
-new_WrapEmpty'mightNotBeReallyEmpty struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_WrapEmpty'mightNotBeReallyEmpty struct result)
-    (Std_.pure result)
-    )
-newtype Wrap2x2 msg
-    = Wrap2x2'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Wrap2x2 msg)) where
-    fromStruct struct = (Std_.pure (Wrap2x2'newtype_ struct))
-instance (Classes.ToStruct msg (Wrap2x2 msg)) where
-    toStruct (Wrap2x2'newtype_ struct) = struct
-instance (Untyped.HasMessage (Wrap2x2 mut) mut) where
-    message (Wrap2x2'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Wrap2x2 mut) mut) where
-    messageDefault msg = (Wrap2x2'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Wrap2x2 msg)) where
-    fromPtr msg ptr = (Wrap2x2'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Wrap2x2 (Message.Mut s))) where
-    toPtr msg (Wrap2x2'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Wrap2x2 (Message.Mut s))) where
-    new msg = (Wrap2x2'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Wrap2x2 mut)) where
-    newtype List mut (Wrap2x2 mut)
-        = Wrap2x2'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Wrap2x2'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Wrap2x2'List_ l) = (Untyped.ListStruct l)
-    length (Wrap2x2'List_ l) = (Untyped.length l)
-    index i (Wrap2x2'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Wrap2x2 (Message.Mut s))) where
-    setIndex (Wrap2x2'newtype_ elt) i (Wrap2x2'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Wrap2x2'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Wrap2x2'mightNotBeReallyEmpty :: ((Untyped.ReadCtx m msg)
-                                     ,(Classes.FromPtr msg (VerTwoDataTwoPtr msg))) => (Wrap2x2 msg) -> (m (VerTwoDataTwoPtr msg))
-get_Wrap2x2'mightNotBeReallyEmpty (Wrap2x2'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Wrap2x2'mightNotBeReallyEmpty :: ((Untyped.RWCtx m s)
-                                     ,(Classes.ToPtr s (VerTwoDataTwoPtr (Message.Mut s)))) => (Wrap2x2 (Message.Mut s)) -> (VerTwoDataTwoPtr (Message.Mut s)) -> (m ())
-set_Wrap2x2'mightNotBeReallyEmpty (Wrap2x2'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Wrap2x2'mightNotBeReallyEmpty :: ((Untyped.ReadCtx m msg)) => (Wrap2x2 msg) -> (m Std_.Bool)
-has_Wrap2x2'mightNotBeReallyEmpty (Wrap2x2'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Wrap2x2'mightNotBeReallyEmpty :: ((Untyped.RWCtx m s)) => (Wrap2x2 (Message.Mut s)) -> (m (VerTwoDataTwoPtr (Message.Mut s)))
-new_Wrap2x2'mightNotBeReallyEmpty struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Wrap2x2'mightNotBeReallyEmpty struct result)
-    (Std_.pure result)
-    )
-newtype Wrap2x2plus msg
-    = Wrap2x2plus'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Wrap2x2plus msg)) where
-    fromStruct struct = (Std_.pure (Wrap2x2plus'newtype_ struct))
-instance (Classes.ToStruct msg (Wrap2x2plus msg)) where
-    toStruct (Wrap2x2plus'newtype_ struct) = struct
-instance (Untyped.HasMessage (Wrap2x2plus mut) mut) where
-    message (Wrap2x2plus'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Wrap2x2plus mut) mut) where
-    messageDefault msg = (Wrap2x2plus'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Wrap2x2plus msg)) where
-    fromPtr msg ptr = (Wrap2x2plus'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Wrap2x2plus (Message.Mut s))) where
-    toPtr msg (Wrap2x2plus'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Wrap2x2plus (Message.Mut s))) where
-    new msg = (Wrap2x2plus'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Wrap2x2plus mut)) where
-    newtype List mut (Wrap2x2plus mut)
-        = Wrap2x2plus'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Wrap2x2plus'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Wrap2x2plus'List_ l) = (Untyped.ListStruct l)
-    length (Wrap2x2plus'List_ l) = (Untyped.length l)
-    index i (Wrap2x2plus'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Wrap2x2plus (Message.Mut s))) where
-    setIndex (Wrap2x2plus'newtype_ elt) i (Wrap2x2plus'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Wrap2x2plus'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Wrap2x2plus'mightNotBeReallyEmpty :: ((Untyped.ReadCtx m msg)
-                                         ,(Classes.FromPtr msg (VerTwoTwoPlus msg))) => (Wrap2x2plus msg) -> (m (VerTwoTwoPlus msg))
-get_Wrap2x2plus'mightNotBeReallyEmpty (Wrap2x2plus'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Wrap2x2plus'mightNotBeReallyEmpty :: ((Untyped.RWCtx m s)
-                                         ,(Classes.ToPtr s (VerTwoTwoPlus (Message.Mut s)))) => (Wrap2x2plus (Message.Mut s)) -> (VerTwoTwoPlus (Message.Mut s)) -> (m ())
-set_Wrap2x2plus'mightNotBeReallyEmpty (Wrap2x2plus'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Wrap2x2plus'mightNotBeReallyEmpty :: ((Untyped.ReadCtx m msg)) => (Wrap2x2plus msg) -> (m Std_.Bool)
-has_Wrap2x2plus'mightNotBeReallyEmpty (Wrap2x2plus'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Wrap2x2plus'mightNotBeReallyEmpty :: ((Untyped.RWCtx m s)) => (Wrap2x2plus (Message.Mut s)) -> (m (VerTwoTwoPlus (Message.Mut s)))
-new_Wrap2x2plus'mightNotBeReallyEmpty struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Wrap2x2plus'mightNotBeReallyEmpty struct result)
-    (Std_.pure result)
-    )
-newtype VoidUnion msg
-    = VoidUnion'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (VoidUnion msg)) where
-    fromStruct struct = (Std_.pure (VoidUnion'newtype_ struct))
-instance (Classes.ToStruct msg (VoidUnion msg)) where
-    toStruct (VoidUnion'newtype_ struct) = struct
-instance (Untyped.HasMessage (VoidUnion mut) mut) where
-    message (VoidUnion'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (VoidUnion mut) mut) where
-    messageDefault msg = (VoidUnion'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (VoidUnion msg)) where
-    fromPtr msg ptr = (VoidUnion'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (VoidUnion (Message.Mut s))) where
-    toPtr msg (VoidUnion'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (VoidUnion (Message.Mut s))) where
-    new msg = (VoidUnion'newtype_ <$> (Untyped.allocStruct msg 1 0))
-instance (Basics.ListElem mut (VoidUnion mut)) where
-    newtype List mut (VoidUnion mut)
-        = VoidUnion'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (VoidUnion'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (VoidUnion'List_ l) = (Untyped.ListStruct l)
-    length (VoidUnion'List_ l) = (Untyped.length l)
-    index i (VoidUnion'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (VoidUnion (Message.Mut s))) where
-    setIndex (VoidUnion'newtype_ elt) i (VoidUnion'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (VoidUnion'List_ <$> (Untyped.allocCompositeList msg 1 0 len))
-data VoidUnion' (mut :: Message.Mutability)
-    = VoidUnion'a 
-    | VoidUnion'b 
-    | VoidUnion'unknown' Std_.Word16
-instance (Classes.FromStruct mut (VoidUnion' mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 0)
-        case tag of
-            0 ->
-                (Std_.pure VoidUnion'a)
-            1 ->
-                (Std_.pure VoidUnion'b)
-            _ ->
-                (Std_.pure (VoidUnion'unknown' (Std_.fromIntegral tag)))
-        )
-get_VoidUnion' :: ((Untyped.ReadCtx m msg)
-                  ,(Classes.FromStruct msg (VoidUnion' msg))) => (VoidUnion msg) -> (m (VoidUnion' msg))
-get_VoidUnion' (VoidUnion'newtype_ struct) = (Classes.fromStruct struct)
-set_VoidUnion'a :: ((Untyped.RWCtx m s)) => (VoidUnion (Message.Mut s)) -> (m ())
-set_VoidUnion'a (VoidUnion'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_VoidUnion'b :: ((Untyped.RWCtx m s)) => (VoidUnion (Message.Mut s)) -> (m ())
-set_VoidUnion'b (VoidUnion'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_VoidUnion'unknown' :: ((Untyped.RWCtx m s)) => (VoidUnion (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_VoidUnion'unknown' (VoidUnion'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-newtype Nester1Capn msg
-    = Nester1Capn'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Nester1Capn msg)) where
-    fromStruct struct = (Std_.pure (Nester1Capn'newtype_ struct))
-instance (Classes.ToStruct msg (Nester1Capn msg)) where
-    toStruct (Nester1Capn'newtype_ struct) = struct
-instance (Untyped.HasMessage (Nester1Capn mut) mut) where
-    message (Nester1Capn'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Nester1Capn mut) mut) where
-    messageDefault msg = (Nester1Capn'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Nester1Capn msg)) where
-    fromPtr msg ptr = (Nester1Capn'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Nester1Capn (Message.Mut s))) where
-    toPtr msg (Nester1Capn'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Nester1Capn (Message.Mut s))) where
-    new msg = (Nester1Capn'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Nester1Capn mut)) where
-    newtype List mut (Nester1Capn mut)
-        = Nester1Capn'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Nester1Capn'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Nester1Capn'List_ l) = (Untyped.ListStruct l)
-    length (Nester1Capn'List_ l) = (Untyped.length l)
-    index i (Nester1Capn'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Nester1Capn (Message.Mut s))) where
-    setIndex (Nester1Capn'newtype_ elt) i (Nester1Capn'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Nester1Capn'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Nester1Capn'strs :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Basics.List msg (Basics.Text msg)))) => (Nester1Capn msg) -> (m (Basics.List msg (Basics.Text msg)))
-get_Nester1Capn'strs (Nester1Capn'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Nester1Capn'strs :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s))))) => (Nester1Capn (Message.Mut s)) -> (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s))) -> (m ())
-set_Nester1Capn'strs (Nester1Capn'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Nester1Capn'strs :: ((Untyped.ReadCtx m msg)) => (Nester1Capn msg) -> (m Std_.Bool)
-has_Nester1Capn'strs (Nester1Capn'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Nester1Capn'strs :: ((Untyped.RWCtx m s)) => Std_.Int -> (Nester1Capn (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Basics.Text (Message.Mut s))))
-new_Nester1Capn'strs len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_Nester1Capn'strs struct result)
-    (Std_.pure result)
-    )
-newtype RWTestCapn msg
-    = RWTestCapn'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (RWTestCapn msg)) where
-    fromStruct struct = (Std_.pure (RWTestCapn'newtype_ struct))
-instance (Classes.ToStruct msg (RWTestCapn msg)) where
-    toStruct (RWTestCapn'newtype_ struct) = struct
-instance (Untyped.HasMessage (RWTestCapn mut) mut) where
-    message (RWTestCapn'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (RWTestCapn mut) mut) where
-    messageDefault msg = (RWTestCapn'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (RWTestCapn msg)) where
-    fromPtr msg ptr = (RWTestCapn'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (RWTestCapn (Message.Mut s))) where
-    toPtr msg (RWTestCapn'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (RWTestCapn (Message.Mut s))) where
-    new msg = (RWTestCapn'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (RWTestCapn mut)) where
-    newtype List mut (RWTestCapn mut)
-        = RWTestCapn'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (RWTestCapn'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (RWTestCapn'List_ l) = (Untyped.ListStruct l)
-    length (RWTestCapn'List_ l) = (Untyped.length l)
-    index i (RWTestCapn'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (RWTestCapn (Message.Mut s))) where
-    setIndex (RWTestCapn'newtype_ elt) i (RWTestCapn'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (RWTestCapn'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_RWTestCapn'nestMatrix :: ((Untyped.ReadCtx m msg)
-                             ,(Classes.FromPtr msg (Basics.List msg (Basics.List msg (Nester1Capn msg))))) => (RWTestCapn msg) -> (m (Basics.List msg (Basics.List msg (Nester1Capn msg))))
-get_RWTestCapn'nestMatrix (RWTestCapn'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_RWTestCapn'nestMatrix :: ((Untyped.RWCtx m s)
-                             ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Basics.List (Message.Mut s) (Nester1Capn (Message.Mut s)))))) => (RWTestCapn (Message.Mut s)) -> (Basics.List (Message.Mut s) (Basics.List (Message.Mut s) (Nester1Capn (Message.Mut s)))) -> (m ())
-set_RWTestCapn'nestMatrix (RWTestCapn'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_RWTestCapn'nestMatrix :: ((Untyped.ReadCtx m msg)) => (RWTestCapn msg) -> (m Std_.Bool)
-has_RWTestCapn'nestMatrix (RWTestCapn'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_RWTestCapn'nestMatrix :: ((Untyped.RWCtx m s)) => Std_.Int -> (RWTestCapn (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Basics.List (Message.Mut s) (Nester1Capn (Message.Mut s)))))
-new_RWTestCapn'nestMatrix len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_RWTestCapn'nestMatrix struct result)
-    (Std_.pure result)
-    )
-newtype ListStructCapn msg
-    = ListStructCapn'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (ListStructCapn msg)) where
-    fromStruct struct = (Std_.pure (ListStructCapn'newtype_ struct))
-instance (Classes.ToStruct msg (ListStructCapn msg)) where
-    toStruct (ListStructCapn'newtype_ struct) = struct
-instance (Untyped.HasMessage (ListStructCapn mut) mut) where
-    message (ListStructCapn'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (ListStructCapn mut) mut) where
-    messageDefault msg = (ListStructCapn'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (ListStructCapn msg)) where
-    fromPtr msg ptr = (ListStructCapn'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (ListStructCapn (Message.Mut s))) where
-    toPtr msg (ListStructCapn'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (ListStructCapn (Message.Mut s))) where
-    new msg = (ListStructCapn'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (ListStructCapn mut)) where
-    newtype List mut (ListStructCapn mut)
-        = ListStructCapn'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (ListStructCapn'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (ListStructCapn'List_ l) = (Untyped.ListStruct l)
-    length (ListStructCapn'List_ l) = (Untyped.length l)
-    index i (ListStructCapn'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (ListStructCapn (Message.Mut s))) where
-    setIndex (ListStructCapn'newtype_ elt) i (ListStructCapn'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (ListStructCapn'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_ListStructCapn'vec :: ((Untyped.ReadCtx m msg)
-                          ,(Classes.FromPtr msg (Basics.List msg (Nester1Capn msg)))) => (ListStructCapn msg) -> (m (Basics.List msg (Nester1Capn msg)))
-get_ListStructCapn'vec (ListStructCapn'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_ListStructCapn'vec :: ((Untyped.RWCtx m s)
-                          ,(Classes.ToPtr s (Basics.List (Message.Mut s) (Nester1Capn (Message.Mut s))))) => (ListStructCapn (Message.Mut s)) -> (Basics.List (Message.Mut s) (Nester1Capn (Message.Mut s))) -> (m ())
-set_ListStructCapn'vec (ListStructCapn'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_ListStructCapn'vec :: ((Untyped.ReadCtx m msg)) => (ListStructCapn msg) -> (m Std_.Bool)
-has_ListStructCapn'vec (ListStructCapn'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_ListStructCapn'vec :: ((Untyped.RWCtx m s)) => Std_.Int -> (ListStructCapn (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (Nester1Capn (Message.Mut s))))
-new_ListStructCapn'vec len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_ListStructCapn'vec struct result)
-    (Std_.pure result)
-    )
-newtype Echo msg
-    = Echo'newtype_ (Std_.Maybe (Untyped.Cap msg))
-instance (Classes.FromPtr msg (Echo msg)) where
-    fromPtr msg ptr = (Echo'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Echo (Message.Mut s))) where
-    toPtr msg (Echo'newtype_ (Std_.Nothing)) = (Std_.pure Std_.Nothing)
-    toPtr msg (Echo'newtype_ (Std_.Just cap)) = (Std_.pure (Std_.Just (Untyped.PtrCap cap)))
-newtype Echo'echo'params msg
-    = Echo'echo'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Echo'echo'params msg)) where
-    fromStruct struct = (Std_.pure (Echo'echo'params'newtype_ struct))
-instance (Classes.ToStruct msg (Echo'echo'params msg)) where
-    toStruct (Echo'echo'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (Echo'echo'params mut) mut) where
-    message (Echo'echo'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Echo'echo'params mut) mut) where
-    messageDefault msg = (Echo'echo'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Echo'echo'params msg)) where
-    fromPtr msg ptr = (Echo'echo'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Echo'echo'params (Message.Mut s))) where
-    toPtr msg (Echo'echo'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Echo'echo'params (Message.Mut s))) where
-    new msg = (Echo'echo'params'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Echo'echo'params mut)) where
-    newtype List mut (Echo'echo'params mut)
-        = Echo'echo'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Echo'echo'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Echo'echo'params'List_ l) = (Untyped.ListStruct l)
-    length (Echo'echo'params'List_ l) = (Untyped.length l)
-    index i (Echo'echo'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Echo'echo'params (Message.Mut s))) where
-    setIndex (Echo'echo'params'newtype_ elt) i (Echo'echo'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Echo'echo'params'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Echo'echo'params'in_ :: ((Untyped.ReadCtx m msg)
-                            ,(Classes.FromPtr msg (Basics.Text msg))) => (Echo'echo'params msg) -> (m (Basics.Text msg))
-get_Echo'echo'params'in_ (Echo'echo'params'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Echo'echo'params'in_ :: ((Untyped.RWCtx m s)
-                            ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Echo'echo'params (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Echo'echo'params'in_ (Echo'echo'params'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Echo'echo'params'in_ :: ((Untyped.ReadCtx m msg)) => (Echo'echo'params msg) -> (m Std_.Bool)
-has_Echo'echo'params'in_ (Echo'echo'params'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Echo'echo'params'in_ :: ((Untyped.RWCtx m s)) => Std_.Int -> (Echo'echo'params (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Echo'echo'params'in_ len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Echo'echo'params'in_ struct result)
-    (Std_.pure result)
-    )
-newtype Echo'echo'results msg
-    = Echo'echo'results'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Echo'echo'results msg)) where
-    fromStruct struct = (Std_.pure (Echo'echo'results'newtype_ struct))
-instance (Classes.ToStruct msg (Echo'echo'results msg)) where
-    toStruct (Echo'echo'results'newtype_ struct) = struct
-instance (Untyped.HasMessage (Echo'echo'results mut) mut) where
-    message (Echo'echo'results'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Echo'echo'results mut) mut) where
-    messageDefault msg = (Echo'echo'results'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Echo'echo'results msg)) where
-    fromPtr msg ptr = (Echo'echo'results'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Echo'echo'results (Message.Mut s))) where
-    toPtr msg (Echo'echo'results'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Echo'echo'results (Message.Mut s))) where
-    new msg = (Echo'echo'results'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Echo'echo'results mut)) where
-    newtype List mut (Echo'echo'results mut)
-        = Echo'echo'results'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Echo'echo'results'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Echo'echo'results'List_ l) = (Untyped.ListStruct l)
-    length (Echo'echo'results'List_ l) = (Untyped.length l)
-    index i (Echo'echo'results'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Echo'echo'results (Message.Mut s))) where
-    setIndex (Echo'echo'results'newtype_ elt) i (Echo'echo'results'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Echo'echo'results'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Echo'echo'results'out :: ((Untyped.ReadCtx m msg)
-                             ,(Classes.FromPtr msg (Basics.Text msg))) => (Echo'echo'results msg) -> (m (Basics.Text msg))
-get_Echo'echo'results'out (Echo'echo'results'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Echo'echo'results'out :: ((Untyped.RWCtx m s)
-                             ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Echo'echo'results (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Echo'echo'results'out (Echo'echo'results'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Echo'echo'results'out :: ((Untyped.ReadCtx m msg)) => (Echo'echo'results msg) -> (m Std_.Bool)
-has_Echo'echo'results'out (Echo'echo'results'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Echo'echo'results'out :: ((Untyped.RWCtx m s)) => Std_.Int -> (Echo'echo'results (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Echo'echo'results'out len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Echo'echo'results'out struct result)
-    (Std_.pure result)
-    )
-newtype Hoth msg
-    = Hoth'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Hoth msg)) where
-    fromStruct struct = (Std_.pure (Hoth'newtype_ struct))
-instance (Classes.ToStruct msg (Hoth msg)) where
-    toStruct (Hoth'newtype_ struct) = struct
-instance (Untyped.HasMessage (Hoth mut) mut) where
-    message (Hoth'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Hoth mut) mut) where
-    messageDefault msg = (Hoth'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Hoth msg)) where
-    fromPtr msg ptr = (Hoth'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Hoth (Message.Mut s))) where
-    toPtr msg (Hoth'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Hoth (Message.Mut s))) where
-    new msg = (Hoth'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Hoth mut)) where
-    newtype List mut (Hoth mut)
-        = Hoth'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Hoth'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Hoth'List_ l) = (Untyped.ListStruct l)
-    length (Hoth'List_ l) = (Untyped.length l)
-    index i (Hoth'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Hoth (Message.Mut s))) where
-    setIndex (Hoth'newtype_ elt) i (Hoth'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Hoth'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Hoth'base :: ((Untyped.ReadCtx m msg)
-                 ,(Classes.FromPtr msg (EchoBase msg))) => (Hoth msg) -> (m (EchoBase msg))
-get_Hoth'base (Hoth'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Hoth'base :: ((Untyped.RWCtx m s)
-                 ,(Classes.ToPtr s (EchoBase (Message.Mut s)))) => (Hoth (Message.Mut s)) -> (EchoBase (Message.Mut s)) -> (m ())
-set_Hoth'base (Hoth'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Hoth'base :: ((Untyped.ReadCtx m msg)) => (Hoth msg) -> (m Std_.Bool)
-has_Hoth'base (Hoth'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Hoth'base :: ((Untyped.RWCtx m s)) => (Hoth (Message.Mut s)) -> (m (EchoBase (Message.Mut s)))
-new_Hoth'base struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Hoth'base struct result)
-    (Std_.pure result)
-    )
-newtype EchoBase msg
-    = EchoBase'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (EchoBase msg)) where
-    fromStruct struct = (Std_.pure (EchoBase'newtype_ struct))
-instance (Classes.ToStruct msg (EchoBase msg)) where
-    toStruct (EchoBase'newtype_ struct) = struct
-instance (Untyped.HasMessage (EchoBase mut) mut) where
-    message (EchoBase'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (EchoBase mut) mut) where
-    messageDefault msg = (EchoBase'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (EchoBase msg)) where
-    fromPtr msg ptr = (EchoBase'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (EchoBase (Message.Mut s))) where
-    toPtr msg (EchoBase'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (EchoBase (Message.Mut s))) where
-    new msg = (EchoBase'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (EchoBase mut)) where
-    newtype List mut (EchoBase mut)
-        = EchoBase'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (EchoBase'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (EchoBase'List_ l) = (Untyped.ListStruct l)
-    length (EchoBase'List_ l) = (Untyped.length l)
-    index i (EchoBase'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (EchoBase (Message.Mut s))) where
-    setIndex (EchoBase'newtype_ elt) i (EchoBase'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (EchoBase'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_EchoBase'echo :: ((Untyped.ReadCtx m msg)
-                     ,(Classes.FromPtr msg (Echo msg))) => (EchoBase msg) -> (m (Echo msg))
-get_EchoBase'echo (EchoBase'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_EchoBase'echo :: ((Untyped.RWCtx m s)
-                     ,(Classes.ToPtr s (Echo (Message.Mut s)))) => (EchoBase (Message.Mut s)) -> (Echo (Message.Mut s)) -> (m ())
-set_EchoBase'echo (EchoBase'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_EchoBase'echo :: ((Untyped.ReadCtx m msg)) => (EchoBase msg) -> (m Std_.Bool)
-has_EchoBase'echo (EchoBase'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-newtype EchoBases msg
-    = EchoBases'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (EchoBases msg)) where
-    fromStruct struct = (Std_.pure (EchoBases'newtype_ struct))
-instance (Classes.ToStruct msg (EchoBases msg)) where
-    toStruct (EchoBases'newtype_ struct) = struct
-instance (Untyped.HasMessage (EchoBases mut) mut) where
-    message (EchoBases'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (EchoBases mut) mut) where
-    messageDefault msg = (EchoBases'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (EchoBases msg)) where
-    fromPtr msg ptr = (EchoBases'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (EchoBases (Message.Mut s))) where
-    toPtr msg (EchoBases'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (EchoBases (Message.Mut s))) where
-    new msg = (EchoBases'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (EchoBases mut)) where
-    newtype List mut (EchoBases mut)
-        = EchoBases'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (EchoBases'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (EchoBases'List_ l) = (Untyped.ListStruct l)
-    length (EchoBases'List_ l) = (Untyped.length l)
-    index i (EchoBases'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (EchoBases (Message.Mut s))) where
-    setIndex (EchoBases'newtype_ elt) i (EchoBases'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (EchoBases'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_EchoBases'bases :: ((Untyped.ReadCtx m msg)
-                       ,(Classes.FromPtr msg (Basics.List msg (EchoBase msg)))) => (EchoBases msg) -> (m (Basics.List msg (EchoBase msg)))
-get_EchoBases'bases (EchoBases'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_EchoBases'bases :: ((Untyped.RWCtx m s)
-                       ,(Classes.ToPtr s (Basics.List (Message.Mut s) (EchoBase (Message.Mut s))))) => (EchoBases (Message.Mut s)) -> (Basics.List (Message.Mut s) (EchoBase (Message.Mut s))) -> (m ())
-set_EchoBases'bases (EchoBases'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_EchoBases'bases :: ((Untyped.ReadCtx m msg)) => (EchoBases msg) -> (m Std_.Bool)
-has_EchoBases'bases (EchoBases'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_EchoBases'bases :: ((Untyped.RWCtx m s)) => Std_.Int -> (EchoBases (Message.Mut s)) -> (m (Basics.List (Message.Mut s) (EchoBase (Message.Mut s))))
-new_EchoBases'bases len struct = (do
-    result <- (Classes.newList (Untyped.message struct) len)
-    (set_EchoBases'bases struct result)
-    (Std_.pure result)
-    )
-newtype StackingRoot msg
-    = StackingRoot'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (StackingRoot msg)) where
-    fromStruct struct = (Std_.pure (StackingRoot'newtype_ struct))
-instance (Classes.ToStruct msg (StackingRoot msg)) where
-    toStruct (StackingRoot'newtype_ struct) = struct
-instance (Untyped.HasMessage (StackingRoot mut) mut) where
-    message (StackingRoot'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (StackingRoot mut) mut) where
-    messageDefault msg = (StackingRoot'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (StackingRoot msg)) where
-    fromPtr msg ptr = (StackingRoot'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (StackingRoot (Message.Mut s))) where
-    toPtr msg (StackingRoot'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (StackingRoot (Message.Mut s))) where
-    new msg = (StackingRoot'newtype_ <$> (Untyped.allocStruct msg 0 2))
-instance (Basics.ListElem mut (StackingRoot mut)) where
-    newtype List mut (StackingRoot mut)
-        = StackingRoot'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (StackingRoot'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (StackingRoot'List_ l) = (Untyped.ListStruct l)
-    length (StackingRoot'List_ l) = (Untyped.length l)
-    index i (StackingRoot'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (StackingRoot (Message.Mut s))) where
-    setIndex (StackingRoot'newtype_ elt) i (StackingRoot'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (StackingRoot'List_ <$> (Untyped.allocCompositeList msg 0 2 len))
-get_StackingRoot'aWithDefault :: ((Untyped.ReadCtx m msg)
-                                 ,(Classes.FromPtr msg (StackingA msg))) => (StackingRoot msg) -> (m (StackingA msg))
-get_StackingRoot'aWithDefault (StackingRoot'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_StackingRoot'aWithDefault :: ((Untyped.RWCtx m s)
-                                 ,(Classes.ToPtr s (StackingA (Message.Mut s)))) => (StackingRoot (Message.Mut s)) -> (StackingA (Message.Mut s)) -> (m ())
-set_StackingRoot'aWithDefault (StackingRoot'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_StackingRoot'aWithDefault :: ((Untyped.ReadCtx m msg)) => (StackingRoot msg) -> (m Std_.Bool)
-has_StackingRoot'aWithDefault (StackingRoot'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_StackingRoot'aWithDefault :: ((Untyped.RWCtx m s)) => (StackingRoot (Message.Mut s)) -> (m (StackingA (Message.Mut s)))
-new_StackingRoot'aWithDefault struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_StackingRoot'aWithDefault struct result)
-    (Std_.pure result)
-    )
-get_StackingRoot'a :: ((Untyped.ReadCtx m msg)
-                      ,(Classes.FromPtr msg (StackingA msg))) => (StackingRoot msg) -> (m (StackingA msg))
-get_StackingRoot'a (StackingRoot'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_StackingRoot'a :: ((Untyped.RWCtx m s)
-                      ,(Classes.ToPtr s (StackingA (Message.Mut s)))) => (StackingRoot (Message.Mut s)) -> (StackingA (Message.Mut s)) -> (m ())
-set_StackingRoot'a (StackingRoot'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_StackingRoot'a :: ((Untyped.ReadCtx m msg)) => (StackingRoot msg) -> (m Std_.Bool)
-has_StackingRoot'a (StackingRoot'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_StackingRoot'a :: ((Untyped.RWCtx m s)) => (StackingRoot (Message.Mut s)) -> (m (StackingA (Message.Mut s)))
-new_StackingRoot'a struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_StackingRoot'a struct result)
-    (Std_.pure result)
-    )
-newtype StackingA msg
-    = StackingA'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (StackingA msg)) where
-    fromStruct struct = (Std_.pure (StackingA'newtype_ struct))
-instance (Classes.ToStruct msg (StackingA msg)) where
-    toStruct (StackingA'newtype_ struct) = struct
-instance (Untyped.HasMessage (StackingA mut) mut) where
-    message (StackingA'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (StackingA mut) mut) where
-    messageDefault msg = (StackingA'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (StackingA msg)) where
-    fromPtr msg ptr = (StackingA'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (StackingA (Message.Mut s))) where
-    toPtr msg (StackingA'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (StackingA (Message.Mut s))) where
-    new msg = (StackingA'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (StackingA mut)) where
-    newtype List mut (StackingA mut)
-        = StackingA'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (StackingA'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (StackingA'List_ l) = (Untyped.ListStruct l)
-    length (StackingA'List_ l) = (Untyped.length l)
-    index i (StackingA'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (StackingA (Message.Mut s))) where
-    setIndex (StackingA'newtype_ elt) i (StackingA'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (StackingA'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-get_StackingA'num :: ((Untyped.ReadCtx m msg)) => (StackingA msg) -> (m Std_.Int32)
-get_StackingA'num (StackingA'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_StackingA'num :: ((Untyped.RWCtx m s)) => (StackingA (Message.Mut s)) -> Std_.Int32 -> (m ())
-set_StackingA'num (StackingA'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-get_StackingA'b :: ((Untyped.ReadCtx m msg)
-                   ,(Classes.FromPtr msg (StackingB msg))) => (StackingA msg) -> (m (StackingB msg))
-get_StackingA'b (StackingA'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_StackingA'b :: ((Untyped.RWCtx m s)
-                   ,(Classes.ToPtr s (StackingB (Message.Mut s)))) => (StackingA (Message.Mut s)) -> (StackingB (Message.Mut s)) -> (m ())
-set_StackingA'b (StackingA'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_StackingA'b :: ((Untyped.ReadCtx m msg)) => (StackingA msg) -> (m Std_.Bool)
-has_StackingA'b (StackingA'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_StackingA'b :: ((Untyped.RWCtx m s)) => (StackingA (Message.Mut s)) -> (m (StackingB (Message.Mut s)))
-new_StackingA'b struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_StackingA'b struct result)
-    (Std_.pure result)
-    )
-newtype StackingB msg
-    = StackingB'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (StackingB msg)) where
-    fromStruct struct = (Std_.pure (StackingB'newtype_ struct))
-instance (Classes.ToStruct msg (StackingB msg)) where
-    toStruct (StackingB'newtype_ struct) = struct
-instance (Untyped.HasMessage (StackingB mut) mut) where
-    message (StackingB'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (StackingB mut) mut) where
-    messageDefault msg = (StackingB'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (StackingB msg)) where
-    fromPtr msg ptr = (StackingB'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (StackingB (Message.Mut s))) where
-    toPtr msg (StackingB'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (StackingB (Message.Mut s))) where
-    new msg = (StackingB'newtype_ <$> (Untyped.allocStruct msg 1 0))
-instance (Basics.ListElem mut (StackingB mut)) where
-    newtype List mut (StackingB mut)
-        = StackingB'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (StackingB'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (StackingB'List_ l) = (Untyped.ListStruct l)
-    length (StackingB'List_ l) = (Untyped.length l)
-    index i (StackingB'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (StackingB (Message.Mut s))) where
-    setIndex (StackingB'newtype_ elt) i (StackingB'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (StackingB'List_ <$> (Untyped.allocCompositeList msg 1 0 len))
-get_StackingB'num :: ((Untyped.ReadCtx m msg)) => (StackingB msg) -> (m Std_.Int32)
-get_StackingB'num (StackingB'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_StackingB'num :: ((Untyped.RWCtx m s)) => (StackingB (Message.Mut s)) -> Std_.Int32 -> (m ())
-set_StackingB'num (StackingB'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-newtype CallSequence msg
-    = CallSequence'newtype_ (Std_.Maybe (Untyped.Cap msg))
-instance (Classes.FromPtr msg (CallSequence msg)) where
-    fromPtr msg ptr = (CallSequence'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (CallSequence (Message.Mut s))) where
-    toPtr msg (CallSequence'newtype_ (Std_.Nothing)) = (Std_.pure Std_.Nothing)
-    toPtr msg (CallSequence'newtype_ (Std_.Just cap)) = (Std_.pure (Std_.Just (Untyped.PtrCap cap)))
-newtype CallSequence'getNumber'params msg
-    = CallSequence'getNumber'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (CallSequence'getNumber'params msg)) where
-    fromStruct struct = (Std_.pure (CallSequence'getNumber'params'newtype_ struct))
-instance (Classes.ToStruct msg (CallSequence'getNumber'params msg)) where
-    toStruct (CallSequence'getNumber'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (CallSequence'getNumber'params mut) mut) where
-    message (CallSequence'getNumber'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (CallSequence'getNumber'params mut) mut) where
-    messageDefault msg = (CallSequence'getNumber'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (CallSequence'getNumber'params msg)) where
-    fromPtr msg ptr = (CallSequence'getNumber'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (CallSequence'getNumber'params (Message.Mut s))) where
-    toPtr msg (CallSequence'getNumber'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (CallSequence'getNumber'params (Message.Mut s))) where
-    new msg = (CallSequence'getNumber'params'newtype_ <$> (Untyped.allocStruct msg 0 0))
-instance (Basics.ListElem mut (CallSequence'getNumber'params mut)) where
-    newtype List mut (CallSequence'getNumber'params mut)
-        = CallSequence'getNumber'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (CallSequence'getNumber'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (CallSequence'getNumber'params'List_ l) = (Untyped.ListStruct l)
-    length (CallSequence'getNumber'params'List_ l) = (Untyped.length l)
-    index i (CallSequence'getNumber'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (CallSequence'getNumber'params (Message.Mut s))) where
-    setIndex (CallSequence'getNumber'params'newtype_ elt) i (CallSequence'getNumber'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (CallSequence'getNumber'params'List_ <$> (Untyped.allocCompositeList msg 0 0 len))
-newtype CallSequence'getNumber'results msg
-    = CallSequence'getNumber'results'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (CallSequence'getNumber'results msg)) where
-    fromStruct struct = (Std_.pure (CallSequence'getNumber'results'newtype_ struct))
-instance (Classes.ToStruct msg (CallSequence'getNumber'results msg)) where
-    toStruct (CallSequence'getNumber'results'newtype_ struct) = struct
-instance (Untyped.HasMessage (CallSequence'getNumber'results mut) mut) where
-    message (CallSequence'getNumber'results'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (CallSequence'getNumber'results mut) mut) where
-    messageDefault msg = (CallSequence'getNumber'results'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (CallSequence'getNumber'results msg)) where
-    fromPtr msg ptr = (CallSequence'getNumber'results'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (CallSequence'getNumber'results (Message.Mut s))) where
-    toPtr msg (CallSequence'getNumber'results'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (CallSequence'getNumber'results (Message.Mut s))) where
-    new msg = (CallSequence'getNumber'results'newtype_ <$> (Untyped.allocStruct msg 1 0))
-instance (Basics.ListElem mut (CallSequence'getNumber'results mut)) where
-    newtype List mut (CallSequence'getNumber'results mut)
-        = CallSequence'getNumber'results'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (CallSequence'getNumber'results'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (CallSequence'getNumber'results'List_ l) = (Untyped.ListStruct l)
-    length (CallSequence'getNumber'results'List_ l) = (Untyped.length l)
-    index i (CallSequence'getNumber'results'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (CallSequence'getNumber'results (Message.Mut s))) where
-    setIndex (CallSequence'getNumber'results'newtype_ elt) i (CallSequence'getNumber'results'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (CallSequence'getNumber'results'List_ <$> (Untyped.allocCompositeList msg 1 0 len))
-get_CallSequence'getNumber'results'n :: ((Untyped.ReadCtx m msg)) => (CallSequence'getNumber'results msg) -> (m Std_.Word32)
-get_CallSequence'getNumber'results'n (CallSequence'getNumber'results'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_CallSequence'getNumber'results'n :: ((Untyped.RWCtx m s)) => (CallSequence'getNumber'results (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_CallSequence'getNumber'results'n (CallSequence'getNumber'results'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-newtype CounterFactory msg
-    = CounterFactory'newtype_ (Std_.Maybe (Untyped.Cap msg))
-instance (Classes.FromPtr msg (CounterFactory msg)) where
-    fromPtr msg ptr = (CounterFactory'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (CounterFactory (Message.Mut s))) where
-    toPtr msg (CounterFactory'newtype_ (Std_.Nothing)) = (Std_.pure Std_.Nothing)
-    toPtr msg (CounterFactory'newtype_ (Std_.Just cap)) = (Std_.pure (Std_.Just (Untyped.PtrCap cap)))
-newtype CounterFactory'newCounter'params msg
-    = CounterFactory'newCounter'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (CounterFactory'newCounter'params msg)) where
-    fromStruct struct = (Std_.pure (CounterFactory'newCounter'params'newtype_ struct))
-instance (Classes.ToStruct msg (CounterFactory'newCounter'params msg)) where
-    toStruct (CounterFactory'newCounter'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (CounterFactory'newCounter'params mut) mut) where
-    message (CounterFactory'newCounter'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (CounterFactory'newCounter'params mut) mut) where
-    messageDefault msg = (CounterFactory'newCounter'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (CounterFactory'newCounter'params msg)) where
-    fromPtr msg ptr = (CounterFactory'newCounter'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (CounterFactory'newCounter'params (Message.Mut s))) where
-    toPtr msg (CounterFactory'newCounter'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (CounterFactory'newCounter'params (Message.Mut s))) where
-    new msg = (CounterFactory'newCounter'params'newtype_ <$> (Untyped.allocStruct msg 1 0))
-instance (Basics.ListElem mut (CounterFactory'newCounter'params mut)) where
-    newtype List mut (CounterFactory'newCounter'params mut)
-        = CounterFactory'newCounter'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (CounterFactory'newCounter'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (CounterFactory'newCounter'params'List_ l) = (Untyped.ListStruct l)
-    length (CounterFactory'newCounter'params'List_ l) = (Untyped.length l)
-    index i (CounterFactory'newCounter'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (CounterFactory'newCounter'params (Message.Mut s))) where
-    setIndex (CounterFactory'newCounter'params'newtype_ elt) i (CounterFactory'newCounter'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (CounterFactory'newCounter'params'List_ <$> (Untyped.allocCompositeList msg 1 0 len))
-get_CounterFactory'newCounter'params'start :: ((Untyped.ReadCtx m msg)) => (CounterFactory'newCounter'params msg) -> (m Std_.Word32)
-get_CounterFactory'newCounter'params'start (CounterFactory'newCounter'params'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_CounterFactory'newCounter'params'start :: ((Untyped.RWCtx m s)) => (CounterFactory'newCounter'params (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_CounterFactory'newCounter'params'start (CounterFactory'newCounter'params'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 0)
-newtype CounterFactory'newCounter'results msg
-    = CounterFactory'newCounter'results'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (CounterFactory'newCounter'results msg)) where
-    fromStruct struct = (Std_.pure (CounterFactory'newCounter'results'newtype_ struct))
-instance (Classes.ToStruct msg (CounterFactory'newCounter'results msg)) where
-    toStruct (CounterFactory'newCounter'results'newtype_ struct) = struct
-instance (Untyped.HasMessage (CounterFactory'newCounter'results mut) mut) where
-    message (CounterFactory'newCounter'results'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (CounterFactory'newCounter'results mut) mut) where
-    messageDefault msg = (CounterFactory'newCounter'results'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (CounterFactory'newCounter'results msg)) where
-    fromPtr msg ptr = (CounterFactory'newCounter'results'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (CounterFactory'newCounter'results (Message.Mut s))) where
-    toPtr msg (CounterFactory'newCounter'results'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (CounterFactory'newCounter'results (Message.Mut s))) where
-    new msg = (CounterFactory'newCounter'results'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (CounterFactory'newCounter'results mut)) where
-    newtype List mut (CounterFactory'newCounter'results mut)
-        = CounterFactory'newCounter'results'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (CounterFactory'newCounter'results'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (CounterFactory'newCounter'results'List_ l) = (Untyped.ListStruct l)
-    length (CounterFactory'newCounter'results'List_ l) = (Untyped.length l)
-    index i (CounterFactory'newCounter'results'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (CounterFactory'newCounter'results (Message.Mut s))) where
-    setIndex (CounterFactory'newCounter'results'newtype_ elt) i (CounterFactory'newCounter'results'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (CounterFactory'newCounter'results'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_CounterFactory'newCounter'results'counter :: ((Untyped.ReadCtx m msg)
-                                                 ,(Classes.FromPtr msg (CallSequence msg))) => (CounterFactory'newCounter'results msg) -> (m (CallSequence msg))
-get_CounterFactory'newCounter'results'counter (CounterFactory'newCounter'results'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_CounterFactory'newCounter'results'counter :: ((Untyped.RWCtx m s)
-                                                 ,(Classes.ToPtr s (CallSequence (Message.Mut s)))) => (CounterFactory'newCounter'results (Message.Mut s)) -> (CallSequence (Message.Mut s)) -> (m ())
-set_CounterFactory'newCounter'results'counter (CounterFactory'newCounter'results'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_CounterFactory'newCounter'results'counter :: ((Untyped.ReadCtx m msg)) => (CounterFactory'newCounter'results msg) -> (m Std_.Bool)
-has_CounterFactory'newCounter'results'counter (CounterFactory'newCounter'results'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-newtype CounterAcceptor msg
-    = CounterAcceptor'newtype_ (Std_.Maybe (Untyped.Cap msg))
-instance (Classes.FromPtr msg (CounterAcceptor msg)) where
-    fromPtr msg ptr = (CounterAcceptor'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (CounterAcceptor (Message.Mut s))) where
-    toPtr msg (CounterAcceptor'newtype_ (Std_.Nothing)) = (Std_.pure Std_.Nothing)
-    toPtr msg (CounterAcceptor'newtype_ (Std_.Just cap)) = (Std_.pure (Std_.Just (Untyped.PtrCap cap)))
-newtype CounterAcceptor'accept'params msg
-    = CounterAcceptor'accept'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (CounterAcceptor'accept'params msg)) where
-    fromStruct struct = (Std_.pure (CounterAcceptor'accept'params'newtype_ struct))
-instance (Classes.ToStruct msg (CounterAcceptor'accept'params msg)) where
-    toStruct (CounterAcceptor'accept'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (CounterAcceptor'accept'params mut) mut) where
-    message (CounterAcceptor'accept'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (CounterAcceptor'accept'params mut) mut) where
-    messageDefault msg = (CounterAcceptor'accept'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (CounterAcceptor'accept'params msg)) where
-    fromPtr msg ptr = (CounterAcceptor'accept'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (CounterAcceptor'accept'params (Message.Mut s))) where
-    toPtr msg (CounterAcceptor'accept'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (CounterAcceptor'accept'params (Message.Mut s))) where
-    new msg = (CounterAcceptor'accept'params'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (CounterAcceptor'accept'params mut)) where
-    newtype List mut (CounterAcceptor'accept'params mut)
-        = CounterAcceptor'accept'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (CounterAcceptor'accept'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (CounterAcceptor'accept'params'List_ l) = (Untyped.ListStruct l)
-    length (CounterAcceptor'accept'params'List_ l) = (Untyped.length l)
-    index i (CounterAcceptor'accept'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (CounterAcceptor'accept'params (Message.Mut s))) where
-    setIndex (CounterAcceptor'accept'params'newtype_ elt) i (CounterAcceptor'accept'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (CounterAcceptor'accept'params'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_CounterAcceptor'accept'params'counter :: ((Untyped.ReadCtx m msg)
-                                             ,(Classes.FromPtr msg (CallSequence msg))) => (CounterAcceptor'accept'params msg) -> (m (CallSequence msg))
-get_CounterAcceptor'accept'params'counter (CounterAcceptor'accept'params'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_CounterAcceptor'accept'params'counter :: ((Untyped.RWCtx m s)
-                                             ,(Classes.ToPtr s (CallSequence (Message.Mut s)))) => (CounterAcceptor'accept'params (Message.Mut s)) -> (CallSequence (Message.Mut s)) -> (m ())
-set_CounterAcceptor'accept'params'counter (CounterAcceptor'accept'params'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_CounterAcceptor'accept'params'counter :: ((Untyped.ReadCtx m msg)) => (CounterAcceptor'accept'params msg) -> (m Std_.Bool)
-has_CounterAcceptor'accept'params'counter (CounterAcceptor'accept'params'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-newtype CounterAcceptor'accept'results msg
-    = CounterAcceptor'accept'results'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (CounterAcceptor'accept'results msg)) where
-    fromStruct struct = (Std_.pure (CounterAcceptor'accept'results'newtype_ struct))
-instance (Classes.ToStruct msg (CounterAcceptor'accept'results msg)) where
-    toStruct (CounterAcceptor'accept'results'newtype_ struct) = struct
-instance (Untyped.HasMessage (CounterAcceptor'accept'results mut) mut) where
-    message (CounterAcceptor'accept'results'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (CounterAcceptor'accept'results mut) mut) where
-    messageDefault msg = (CounterAcceptor'accept'results'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (CounterAcceptor'accept'results msg)) where
-    fromPtr msg ptr = (CounterAcceptor'accept'results'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (CounterAcceptor'accept'results (Message.Mut s))) where
-    toPtr msg (CounterAcceptor'accept'results'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (CounterAcceptor'accept'results (Message.Mut s))) where
-    new msg = (CounterAcceptor'accept'results'newtype_ <$> (Untyped.allocStruct msg 0 0))
-instance (Basics.ListElem mut (CounterAcceptor'accept'results mut)) where
-    newtype List mut (CounterAcceptor'accept'results mut)
-        = CounterAcceptor'accept'results'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (CounterAcceptor'accept'results'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (CounterAcceptor'accept'results'List_ l) = (Untyped.ListStruct l)
-    length (CounterAcceptor'accept'results'List_ l) = (Untyped.length l)
-    index i (CounterAcceptor'accept'results'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (CounterAcceptor'accept'results (Message.Mut s))) where
-    setIndex (CounterAcceptor'accept'results'newtype_ elt) i (CounterAcceptor'accept'results'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (CounterAcceptor'accept'results'List_ <$> (Untyped.allocCompositeList msg 0 0 len))
-newtype Top msg
-    = Top'newtype_ (Std_.Maybe (Untyped.Cap msg))
-instance (Classes.FromPtr msg (Top msg)) where
-    fromPtr msg ptr = (Top'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Top (Message.Mut s))) where
-    toPtr msg (Top'newtype_ (Std_.Nothing)) = (Std_.pure Std_.Nothing)
-    toPtr msg (Top'newtype_ (Std_.Just cap)) = (Std_.pure (Std_.Just (Untyped.PtrCap cap)))
-newtype Top'top'params msg
-    = Top'top'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Top'top'params msg)) where
-    fromStruct struct = (Std_.pure (Top'top'params'newtype_ struct))
-instance (Classes.ToStruct msg (Top'top'params msg)) where
-    toStruct (Top'top'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (Top'top'params mut) mut) where
-    message (Top'top'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Top'top'params mut) mut) where
-    messageDefault msg = (Top'top'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Top'top'params msg)) where
-    fromPtr msg ptr = (Top'top'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Top'top'params (Message.Mut s))) where
-    toPtr msg (Top'top'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Top'top'params (Message.Mut s))) where
-    new msg = (Top'top'params'newtype_ <$> (Untyped.allocStruct msg 0 0))
-instance (Basics.ListElem mut (Top'top'params mut)) where
-    newtype List mut (Top'top'params mut)
-        = Top'top'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Top'top'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Top'top'params'List_ l) = (Untyped.ListStruct l)
-    length (Top'top'params'List_ l) = (Untyped.length l)
-    index i (Top'top'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Top'top'params (Message.Mut s))) where
-    setIndex (Top'top'params'newtype_ elt) i (Top'top'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Top'top'params'List_ <$> (Untyped.allocCompositeList msg 0 0 len))
-newtype Top'top'results msg
-    = Top'top'results'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Top'top'results msg)) where
-    fromStruct struct = (Std_.pure (Top'top'results'newtype_ struct))
-instance (Classes.ToStruct msg (Top'top'results msg)) where
-    toStruct (Top'top'results'newtype_ struct) = struct
-instance (Untyped.HasMessage (Top'top'results mut) mut) where
-    message (Top'top'results'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Top'top'results mut) mut) where
-    messageDefault msg = (Top'top'results'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Top'top'results msg)) where
-    fromPtr msg ptr = (Top'top'results'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Top'top'results (Message.Mut s))) where
-    toPtr msg (Top'top'results'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Top'top'results (Message.Mut s))) where
-    new msg = (Top'top'results'newtype_ <$> (Untyped.allocStruct msg 0 0))
-instance (Basics.ListElem mut (Top'top'results mut)) where
-    newtype List mut (Top'top'results mut)
-        = Top'top'results'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Top'top'results'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Top'top'results'List_ l) = (Untyped.ListStruct l)
-    length (Top'top'results'List_ l) = (Untyped.length l)
-    index i (Top'top'results'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Top'top'results (Message.Mut s))) where
-    setIndex (Top'top'results'newtype_ elt) i (Top'top'results'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Top'top'results'List_ <$> (Untyped.allocCompositeList msg 0 0 len))
-newtype Left msg
-    = Left'newtype_ (Std_.Maybe (Untyped.Cap msg))
-instance (Classes.FromPtr msg (Left msg)) where
-    fromPtr msg ptr = (Left'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Left (Message.Mut s))) where
-    toPtr msg (Left'newtype_ (Std_.Nothing)) = (Std_.pure Std_.Nothing)
-    toPtr msg (Left'newtype_ (Std_.Just cap)) = (Std_.pure (Std_.Just (Untyped.PtrCap cap)))
-newtype Left'left'params msg
-    = Left'left'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Left'left'params msg)) where
-    fromStruct struct = (Std_.pure (Left'left'params'newtype_ struct))
-instance (Classes.ToStruct msg (Left'left'params msg)) where
-    toStruct (Left'left'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (Left'left'params mut) mut) where
-    message (Left'left'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Left'left'params mut) mut) where
-    messageDefault msg = (Left'left'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Left'left'params msg)) where
-    fromPtr msg ptr = (Left'left'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Left'left'params (Message.Mut s))) where
-    toPtr msg (Left'left'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Left'left'params (Message.Mut s))) where
-    new msg = (Left'left'params'newtype_ <$> (Untyped.allocStruct msg 0 0))
-instance (Basics.ListElem mut (Left'left'params mut)) where
-    newtype List mut (Left'left'params mut)
-        = Left'left'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Left'left'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Left'left'params'List_ l) = (Untyped.ListStruct l)
-    length (Left'left'params'List_ l) = (Untyped.length l)
-    index i (Left'left'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Left'left'params (Message.Mut s))) where
-    setIndex (Left'left'params'newtype_ elt) i (Left'left'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Left'left'params'List_ <$> (Untyped.allocCompositeList msg 0 0 len))
-newtype Left'left'results msg
-    = Left'left'results'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Left'left'results msg)) where
-    fromStruct struct = (Std_.pure (Left'left'results'newtype_ struct))
-instance (Classes.ToStruct msg (Left'left'results msg)) where
-    toStruct (Left'left'results'newtype_ struct) = struct
-instance (Untyped.HasMessage (Left'left'results mut) mut) where
-    message (Left'left'results'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Left'left'results mut) mut) where
-    messageDefault msg = (Left'left'results'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Left'left'results msg)) where
-    fromPtr msg ptr = (Left'left'results'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Left'left'results (Message.Mut s))) where
-    toPtr msg (Left'left'results'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Left'left'results (Message.Mut s))) where
-    new msg = (Left'left'results'newtype_ <$> (Untyped.allocStruct msg 0 0))
-instance (Basics.ListElem mut (Left'left'results mut)) where
-    newtype List mut (Left'left'results mut)
-        = Left'left'results'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Left'left'results'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Left'left'results'List_ l) = (Untyped.ListStruct l)
-    length (Left'left'results'List_ l) = (Untyped.length l)
-    index i (Left'left'results'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Left'left'results (Message.Mut s))) where
-    setIndex (Left'left'results'newtype_ elt) i (Left'left'results'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Left'left'results'List_ <$> (Untyped.allocCompositeList msg 0 0 len))
-newtype Right msg
-    = Right'newtype_ (Std_.Maybe (Untyped.Cap msg))
-instance (Classes.FromPtr msg (Right msg)) where
-    fromPtr msg ptr = (Right'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Right (Message.Mut s))) where
-    toPtr msg (Right'newtype_ (Std_.Nothing)) = (Std_.pure Std_.Nothing)
-    toPtr msg (Right'newtype_ (Std_.Just cap)) = (Std_.pure (Std_.Just (Untyped.PtrCap cap)))
-newtype Right'right'params msg
-    = Right'right'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Right'right'params msg)) where
-    fromStruct struct = (Std_.pure (Right'right'params'newtype_ struct))
-instance (Classes.ToStruct msg (Right'right'params msg)) where
-    toStruct (Right'right'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (Right'right'params mut) mut) where
-    message (Right'right'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Right'right'params mut) mut) where
-    messageDefault msg = (Right'right'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Right'right'params msg)) where
-    fromPtr msg ptr = (Right'right'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Right'right'params (Message.Mut s))) where
-    toPtr msg (Right'right'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Right'right'params (Message.Mut s))) where
-    new msg = (Right'right'params'newtype_ <$> (Untyped.allocStruct msg 0 0))
-instance (Basics.ListElem mut (Right'right'params mut)) where
-    newtype List mut (Right'right'params mut)
-        = Right'right'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Right'right'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Right'right'params'List_ l) = (Untyped.ListStruct l)
-    length (Right'right'params'List_ l) = (Untyped.length l)
-    index i (Right'right'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Right'right'params (Message.Mut s))) where
-    setIndex (Right'right'params'newtype_ elt) i (Right'right'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Right'right'params'List_ <$> (Untyped.allocCompositeList msg 0 0 len))
-newtype Right'right'results msg
-    = Right'right'results'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Right'right'results msg)) where
-    fromStruct struct = (Std_.pure (Right'right'results'newtype_ struct))
-instance (Classes.ToStruct msg (Right'right'results msg)) where
-    toStruct (Right'right'results'newtype_ struct) = struct
-instance (Untyped.HasMessage (Right'right'results mut) mut) where
-    message (Right'right'results'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Right'right'results mut) mut) where
-    messageDefault msg = (Right'right'results'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Right'right'results msg)) where
-    fromPtr msg ptr = (Right'right'results'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Right'right'results (Message.Mut s))) where
-    toPtr msg (Right'right'results'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Right'right'results (Message.Mut s))) where
-    new msg = (Right'right'results'newtype_ <$> (Untyped.allocStruct msg 0 0))
-instance (Basics.ListElem mut (Right'right'results mut)) where
-    newtype List mut (Right'right'results mut)
-        = Right'right'results'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Right'right'results'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Right'right'results'List_ l) = (Untyped.ListStruct l)
-    length (Right'right'results'List_ l) = (Untyped.length l)
-    index i (Right'right'results'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Right'right'results (Message.Mut s))) where
-    setIndex (Right'right'results'newtype_ elt) i (Right'right'results'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Right'right'results'List_ <$> (Untyped.allocCompositeList msg 0 0 len))
-newtype Bottom msg
-    = Bottom'newtype_ (Std_.Maybe (Untyped.Cap msg))
-instance (Classes.FromPtr msg (Bottom msg)) where
-    fromPtr msg ptr = (Bottom'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Bottom (Message.Mut s))) where
-    toPtr msg (Bottom'newtype_ (Std_.Nothing)) = (Std_.pure Std_.Nothing)
-    toPtr msg (Bottom'newtype_ (Std_.Just cap)) = (Std_.pure (Std_.Just (Untyped.PtrCap cap)))
-newtype Bottom'bottom'params msg
-    = Bottom'bottom'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Bottom'bottom'params msg)) where
-    fromStruct struct = (Std_.pure (Bottom'bottom'params'newtype_ struct))
-instance (Classes.ToStruct msg (Bottom'bottom'params msg)) where
-    toStruct (Bottom'bottom'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (Bottom'bottom'params mut) mut) where
-    message (Bottom'bottom'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Bottom'bottom'params mut) mut) where
-    messageDefault msg = (Bottom'bottom'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Bottom'bottom'params msg)) where
-    fromPtr msg ptr = (Bottom'bottom'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Bottom'bottom'params (Message.Mut s))) where
-    toPtr msg (Bottom'bottom'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Bottom'bottom'params (Message.Mut s))) where
-    new msg = (Bottom'bottom'params'newtype_ <$> (Untyped.allocStruct msg 0 0))
-instance (Basics.ListElem mut (Bottom'bottom'params mut)) where
-    newtype List mut (Bottom'bottom'params mut)
-        = Bottom'bottom'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Bottom'bottom'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Bottom'bottom'params'List_ l) = (Untyped.ListStruct l)
-    length (Bottom'bottom'params'List_ l) = (Untyped.length l)
-    index i (Bottom'bottom'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Bottom'bottom'params (Message.Mut s))) where
-    setIndex (Bottom'bottom'params'newtype_ elt) i (Bottom'bottom'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Bottom'bottom'params'List_ <$> (Untyped.allocCompositeList msg 0 0 len))
-newtype Bottom'bottom'results msg
-    = Bottom'bottom'results'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Bottom'bottom'results msg)) where
-    fromStruct struct = (Std_.pure (Bottom'bottom'results'newtype_ struct))
-instance (Classes.ToStruct msg (Bottom'bottom'results msg)) where
-    toStruct (Bottom'bottom'results'newtype_ struct) = struct
-instance (Untyped.HasMessage (Bottom'bottom'results mut) mut) where
-    message (Bottom'bottom'results'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Bottom'bottom'results mut) mut) where
-    messageDefault msg = (Bottom'bottom'results'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Bottom'bottom'results msg)) where
-    fromPtr msg ptr = (Bottom'bottom'results'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Bottom'bottom'results (Message.Mut s))) where
-    toPtr msg (Bottom'bottom'results'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Bottom'bottom'results (Message.Mut s))) where
-    new msg = (Bottom'bottom'results'newtype_ <$> (Untyped.allocStruct msg 0 0))
-instance (Basics.ListElem mut (Bottom'bottom'results mut)) where
-    newtype List mut (Bottom'bottom'results mut)
-        = Bottom'bottom'results'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Bottom'bottom'results'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Bottom'bottom'results'List_ l) = (Untyped.ListStruct l)
-    length (Bottom'bottom'results'List_ l) = (Untyped.length l)
-    index i (Bottom'bottom'results'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Bottom'bottom'results (Message.Mut s))) where
-    setIndex (Bottom'bottom'results'newtype_ elt) i (Bottom'bottom'results'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Bottom'bottom'results'List_ <$> (Untyped.allocCompositeList msg 0 0 len))
-newtype Defaults msg
-    = Defaults'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Defaults msg)) where
-    fromStruct struct = (Std_.pure (Defaults'newtype_ struct))
-instance (Classes.ToStruct msg (Defaults msg)) where
-    toStruct (Defaults'newtype_ struct) = struct
-instance (Untyped.HasMessage (Defaults mut) mut) where
-    message (Defaults'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Defaults mut) mut) where
-    messageDefault msg = (Defaults'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Defaults msg)) where
-    fromPtr msg ptr = (Defaults'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Defaults (Message.Mut s))) where
-    toPtr msg (Defaults'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Defaults (Message.Mut s))) where
-    new msg = (Defaults'newtype_ <$> (Untyped.allocStruct msg 2 2))
-instance (Basics.ListElem mut (Defaults mut)) where
-    newtype List mut (Defaults mut)
-        = Defaults'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Defaults'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Defaults'List_ l) = (Untyped.ListStruct l)
-    length (Defaults'List_ l) = (Untyped.length l)
-    index i (Defaults'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Defaults (Message.Mut s))) where
-    setIndex (Defaults'newtype_ elt) i (Defaults'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Defaults'List_ <$> (Untyped.allocCompositeList msg 2 2 len))
-get_Defaults'text :: ((Untyped.ReadCtx m msg)
-                     ,(Classes.FromPtr msg (Basics.Text msg))) => (Defaults msg) -> (m (Basics.Text msg))
-get_Defaults'text (Defaults'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Defaults'text :: ((Untyped.RWCtx m s)
-                     ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (Defaults (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_Defaults'text (Defaults'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Defaults'text :: ((Untyped.ReadCtx m msg)) => (Defaults msg) -> (m Std_.Bool)
-has_Defaults'text (Defaults'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Defaults'text :: ((Untyped.RWCtx m s)) => Std_.Int -> (Defaults (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_Defaults'text len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_Defaults'text struct result)
-    (Std_.pure result)
-    )
-get_Defaults'data_ :: ((Untyped.ReadCtx m msg)
-                      ,(Classes.FromPtr msg (Basics.Data msg))) => (Defaults msg) -> (m (Basics.Data msg))
-get_Defaults'data_ (Defaults'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Defaults'data_ :: ((Untyped.RWCtx m s)
-                      ,(Classes.ToPtr s (Basics.Data (Message.Mut s)))) => (Defaults (Message.Mut s)) -> (Basics.Data (Message.Mut s)) -> (m ())
-set_Defaults'data_ (Defaults'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Defaults'data_ :: ((Untyped.ReadCtx m msg)) => (Defaults msg) -> (m Std_.Bool)
-has_Defaults'data_ (Defaults'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_Defaults'data_ :: ((Untyped.RWCtx m s)) => Std_.Int -> (Defaults (Message.Mut s)) -> (m (Basics.Data (Message.Mut s)))
-new_Defaults'data_ len struct = (do
-    result <- (Basics.newData (Untyped.message struct) len)
-    (set_Defaults'data_ struct result)
-    (Std_.pure result)
-    )
-get_Defaults'float :: ((Untyped.ReadCtx m msg)) => (Defaults msg) -> (m Std_.Float)
-get_Defaults'float (Defaults'newtype_ struct) = (GenHelpers.getWordField struct 0 0 1078523331)
-set_Defaults'float :: ((Untyped.RWCtx m s)) => (Defaults (Message.Mut s)) -> Std_.Float -> (m ())
-set_Defaults'float (Defaults'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 0 1078523331)
-get_Defaults'int :: ((Untyped.ReadCtx m msg)) => (Defaults msg) -> (m Std_.Int32)
-get_Defaults'int (Defaults'newtype_ struct) = (GenHelpers.getWordField struct 0 32 18446744073709551493)
-set_Defaults'int :: ((Untyped.RWCtx m s)) => (Defaults (Message.Mut s)) -> Std_.Int32 -> (m ())
-set_Defaults'int (Defaults'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 0 32 18446744073709551493)
-get_Defaults'uint :: ((Untyped.ReadCtx m msg)) => (Defaults msg) -> (m Std_.Word32)
-get_Defaults'uint (Defaults'newtype_ struct) = (GenHelpers.getWordField struct 1 0 42)
-set_Defaults'uint :: ((Untyped.RWCtx m s)) => (Defaults (Message.Mut s)) -> Std_.Word32 -> (m ())
-set_Defaults'uint (Defaults'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 1 0 42)
-newtype BenchmarkA msg
-    = BenchmarkA'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (BenchmarkA msg)) where
-    fromStruct struct = (Std_.pure (BenchmarkA'newtype_ struct))
-instance (Classes.ToStruct msg (BenchmarkA msg)) where
-    toStruct (BenchmarkA'newtype_ struct) = struct
-instance (Untyped.HasMessage (BenchmarkA mut) mut) where
-    message (BenchmarkA'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (BenchmarkA mut) mut) where
-    messageDefault msg = (BenchmarkA'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (BenchmarkA msg)) where
-    fromPtr msg ptr = (BenchmarkA'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (BenchmarkA (Message.Mut s))) where
-    toPtr msg (BenchmarkA'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (BenchmarkA (Message.Mut s))) where
-    new msg = (BenchmarkA'newtype_ <$> (Untyped.allocStruct msg 3 2))
-instance (Basics.ListElem mut (BenchmarkA mut)) where
-    newtype List mut (BenchmarkA mut)
-        = BenchmarkA'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (BenchmarkA'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (BenchmarkA'List_ l) = (Untyped.ListStruct l)
-    length (BenchmarkA'List_ l) = (Untyped.length l)
-    index i (BenchmarkA'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (BenchmarkA (Message.Mut s))) where
-    setIndex (BenchmarkA'newtype_ elt) i (BenchmarkA'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (BenchmarkA'List_ <$> (Untyped.allocCompositeList msg 3 2 len))
-get_BenchmarkA'name :: ((Untyped.ReadCtx m msg)
-                       ,(Classes.FromPtr msg (Basics.Text msg))) => (BenchmarkA msg) -> (m (Basics.Text msg))
-get_BenchmarkA'name (BenchmarkA'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_BenchmarkA'name :: ((Untyped.RWCtx m s)
-                       ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (BenchmarkA (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_BenchmarkA'name (BenchmarkA'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_BenchmarkA'name :: ((Untyped.ReadCtx m msg)) => (BenchmarkA msg) -> (m Std_.Bool)
-has_BenchmarkA'name (BenchmarkA'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_BenchmarkA'name :: ((Untyped.RWCtx m s)) => Std_.Int -> (BenchmarkA (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_BenchmarkA'name len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_BenchmarkA'name struct result)
-    (Std_.pure result)
-    )
-get_BenchmarkA'birthDay :: ((Untyped.ReadCtx m msg)) => (BenchmarkA msg) -> (m Std_.Int64)
-get_BenchmarkA'birthDay (BenchmarkA'newtype_ struct) = (GenHelpers.getWordField struct 0 0 0)
-set_BenchmarkA'birthDay :: ((Untyped.RWCtx m s)) => (BenchmarkA (Message.Mut s)) -> Std_.Int64 -> (m ())
-set_BenchmarkA'birthDay (BenchmarkA'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 0 0 0)
-get_BenchmarkA'phone :: ((Untyped.ReadCtx m msg)
-                        ,(Classes.FromPtr msg (Basics.Text msg))) => (BenchmarkA msg) -> (m (Basics.Text msg))
-get_BenchmarkA'phone (BenchmarkA'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_BenchmarkA'phone :: ((Untyped.RWCtx m s)
-                        ,(Classes.ToPtr s (Basics.Text (Message.Mut s)))) => (BenchmarkA (Message.Mut s)) -> (Basics.Text (Message.Mut s)) -> (m ())
-set_BenchmarkA'phone (BenchmarkA'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_BenchmarkA'phone :: ((Untyped.ReadCtx m msg)) => (BenchmarkA msg) -> (m Std_.Bool)
-has_BenchmarkA'phone (BenchmarkA'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_BenchmarkA'phone :: ((Untyped.RWCtx m s)) => Std_.Int -> (BenchmarkA (Message.Mut s)) -> (m (Basics.Text (Message.Mut s)))
-new_BenchmarkA'phone len struct = (do
-    result <- (Basics.newText (Untyped.message struct) len)
-    (set_BenchmarkA'phone struct result)
-    (Std_.pure result)
-    )
-get_BenchmarkA'siblings :: ((Untyped.ReadCtx m msg)) => (BenchmarkA msg) -> (m Std_.Int32)
-get_BenchmarkA'siblings (BenchmarkA'newtype_ struct) = (GenHelpers.getWordField struct 1 0 0)
-set_BenchmarkA'siblings :: ((Untyped.RWCtx m s)) => (BenchmarkA (Message.Mut s)) -> Std_.Int32 -> (m ())
-set_BenchmarkA'siblings (BenchmarkA'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word32) 1 0 0)
-get_BenchmarkA'spouse :: ((Untyped.ReadCtx m msg)) => (BenchmarkA msg) -> (m Std_.Bool)
-get_BenchmarkA'spouse (BenchmarkA'newtype_ struct) = (GenHelpers.getWordField struct 1 32 0)
-set_BenchmarkA'spouse :: ((Untyped.RWCtx m s)) => (BenchmarkA (Message.Mut s)) -> Std_.Bool -> (m ())
-set_BenchmarkA'spouse (BenchmarkA'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word1) 1 32 0)
-get_BenchmarkA'money :: ((Untyped.ReadCtx m msg)) => (BenchmarkA msg) -> (m Std_.Double)
-get_BenchmarkA'money (BenchmarkA'newtype_ struct) = (GenHelpers.getWordField struct 2 0 0)
-set_BenchmarkA'money :: ((Untyped.RWCtx m s)) => (BenchmarkA (Message.Mut s)) -> Std_.Double -> (m ())
-set_BenchmarkA'money (BenchmarkA'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word64) 2 0 0)
diff --git a/gen/tests/Capnp/Gen/Aircraft/New.hs b/gen/tests/Capnp/Gen/Aircraft/New.hs
--- a/gen/tests/Capnp/Gen/Aircraft/New.hs
+++ b/gen/tests/Capnp/Gen/Aircraft/New.hs
@@ -27,15 +27,15 @@
 import qualified Capnp.GenHelpers.New as GH
 import qualified Capnp.New.Classes as C
 import qualified GHC.Generics as Generics
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
+import qualified Capnp.GenHelpers.New.Rpc as GH
 import qualified Prelude as Std_
 import qualified Data.Word as Std_
 import qualified Data.Int as Std_
 import Prelude ((<$>), (<*>), (>>=))
 constDate :: (R.Raw GH.Const Zdate)
-constDate  = (GH.getPtrConst ("\NUL\NUL\NUL\NUL\ETX\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\SOH\NUL\NUL\NUL\NUL\NUL\SOH\NUL\NUL\NUL\223\a\b\ESC\NUL\NUL\NUL\NUL" :: BS.ByteString))
+constDate  = (GH.getPtrConst ("\NUL\NUL\NUL\NUL\ETX\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\SOH\NUL\NUL\NUL\NUL\NUL\SOH\NUL\NUL\NUL\223\a\b\ESC\NUL\NUL\NUL\NUL" :: GH.ByteString))
 constList :: (R.Raw GH.Const (R.List Zdate))
-constList  = (GH.getPtrConst ("\NUL\NUL\NUL\NUL\ENQ\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\SOH\NUL\SOH\NUL\NUL\NUL\ETB\NUL\NUL\NUL\b\NUL\NUL\NUL\SOH\NUL\NUL\NUL\223\a\b\ESC\NUL\NUL\NUL\NUL\223\a\b\FS\NUL\NUL\NUL\NUL" :: BS.ByteString))
+constList  = (GH.getPtrConst ("\NUL\NUL\NUL\NUL\ENQ\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\SOH\NUL\SOH\NUL\NUL\NUL\ETB\NUL\NUL\NUL\b\NUL\NUL\NUL\SOH\NUL\NUL\NUL\223\a\b\ESC\NUL\NUL\NUL\NUL\223\a\b\FS\NUL\NUL\NUL\NUL" :: GH.ByteString))
 constEnum :: Airport
 constEnum  = (C.fromWord 1)
 data Zdate 
diff --git a/gen/tests/Capnp/Gen/Aircraft/Pure.hs b/gen/tests/Capnp/Gen/Aircraft/Pure.hs
deleted file mode 100644
--- a/gen/tests/Capnp/Gen/Aircraft/Pure.hs
+++ /dev/null
@@ -1,2977 +0,0 @@
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE RecordWildCards #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Aircraft.Pure(Capnp.Gen.ById.X832bcc6686a26d56.Airport(..)
-                              ,constDate
-                              ,constList
-                              ,Capnp.Gen.ById.X832bcc6686a26d56.constEnum
-                              ,Zdate(..)
-                              ,Zdata(..)
-                              ,PlaneBase(..)
-                              ,B737(..)
-                              ,A320(..)
-                              ,F16(..)
-                              ,Regression(..)
-                              ,Aircraft(..)
-                              ,Z(..)
-                              ,Z'grp(..)
-                              ,Counter(..)
-                              ,Bag(..)
-                              ,Zserver(..)
-                              ,Zjob(..)
-                              ,VerEmpty(..)
-                              ,VerOneData(..)
-                              ,VerTwoData(..)
-                              ,VerOnePtr(..)
-                              ,VerTwoPtr(..)
-                              ,VerTwoDataTwoPtr(..)
-                              ,HoldsVerEmptyList(..)
-                              ,HoldsVerOneDataList(..)
-                              ,HoldsVerTwoDataList(..)
-                              ,HoldsVerOnePtrList(..)
-                              ,HoldsVerTwoPtrList(..)
-                              ,HoldsVerTwoTwoList(..)
-                              ,HoldsVerTwoTwoPlus(..)
-                              ,VerTwoTwoPlus(..)
-                              ,HoldsText(..)
-                              ,WrapEmpty(..)
-                              ,Wrap2x2(..)
-                              ,Wrap2x2plus(..)
-                              ,VoidUnion(..)
-                              ,Nester1Capn(..)
-                              ,RWTestCapn(..)
-                              ,ListStructCapn(..)
-                              ,Echo(..)
-                              ,Echo'server_(..)
-                              ,export_Echo
-                              ,Echo'echo'params(..)
-                              ,Echo'echo'results(..)
-                              ,Hoth(..)
-                              ,EchoBase(..)
-                              ,EchoBases(..)
-                              ,StackingRoot(..)
-                              ,StackingA(..)
-                              ,StackingB(..)
-                              ,CallSequence(..)
-                              ,CallSequence'server_(..)
-                              ,export_CallSequence
-                              ,CallSequence'getNumber'params(..)
-                              ,CallSequence'getNumber'results(..)
-                              ,CounterFactory(..)
-                              ,CounterFactory'server_(..)
-                              ,export_CounterFactory
-                              ,CounterFactory'newCounter'params(..)
-                              ,CounterFactory'newCounter'results(..)
-                              ,CounterAcceptor(..)
-                              ,CounterAcceptor'server_(..)
-                              ,export_CounterAcceptor
-                              ,CounterAcceptor'accept'params(..)
-                              ,CounterAcceptor'accept'results(..)
-                              ,Top(..)
-                              ,Top'server_(..)
-                              ,export_Top
-                              ,Top'top'params(..)
-                              ,Top'top'results(..)
-                              ,Left(..)
-                              ,Left'server_(..)
-                              ,export_Left
-                              ,Left'left'params(..)
-                              ,Left'left'results(..)
-                              ,Right(..)
-                              ,Right'server_(..)
-                              ,export_Right
-                              ,Right'right'params(..)
-                              ,Right'right'results(..)
-                              ,Bottom(..)
-                              ,Bottom'server_(..)
-                              ,export_Bottom
-                              ,Bottom'bottom'params(..)
-                              ,Bottom'bottom'results(..)
-                              ,Defaults(..)
-                              ,BenchmarkA(..)) where
-import qualified Capnp.GenHelpers.ReExports.Data.Vector as V
-import qualified Capnp.GenHelpers.ReExports.Data.Text as T
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Capnp.GenHelpers.ReExports.Data.Default as Default
-import qualified GHC.Generics as Generics
-import qualified Control.Monad.IO.Class as MonadIO
-import qualified Capnp.Untyped.Pure as UntypedPure
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Message as Message
-import qualified Capnp.Classes as Classes
-import qualified Capnp.Basics.Pure as BasicsPure
-import qualified Capnp.GenHelpers.Pure as GenHelpersPure
-import qualified Capnp.Rpc.Untyped as Rpc
-import qualified Capnp.Rpc.Server as Server
-import qualified Capnp.GenHelpers.Rpc as RpcHelpers
-import qualified Capnp.GenHelpers.ReExports.Control.Concurrent.STM as STM
-import qualified Capnp.GenHelpers.ReExports.Control.Monad.STM.Class as STM
-import qualified Capnp.GenHelpers.ReExports.Supervisors as Supervisors
-import qualified Capnp.Gen.ById.X832bcc6686a26d56
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-constDate :: Zdate
-constDate  = (GenHelpersPure.toPurePtrConst Capnp.Gen.ById.X832bcc6686a26d56.constDate)
-constList :: (V.Vector Zdate)
-constList  = (GenHelpersPure.toPurePtrConst Capnp.Gen.ById.X832bcc6686a26d56.constList)
-data Zdate 
-    = Zdate 
-        {year :: Std_.Int16
-        ,month :: Std_.Word8
-        ,day :: Std_.Word8}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Zdate) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Zdate) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Zdate) where
-    type Cerial msg Zdate = (Capnp.Gen.ById.X832bcc6686a26d56.Zdate msg)
-    decerialize raw = (Zdate <$> (Capnp.Gen.ById.X832bcc6686a26d56.get_Zdate'year raw)
-                             <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_Zdate'month raw)
-                             <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_Zdate'day raw))
-instance (Classes.Marshal s Zdate) where
-    marshalInto raw_ value_ = case value_ of
-        Zdate{..} ->
-            (do
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_Zdate'year raw_ year)
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_Zdate'month raw_ month)
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_Zdate'day raw_ day)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Zdate)
-instance (Classes.Cerialize s (V.Vector Zdate)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Zdate))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Zdate)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Zdate))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Zdate)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Zdate))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Zdate)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Zdata 
-    = Zdata 
-        {data_ :: BS.ByteString}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Zdata) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Zdata) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Zdata) where
-    type Cerial msg Zdata = (Capnp.Gen.ById.X832bcc6686a26d56.Zdata msg)
-    decerialize raw = (Zdata <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Zdata'data_ raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Zdata) where
-    marshalInto raw_ value_ = case value_ of
-        Zdata{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) data_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Zdata'data_ raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Zdata)
-instance (Classes.Cerialize s (V.Vector Zdata)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Zdata))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Zdata)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Zdata))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Zdata)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Zdata))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Zdata)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data PlaneBase 
-    = PlaneBase 
-        {name :: T.Text
-        ,homes :: (V.Vector Capnp.Gen.ById.X832bcc6686a26d56.Airport)
-        ,rating :: Std_.Int64
-        ,canFly :: Std_.Bool
-        ,capacity :: Std_.Int64
-        ,maxSpeed :: Std_.Double}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default PlaneBase) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const PlaneBase) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize PlaneBase) where
-    type Cerial msg PlaneBase = (Capnp.Gen.ById.X832bcc6686a26d56.PlaneBase msg)
-    decerialize raw = (PlaneBase <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_PlaneBase'name raw) >>= Classes.decerialize)
-                                 <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_PlaneBase'homes raw) >>= Classes.decerialize)
-                                 <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_PlaneBase'rating raw)
-                                 <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_PlaneBase'canFly raw)
-                                 <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_PlaneBase'capacity raw)
-                                 <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_PlaneBase'maxSpeed raw))
-instance (Classes.Marshal s PlaneBase) where
-    marshalInto raw_ value_ = case value_ of
-        PlaneBase{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) name) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_PlaneBase'name raw_))
-                ((Classes.cerialize (Untyped.message raw_) homes) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_PlaneBase'homes raw_))
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_PlaneBase'rating raw_ rating)
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_PlaneBase'canFly raw_ canFly)
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_PlaneBase'capacity raw_ capacity)
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_PlaneBase'maxSpeed raw_ maxSpeed)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s PlaneBase)
-instance (Classes.Cerialize s (V.Vector PlaneBase)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector PlaneBase))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector PlaneBase)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector PlaneBase))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector PlaneBase)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector PlaneBase))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector PlaneBase)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data B737 
-    = B737 
-        {base :: PlaneBase}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default B737) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const B737) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize B737) where
-    type Cerial msg B737 = (Capnp.Gen.ById.X832bcc6686a26d56.B737 msg)
-    decerialize raw = (B737 <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_B737'base raw) >>= Classes.decerialize))
-instance (Classes.Marshal s B737) where
-    marshalInto raw_ value_ = case value_ of
-        B737{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) base) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_B737'base raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s B737)
-instance (Classes.Cerialize s (V.Vector B737)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector B737))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector B737)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector B737))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector B737)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector B737))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector B737)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data A320 
-    = A320 
-        {base :: PlaneBase}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default A320) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const A320) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize A320) where
-    type Cerial msg A320 = (Capnp.Gen.ById.X832bcc6686a26d56.A320 msg)
-    decerialize raw = (A320 <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_A320'base raw) >>= Classes.decerialize))
-instance (Classes.Marshal s A320) where
-    marshalInto raw_ value_ = case value_ of
-        A320{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) base) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_A320'base raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s A320)
-instance (Classes.Cerialize s (V.Vector A320)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector A320))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector A320)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector A320))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector A320)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector A320))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector A320)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data F16 
-    = F16 
-        {base :: PlaneBase}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default F16) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const F16) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize F16) where
-    type Cerial msg F16 = (Capnp.Gen.ById.X832bcc6686a26d56.F16 msg)
-    decerialize raw = (F16 <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_F16'base raw) >>= Classes.decerialize))
-instance (Classes.Marshal s F16) where
-    marshalInto raw_ value_ = case value_ of
-        F16{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) base) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_F16'base raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s F16)
-instance (Classes.Cerialize s (V.Vector F16)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector F16))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector F16)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector F16))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector F16)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector F16))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector F16)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Regression 
-    = Regression 
-        {base :: PlaneBase
-        ,b0 :: Std_.Double
-        ,beta :: (V.Vector Std_.Double)
-        ,planes :: (V.Vector Aircraft)
-        ,ymu :: Std_.Double
-        ,ysd :: Std_.Double}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Regression) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Regression) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Regression) where
-    type Cerial msg Regression = (Capnp.Gen.ById.X832bcc6686a26d56.Regression msg)
-    decerialize raw = (Regression <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Regression'base raw) >>= Classes.decerialize)
-                                  <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_Regression'b0 raw)
-                                  <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Regression'beta raw) >>= Classes.decerialize)
-                                  <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Regression'planes raw) >>= Classes.decerialize)
-                                  <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_Regression'ymu raw)
-                                  <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_Regression'ysd raw))
-instance (Classes.Marshal s Regression) where
-    marshalInto raw_ value_ = case value_ of
-        Regression{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) base) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Regression'base raw_))
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_Regression'b0 raw_ b0)
-                ((Classes.cerialize (Untyped.message raw_) beta) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Regression'beta raw_))
-                ((Classes.cerialize (Untyped.message raw_) planes) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Regression'planes raw_))
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_Regression'ymu raw_ ymu)
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_Regression'ysd raw_ ysd)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Regression)
-instance (Classes.Cerialize s (V.Vector Regression)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Regression))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Regression)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Regression))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Regression)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Regression))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Regression)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Aircraft 
-    = Aircraft'void 
-    | Aircraft'b737 B737
-    | Aircraft'a320 A320
-    | Aircraft'f16 F16
-    | Aircraft'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Aircraft) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Aircraft) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Aircraft) where
-    type Cerial msg Aircraft = (Capnp.Gen.ById.X832bcc6686a26d56.Aircraft msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.X832bcc6686a26d56.get_Aircraft' raw)
-        case raw of
-            (Capnp.Gen.ById.X832bcc6686a26d56.Aircraft'void) ->
-                (Std_.pure Aircraft'void)
-            (Capnp.Gen.ById.X832bcc6686a26d56.Aircraft'b737 raw) ->
-                (Aircraft'b737 <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Aircraft'a320 raw) ->
-                (Aircraft'a320 <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Aircraft'f16 raw) ->
-                (Aircraft'f16 <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Aircraft'unknown' tag) ->
-                (Std_.pure (Aircraft'unknown' tag))
-        )
-instance (Classes.Marshal s Aircraft) where
-    marshalInto raw_ value_ = case value_ of
-        (Aircraft'void) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_Aircraft'void raw_)
-        (Aircraft'b737 arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Aircraft'b737 raw_))
-        (Aircraft'a320 arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Aircraft'a320 raw_))
-        (Aircraft'f16 arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Aircraft'f16 raw_))
-        (Aircraft'unknown' tag) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_Aircraft'unknown' raw_ tag)
-instance (Classes.Cerialize s Aircraft)
-instance (Classes.Cerialize s (V.Vector Aircraft)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Aircraft))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Aircraft)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Aircraft))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Aircraft)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Aircraft))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Aircraft)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Z 
-    = Z'void 
-    | Z'zz Z
-    | Z'f64 Std_.Double
-    | Z'f32 Std_.Float
-    | Z'i64 Std_.Int64
-    | Z'i32 Std_.Int32
-    | Z'i16 Std_.Int16
-    | Z'i8 Std_.Int8
-    | Z'u64 Std_.Word64
-    | Z'u32 Std_.Word32
-    | Z'u16 Std_.Word16
-    | Z'u8 Std_.Word8
-    | Z'bool Std_.Bool
-    | Z'text T.Text
-    | Z'blob BS.ByteString
-    | Z'f64vec (V.Vector Std_.Double)
-    | Z'f32vec (V.Vector Std_.Float)
-    | Z'i64vec (V.Vector Std_.Int64)
-    | Z'i32vec (V.Vector Std_.Int32)
-    | Z'i16vec (V.Vector Std_.Int16)
-    | Z'i8vec (V.Vector Std_.Int8)
-    | Z'u64vec (V.Vector Std_.Word64)
-    | Z'u32vec (V.Vector Std_.Word32)
-    | Z'u16vec (V.Vector Std_.Word16)
-    | Z'u8vec (V.Vector Std_.Word8)
-    | Z'zvec (V.Vector Z)
-    | Z'zvecvec (V.Vector (V.Vector Z))
-    | Z'zdate Zdate
-    | Z'zdata Zdata
-    | Z'aircraftvec (V.Vector Aircraft)
-    | Z'aircraft Aircraft
-    | Z'regression Regression
-    | Z'planebase PlaneBase
-    | Z'airport Capnp.Gen.ById.X832bcc6686a26d56.Airport
-    | Z'b737 B737
-    | Z'a320 A320
-    | Z'f16 F16
-    | Z'zdatevec (V.Vector Zdate)
-    | Z'zdatavec (V.Vector Zdata)
-    | Z'boolvec (V.Vector Std_.Bool)
-    | Z'datavec (V.Vector BS.ByteString)
-    | Z'textvec (V.Vector T.Text)
-    | Z'grp Z'grp
-    | Z'echo Echo
-    | Z'echoBases EchoBases
-    | Z'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Z) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Z) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Z) where
-    type Cerial msg Z = (Capnp.Gen.ById.X832bcc6686a26d56.Z msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.X832bcc6686a26d56.get_Z' raw)
-        case raw of
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'void) ->
-                (Std_.pure Z'void)
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'zz raw) ->
-                (Z'zz <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'f64 raw) ->
-                (Std_.pure (Z'f64 raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'f32 raw) ->
-                (Std_.pure (Z'f32 raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'i64 raw) ->
-                (Std_.pure (Z'i64 raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'i32 raw) ->
-                (Std_.pure (Z'i32 raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'i16 raw) ->
-                (Std_.pure (Z'i16 raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'i8 raw) ->
-                (Std_.pure (Z'i8 raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'u64 raw) ->
-                (Std_.pure (Z'u64 raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'u32 raw) ->
-                (Std_.pure (Z'u32 raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'u16 raw) ->
-                (Std_.pure (Z'u16 raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'u8 raw) ->
-                (Std_.pure (Z'u8 raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'bool raw) ->
-                (Std_.pure (Z'bool raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'text raw) ->
-                (Z'text <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'blob raw) ->
-                (Z'blob <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'f64vec raw) ->
-                (Z'f64vec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'f32vec raw) ->
-                (Z'f32vec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'i64vec raw) ->
-                (Z'i64vec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'i32vec raw) ->
-                (Z'i32vec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'i16vec raw) ->
-                (Z'i16vec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'i8vec raw) ->
-                (Z'i8vec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'u64vec raw) ->
-                (Z'u64vec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'u32vec raw) ->
-                (Z'u32vec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'u16vec raw) ->
-                (Z'u16vec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'u8vec raw) ->
-                (Z'u8vec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'zvec raw) ->
-                (Z'zvec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'zvecvec raw) ->
-                (Z'zvecvec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'zdate raw) ->
-                (Z'zdate <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'zdata raw) ->
-                (Z'zdata <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'aircraftvec raw) ->
-                (Z'aircraftvec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'aircraft raw) ->
-                (Z'aircraft <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'regression raw) ->
-                (Z'regression <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'planebase raw) ->
-                (Z'planebase <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'airport raw) ->
-                (Std_.pure (Z'airport raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'b737 raw) ->
-                (Z'b737 <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'a320 raw) ->
-                (Z'a320 <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'f16 raw) ->
-                (Z'f16 <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'zdatevec raw) ->
-                (Z'zdatevec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'zdatavec raw) ->
-                (Z'zdatavec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'boolvec raw) ->
-                (Z'boolvec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'datavec raw) ->
-                (Z'datavec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'textvec raw) ->
-                (Z'textvec <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'grp raw) ->
-                (Z'grp <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'echo raw) ->
-                (Z'echo <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'echoBases raw) ->
-                (Z'echoBases <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.X832bcc6686a26d56.Z'unknown' tag) ->
-                (Std_.pure (Z'unknown' tag))
-        )
-instance (Classes.Marshal s Z) where
-    marshalInto raw_ value_ = case value_ of
-        (Z'void) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'void raw_)
-        (Z'zz arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'zz raw_))
-        (Z'f64 arg_) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'f64 raw_ arg_)
-        (Z'f32 arg_) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'f32 raw_ arg_)
-        (Z'i64 arg_) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'i64 raw_ arg_)
-        (Z'i32 arg_) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'i32 raw_ arg_)
-        (Z'i16 arg_) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'i16 raw_ arg_)
-        (Z'i8 arg_) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'i8 raw_ arg_)
-        (Z'u64 arg_) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'u64 raw_ arg_)
-        (Z'u32 arg_) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'u32 raw_ arg_)
-        (Z'u16 arg_) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'u16 raw_ arg_)
-        (Z'u8 arg_) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'u8 raw_ arg_)
-        (Z'bool arg_) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'bool raw_ arg_)
-        (Z'text arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'text raw_))
-        (Z'blob arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'blob raw_))
-        (Z'f64vec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'f64vec raw_))
-        (Z'f32vec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'f32vec raw_))
-        (Z'i64vec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'i64vec raw_))
-        (Z'i32vec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'i32vec raw_))
-        (Z'i16vec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'i16vec raw_))
-        (Z'i8vec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'i8vec raw_))
-        (Z'u64vec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'u64vec raw_))
-        (Z'u32vec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'u32vec raw_))
-        (Z'u16vec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'u16vec raw_))
-        (Z'u8vec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'u8vec raw_))
-        (Z'zvec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'zvec raw_))
-        (Z'zvecvec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'zvecvec raw_))
-        (Z'zdate arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'zdate raw_))
-        (Z'zdata arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'zdata raw_))
-        (Z'aircraftvec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'aircraftvec raw_))
-        (Z'aircraft arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'aircraft raw_))
-        (Z'regression arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'regression raw_))
-        (Z'planebase arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'planebase raw_))
-        (Z'airport arg_) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'airport raw_ arg_)
-        (Z'b737 arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'b737 raw_))
-        (Z'a320 arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'a320 raw_))
-        (Z'f16 arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'f16 raw_))
-        (Z'zdatevec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'zdatevec raw_))
-        (Z'zdatavec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'zdatavec raw_))
-        (Z'boolvec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'boolvec raw_))
-        (Z'datavec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'datavec raw_))
-        (Z'textvec arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'textvec raw_))
-        (Z'grp arg_) ->
-            (do
-                raw_ <- (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'grp raw_)
-                (Classes.marshalInto raw_ arg_)
-                )
-        (Z'echo arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'echo raw_))
-        (Z'echoBases arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'echoBases raw_))
-        (Z'unknown' tag) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'unknown' raw_ tag)
-instance (Classes.Cerialize s Z)
-instance (Classes.Cerialize s (V.Vector Z)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Z))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Z)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Z))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Z)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Z))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Z)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Z'grp 
-    = Z'grp' 
-        {first :: Std_.Word64
-        ,second :: Std_.Word64}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Z'grp) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Z'grp) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Z'grp) where
-    type Cerial msg Z'grp = (Capnp.Gen.ById.X832bcc6686a26d56.Z'grp msg)
-    decerialize raw = (Z'grp' <$> (Capnp.Gen.ById.X832bcc6686a26d56.get_Z'grp'first raw)
-                              <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_Z'grp'second raw))
-instance (Classes.Marshal s Z'grp) where
-    marshalInto raw_ value_ = case value_ of
-        Z'grp'{..} ->
-            (do
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'grp'first raw_ first)
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_Z'grp'second raw_ second)
-                (Std_.pure ())
-                )
-data Counter 
-    = Counter 
-        {size :: Std_.Int64
-        ,words :: T.Text
-        ,wordlist :: (V.Vector T.Text)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Counter) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Counter) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Counter) where
-    type Cerial msg Counter = (Capnp.Gen.ById.X832bcc6686a26d56.Counter msg)
-    decerialize raw = (Counter <$> (Capnp.Gen.ById.X832bcc6686a26d56.get_Counter'size raw)
-                               <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Counter'words raw) >>= Classes.decerialize)
-                               <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Counter'wordlist raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Counter) where
-    marshalInto raw_ value_ = case value_ of
-        Counter{..} ->
-            (do
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_Counter'size raw_ size)
-                ((Classes.cerialize (Untyped.message raw_) words) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Counter'words raw_))
-                ((Classes.cerialize (Untyped.message raw_) wordlist) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Counter'wordlist raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Counter)
-instance (Classes.Cerialize s (V.Vector Counter)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Counter))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Counter)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Counter))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Counter)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Counter))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Counter)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Bag 
-    = Bag 
-        {counter :: Counter}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Bag) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Bag) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Bag) where
-    type Cerial msg Bag = (Capnp.Gen.ById.X832bcc6686a26d56.Bag msg)
-    decerialize raw = (Bag <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Bag'counter raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Bag) where
-    marshalInto raw_ value_ = case value_ of
-        Bag{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) counter) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Bag'counter raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Bag)
-instance (Classes.Cerialize s (V.Vector Bag)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Bag))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Bag)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Bag))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Bag)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Bag))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Bag)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Zserver 
-    = Zserver 
-        {waitingjobs :: (V.Vector Zjob)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Zserver) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Zserver) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Zserver) where
-    type Cerial msg Zserver = (Capnp.Gen.ById.X832bcc6686a26d56.Zserver msg)
-    decerialize raw = (Zserver <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Zserver'waitingjobs raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Zserver) where
-    marshalInto raw_ value_ = case value_ of
-        Zserver{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) waitingjobs) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Zserver'waitingjobs raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Zserver)
-instance (Classes.Cerialize s (V.Vector Zserver)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Zserver))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Zserver)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Zserver))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Zserver)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Zserver))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Zserver)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Zjob 
-    = Zjob 
-        {cmd :: T.Text
-        ,args :: (V.Vector T.Text)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Zjob) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Zjob) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Zjob) where
-    type Cerial msg Zjob = (Capnp.Gen.ById.X832bcc6686a26d56.Zjob msg)
-    decerialize raw = (Zjob <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Zjob'cmd raw) >>= Classes.decerialize)
-                            <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Zjob'args raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Zjob) where
-    marshalInto raw_ value_ = case value_ of
-        Zjob{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) cmd) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Zjob'cmd raw_))
-                ((Classes.cerialize (Untyped.message raw_) args) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Zjob'args raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Zjob)
-instance (Classes.Cerialize s (V.Vector Zjob)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Zjob))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Zjob)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Zjob))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Zjob)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Zjob))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Zjob)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data VerEmpty 
-    = VerEmpty 
-        {}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default VerEmpty) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const VerEmpty) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize VerEmpty) where
-    type Cerial msg VerEmpty = (Capnp.Gen.ById.X832bcc6686a26d56.VerEmpty msg)
-    decerialize raw = (Std_.pure VerEmpty)
-instance (Classes.Marshal s VerEmpty) where
-    marshalInto raw_ value_ = case value_ of
-        (VerEmpty) ->
-            (do
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s VerEmpty)
-instance (Classes.Cerialize s (V.Vector VerEmpty)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector VerEmpty))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector VerEmpty)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector VerEmpty))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerEmpty)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerEmpty))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerEmpty)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data VerOneData 
-    = VerOneData 
-        {val :: Std_.Int16}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default VerOneData) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const VerOneData) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize VerOneData) where
-    type Cerial msg VerOneData = (Capnp.Gen.ById.X832bcc6686a26d56.VerOneData msg)
-    decerialize raw = (VerOneData <$> (Capnp.Gen.ById.X832bcc6686a26d56.get_VerOneData'val raw))
-instance (Classes.Marshal s VerOneData) where
-    marshalInto raw_ value_ = case value_ of
-        VerOneData{..} ->
-            (do
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_VerOneData'val raw_ val)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s VerOneData)
-instance (Classes.Cerialize s (V.Vector VerOneData)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector VerOneData))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector VerOneData)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector VerOneData))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerOneData)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerOneData))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerOneData)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data VerTwoData 
-    = VerTwoData 
-        {val :: Std_.Int16
-        ,duo :: Std_.Int64}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default VerTwoData) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const VerTwoData) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize VerTwoData) where
-    type Cerial msg VerTwoData = (Capnp.Gen.ById.X832bcc6686a26d56.VerTwoData msg)
-    decerialize raw = (VerTwoData <$> (Capnp.Gen.ById.X832bcc6686a26d56.get_VerTwoData'val raw)
-                                  <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_VerTwoData'duo raw))
-instance (Classes.Marshal s VerTwoData) where
-    marshalInto raw_ value_ = case value_ of
-        VerTwoData{..} ->
-            (do
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_VerTwoData'val raw_ val)
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_VerTwoData'duo raw_ duo)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s VerTwoData)
-instance (Classes.Cerialize s (V.Vector VerTwoData)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector VerTwoData))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector VerTwoData)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector VerTwoData))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerTwoData)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerTwoData))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerTwoData)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data VerOnePtr 
-    = VerOnePtr 
-        {ptr :: VerOneData}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default VerOnePtr) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const VerOnePtr) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize VerOnePtr) where
-    type Cerial msg VerOnePtr = (Capnp.Gen.ById.X832bcc6686a26d56.VerOnePtr msg)
-    decerialize raw = (VerOnePtr <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_VerOnePtr'ptr raw) >>= Classes.decerialize))
-instance (Classes.Marshal s VerOnePtr) where
-    marshalInto raw_ value_ = case value_ of
-        VerOnePtr{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) ptr) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_VerOnePtr'ptr raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s VerOnePtr)
-instance (Classes.Cerialize s (V.Vector VerOnePtr)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector VerOnePtr))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector VerOnePtr)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector VerOnePtr))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerOnePtr)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerOnePtr))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerOnePtr)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data VerTwoPtr 
-    = VerTwoPtr 
-        {ptr1 :: VerOneData
-        ,ptr2 :: VerOneData}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default VerTwoPtr) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const VerTwoPtr) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize VerTwoPtr) where
-    type Cerial msg VerTwoPtr = (Capnp.Gen.ById.X832bcc6686a26d56.VerTwoPtr msg)
-    decerialize raw = (VerTwoPtr <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_VerTwoPtr'ptr1 raw) >>= Classes.decerialize)
-                                 <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_VerTwoPtr'ptr2 raw) >>= Classes.decerialize))
-instance (Classes.Marshal s VerTwoPtr) where
-    marshalInto raw_ value_ = case value_ of
-        VerTwoPtr{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) ptr1) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_VerTwoPtr'ptr1 raw_))
-                ((Classes.cerialize (Untyped.message raw_) ptr2) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_VerTwoPtr'ptr2 raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s VerTwoPtr)
-instance (Classes.Cerialize s (V.Vector VerTwoPtr)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector VerTwoPtr))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector VerTwoPtr)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector VerTwoPtr))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerTwoPtr)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerTwoPtr))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerTwoPtr)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data VerTwoDataTwoPtr 
-    = VerTwoDataTwoPtr 
-        {val :: Std_.Int16
-        ,duo :: Std_.Int64
-        ,ptr1 :: VerOneData
-        ,ptr2 :: VerOneData}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default VerTwoDataTwoPtr) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const VerTwoDataTwoPtr) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize VerTwoDataTwoPtr) where
-    type Cerial msg VerTwoDataTwoPtr = (Capnp.Gen.ById.X832bcc6686a26d56.VerTwoDataTwoPtr msg)
-    decerialize raw = (VerTwoDataTwoPtr <$> (Capnp.Gen.ById.X832bcc6686a26d56.get_VerTwoDataTwoPtr'val raw)
-                                        <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_VerTwoDataTwoPtr'duo raw)
-                                        <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_VerTwoDataTwoPtr'ptr1 raw) >>= Classes.decerialize)
-                                        <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_VerTwoDataTwoPtr'ptr2 raw) >>= Classes.decerialize))
-instance (Classes.Marshal s VerTwoDataTwoPtr) where
-    marshalInto raw_ value_ = case value_ of
-        VerTwoDataTwoPtr{..} ->
-            (do
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_VerTwoDataTwoPtr'val raw_ val)
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_VerTwoDataTwoPtr'duo raw_ duo)
-                ((Classes.cerialize (Untyped.message raw_) ptr1) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_VerTwoDataTwoPtr'ptr1 raw_))
-                ((Classes.cerialize (Untyped.message raw_) ptr2) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_VerTwoDataTwoPtr'ptr2 raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s VerTwoDataTwoPtr)
-instance (Classes.Cerialize s (V.Vector VerTwoDataTwoPtr)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector VerTwoDataTwoPtr))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector VerTwoDataTwoPtr)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector VerTwoDataTwoPtr))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerTwoDataTwoPtr)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerTwoDataTwoPtr))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerTwoDataTwoPtr)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data HoldsVerEmptyList 
-    = HoldsVerEmptyList 
-        {mylist :: (V.Vector VerEmpty)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default HoldsVerEmptyList) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const HoldsVerEmptyList) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize HoldsVerEmptyList) where
-    type Cerial msg HoldsVerEmptyList = (Capnp.Gen.ById.X832bcc6686a26d56.HoldsVerEmptyList msg)
-    decerialize raw = (HoldsVerEmptyList <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_HoldsVerEmptyList'mylist raw) >>= Classes.decerialize))
-instance (Classes.Marshal s HoldsVerEmptyList) where
-    marshalInto raw_ value_ = case value_ of
-        HoldsVerEmptyList{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) mylist) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_HoldsVerEmptyList'mylist raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s HoldsVerEmptyList)
-instance (Classes.Cerialize s (V.Vector HoldsVerEmptyList)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector HoldsVerEmptyList))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector HoldsVerEmptyList)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerEmptyList))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerEmptyList)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerEmptyList))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerEmptyList)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data HoldsVerOneDataList 
-    = HoldsVerOneDataList 
-        {mylist :: (V.Vector VerOneData)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default HoldsVerOneDataList) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const HoldsVerOneDataList) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize HoldsVerOneDataList) where
-    type Cerial msg HoldsVerOneDataList = (Capnp.Gen.ById.X832bcc6686a26d56.HoldsVerOneDataList msg)
-    decerialize raw = (HoldsVerOneDataList <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_HoldsVerOneDataList'mylist raw) >>= Classes.decerialize))
-instance (Classes.Marshal s HoldsVerOneDataList) where
-    marshalInto raw_ value_ = case value_ of
-        HoldsVerOneDataList{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) mylist) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_HoldsVerOneDataList'mylist raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s HoldsVerOneDataList)
-instance (Classes.Cerialize s (V.Vector HoldsVerOneDataList)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector HoldsVerOneDataList))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector HoldsVerOneDataList)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerOneDataList))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerOneDataList)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerOneDataList))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerOneDataList)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data HoldsVerTwoDataList 
-    = HoldsVerTwoDataList 
-        {mylist :: (V.Vector VerTwoData)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default HoldsVerTwoDataList) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const HoldsVerTwoDataList) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize HoldsVerTwoDataList) where
-    type Cerial msg HoldsVerTwoDataList = (Capnp.Gen.ById.X832bcc6686a26d56.HoldsVerTwoDataList msg)
-    decerialize raw = (HoldsVerTwoDataList <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_HoldsVerTwoDataList'mylist raw) >>= Classes.decerialize))
-instance (Classes.Marshal s HoldsVerTwoDataList) where
-    marshalInto raw_ value_ = case value_ of
-        HoldsVerTwoDataList{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) mylist) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_HoldsVerTwoDataList'mylist raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s HoldsVerTwoDataList)
-instance (Classes.Cerialize s (V.Vector HoldsVerTwoDataList)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector HoldsVerTwoDataList))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector HoldsVerTwoDataList)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerTwoDataList))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerTwoDataList)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerTwoDataList))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerTwoDataList)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data HoldsVerOnePtrList 
-    = HoldsVerOnePtrList 
-        {mylist :: (V.Vector VerOnePtr)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default HoldsVerOnePtrList) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const HoldsVerOnePtrList) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize HoldsVerOnePtrList) where
-    type Cerial msg HoldsVerOnePtrList = (Capnp.Gen.ById.X832bcc6686a26d56.HoldsVerOnePtrList msg)
-    decerialize raw = (HoldsVerOnePtrList <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_HoldsVerOnePtrList'mylist raw) >>= Classes.decerialize))
-instance (Classes.Marshal s HoldsVerOnePtrList) where
-    marshalInto raw_ value_ = case value_ of
-        HoldsVerOnePtrList{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) mylist) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_HoldsVerOnePtrList'mylist raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s HoldsVerOnePtrList)
-instance (Classes.Cerialize s (V.Vector HoldsVerOnePtrList)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector HoldsVerOnePtrList))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector HoldsVerOnePtrList)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerOnePtrList))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerOnePtrList)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerOnePtrList))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerOnePtrList)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data HoldsVerTwoPtrList 
-    = HoldsVerTwoPtrList 
-        {mylist :: (V.Vector VerTwoPtr)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default HoldsVerTwoPtrList) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const HoldsVerTwoPtrList) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize HoldsVerTwoPtrList) where
-    type Cerial msg HoldsVerTwoPtrList = (Capnp.Gen.ById.X832bcc6686a26d56.HoldsVerTwoPtrList msg)
-    decerialize raw = (HoldsVerTwoPtrList <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_HoldsVerTwoPtrList'mylist raw) >>= Classes.decerialize))
-instance (Classes.Marshal s HoldsVerTwoPtrList) where
-    marshalInto raw_ value_ = case value_ of
-        HoldsVerTwoPtrList{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) mylist) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_HoldsVerTwoPtrList'mylist raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s HoldsVerTwoPtrList)
-instance (Classes.Cerialize s (V.Vector HoldsVerTwoPtrList)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector HoldsVerTwoPtrList))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector HoldsVerTwoPtrList)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerTwoPtrList))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerTwoPtrList)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerTwoPtrList))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerTwoPtrList)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data HoldsVerTwoTwoList 
-    = HoldsVerTwoTwoList 
-        {mylist :: (V.Vector VerTwoDataTwoPtr)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default HoldsVerTwoTwoList) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const HoldsVerTwoTwoList) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize HoldsVerTwoTwoList) where
-    type Cerial msg HoldsVerTwoTwoList = (Capnp.Gen.ById.X832bcc6686a26d56.HoldsVerTwoTwoList msg)
-    decerialize raw = (HoldsVerTwoTwoList <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_HoldsVerTwoTwoList'mylist raw) >>= Classes.decerialize))
-instance (Classes.Marshal s HoldsVerTwoTwoList) where
-    marshalInto raw_ value_ = case value_ of
-        HoldsVerTwoTwoList{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) mylist) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_HoldsVerTwoTwoList'mylist raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s HoldsVerTwoTwoList)
-instance (Classes.Cerialize s (V.Vector HoldsVerTwoTwoList)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector HoldsVerTwoTwoList))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector HoldsVerTwoTwoList)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerTwoTwoList))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerTwoTwoList)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerTwoTwoList))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerTwoTwoList)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data HoldsVerTwoTwoPlus 
-    = HoldsVerTwoTwoPlus 
-        {mylist :: (V.Vector VerTwoTwoPlus)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default HoldsVerTwoTwoPlus) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const HoldsVerTwoTwoPlus) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize HoldsVerTwoTwoPlus) where
-    type Cerial msg HoldsVerTwoTwoPlus = (Capnp.Gen.ById.X832bcc6686a26d56.HoldsVerTwoTwoPlus msg)
-    decerialize raw = (HoldsVerTwoTwoPlus <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_HoldsVerTwoTwoPlus'mylist raw) >>= Classes.decerialize))
-instance (Classes.Marshal s HoldsVerTwoTwoPlus) where
-    marshalInto raw_ value_ = case value_ of
-        HoldsVerTwoTwoPlus{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) mylist) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_HoldsVerTwoTwoPlus'mylist raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s HoldsVerTwoTwoPlus)
-instance (Classes.Cerialize s (V.Vector HoldsVerTwoTwoPlus)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector HoldsVerTwoTwoPlus))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector HoldsVerTwoTwoPlus)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerTwoTwoPlus))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerTwoTwoPlus)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerTwoTwoPlus))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsVerTwoTwoPlus)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data VerTwoTwoPlus 
-    = VerTwoTwoPlus 
-        {val :: Std_.Int16
-        ,duo :: Std_.Int64
-        ,ptr1 :: VerTwoDataTwoPtr
-        ,ptr2 :: VerTwoDataTwoPtr
-        ,tre :: Std_.Int64
-        ,lst3 :: (V.Vector Std_.Int64)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default VerTwoTwoPlus) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const VerTwoTwoPlus) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize VerTwoTwoPlus) where
-    type Cerial msg VerTwoTwoPlus = (Capnp.Gen.ById.X832bcc6686a26d56.VerTwoTwoPlus msg)
-    decerialize raw = (VerTwoTwoPlus <$> (Capnp.Gen.ById.X832bcc6686a26d56.get_VerTwoTwoPlus'val raw)
-                                     <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_VerTwoTwoPlus'duo raw)
-                                     <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_VerTwoTwoPlus'ptr1 raw) >>= Classes.decerialize)
-                                     <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_VerTwoTwoPlus'ptr2 raw) >>= Classes.decerialize)
-                                     <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_VerTwoTwoPlus'tre raw)
-                                     <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_VerTwoTwoPlus'lst3 raw) >>= Classes.decerialize))
-instance (Classes.Marshal s VerTwoTwoPlus) where
-    marshalInto raw_ value_ = case value_ of
-        VerTwoTwoPlus{..} ->
-            (do
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_VerTwoTwoPlus'val raw_ val)
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_VerTwoTwoPlus'duo raw_ duo)
-                ((Classes.cerialize (Untyped.message raw_) ptr1) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_VerTwoTwoPlus'ptr1 raw_))
-                ((Classes.cerialize (Untyped.message raw_) ptr2) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_VerTwoTwoPlus'ptr2 raw_))
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_VerTwoTwoPlus'tre raw_ tre)
-                ((Classes.cerialize (Untyped.message raw_) lst3) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_VerTwoTwoPlus'lst3 raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s VerTwoTwoPlus)
-instance (Classes.Cerialize s (V.Vector VerTwoTwoPlus)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector VerTwoTwoPlus))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector VerTwoTwoPlus)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector VerTwoTwoPlus))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerTwoTwoPlus)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerTwoTwoPlus))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VerTwoTwoPlus)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data HoldsText 
-    = HoldsText 
-        {txt :: T.Text
-        ,lst :: (V.Vector T.Text)
-        ,lstlst :: (V.Vector (V.Vector T.Text))}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default HoldsText) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const HoldsText) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize HoldsText) where
-    type Cerial msg HoldsText = (Capnp.Gen.ById.X832bcc6686a26d56.HoldsText msg)
-    decerialize raw = (HoldsText <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_HoldsText'txt raw) >>= Classes.decerialize)
-                                 <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_HoldsText'lst raw) >>= Classes.decerialize)
-                                 <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_HoldsText'lstlst raw) >>= Classes.decerialize))
-instance (Classes.Marshal s HoldsText) where
-    marshalInto raw_ value_ = case value_ of
-        HoldsText{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) txt) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_HoldsText'txt raw_))
-                ((Classes.cerialize (Untyped.message raw_) lst) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_HoldsText'lst raw_))
-                ((Classes.cerialize (Untyped.message raw_) lstlst) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_HoldsText'lstlst raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s HoldsText)
-instance (Classes.Cerialize s (V.Vector HoldsText)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector HoldsText))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector HoldsText)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector HoldsText))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsText)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsText))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector HoldsText)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data WrapEmpty 
-    = WrapEmpty 
-        {mightNotBeReallyEmpty :: VerEmpty}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default WrapEmpty) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const WrapEmpty) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize WrapEmpty) where
-    type Cerial msg WrapEmpty = (Capnp.Gen.ById.X832bcc6686a26d56.WrapEmpty msg)
-    decerialize raw = (WrapEmpty <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_WrapEmpty'mightNotBeReallyEmpty raw) >>= Classes.decerialize))
-instance (Classes.Marshal s WrapEmpty) where
-    marshalInto raw_ value_ = case value_ of
-        WrapEmpty{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) mightNotBeReallyEmpty) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_WrapEmpty'mightNotBeReallyEmpty raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s WrapEmpty)
-instance (Classes.Cerialize s (V.Vector WrapEmpty)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector WrapEmpty))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector WrapEmpty)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector WrapEmpty))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector WrapEmpty)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector WrapEmpty))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector WrapEmpty)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Wrap2x2 
-    = Wrap2x2 
-        {mightNotBeReallyEmpty :: VerTwoDataTwoPtr}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Wrap2x2) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Wrap2x2) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Wrap2x2) where
-    type Cerial msg Wrap2x2 = (Capnp.Gen.ById.X832bcc6686a26d56.Wrap2x2 msg)
-    decerialize raw = (Wrap2x2 <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Wrap2x2'mightNotBeReallyEmpty raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Wrap2x2) where
-    marshalInto raw_ value_ = case value_ of
-        Wrap2x2{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) mightNotBeReallyEmpty) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Wrap2x2'mightNotBeReallyEmpty raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Wrap2x2)
-instance (Classes.Cerialize s (V.Vector Wrap2x2)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Wrap2x2))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Wrap2x2)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Wrap2x2))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Wrap2x2)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Wrap2x2))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Wrap2x2)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Wrap2x2plus 
-    = Wrap2x2plus 
-        {mightNotBeReallyEmpty :: VerTwoTwoPlus}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Wrap2x2plus) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Wrap2x2plus) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Wrap2x2plus) where
-    type Cerial msg Wrap2x2plus = (Capnp.Gen.ById.X832bcc6686a26d56.Wrap2x2plus msg)
-    decerialize raw = (Wrap2x2plus <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Wrap2x2plus'mightNotBeReallyEmpty raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Wrap2x2plus) where
-    marshalInto raw_ value_ = case value_ of
-        Wrap2x2plus{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) mightNotBeReallyEmpty) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Wrap2x2plus'mightNotBeReallyEmpty raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Wrap2x2plus)
-instance (Classes.Cerialize s (V.Vector Wrap2x2plus)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Wrap2x2plus))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Wrap2x2plus)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Wrap2x2plus))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Wrap2x2plus)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Wrap2x2plus))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Wrap2x2plus)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data VoidUnion 
-    = VoidUnion'a 
-    | VoidUnion'b 
-    | VoidUnion'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default VoidUnion) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const VoidUnion) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize VoidUnion) where
-    type Cerial msg VoidUnion = (Capnp.Gen.ById.X832bcc6686a26d56.VoidUnion msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.X832bcc6686a26d56.get_VoidUnion' raw)
-        case raw of
-            (Capnp.Gen.ById.X832bcc6686a26d56.VoidUnion'a) ->
-                (Std_.pure VoidUnion'a)
-            (Capnp.Gen.ById.X832bcc6686a26d56.VoidUnion'b) ->
-                (Std_.pure VoidUnion'b)
-            (Capnp.Gen.ById.X832bcc6686a26d56.VoidUnion'unknown' tag) ->
-                (Std_.pure (VoidUnion'unknown' tag))
-        )
-instance (Classes.Marshal s VoidUnion) where
-    marshalInto raw_ value_ = case value_ of
-        (VoidUnion'a) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_VoidUnion'a raw_)
-        (VoidUnion'b) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_VoidUnion'b raw_)
-        (VoidUnion'unknown' tag) ->
-            (Capnp.Gen.ById.X832bcc6686a26d56.set_VoidUnion'unknown' raw_ tag)
-instance (Classes.Cerialize s VoidUnion)
-instance (Classes.Cerialize s (V.Vector VoidUnion)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector VoidUnion))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector VoidUnion)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector VoidUnion))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VoidUnion)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VoidUnion))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector VoidUnion)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Nester1Capn 
-    = Nester1Capn 
-        {strs :: (V.Vector T.Text)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Nester1Capn) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Nester1Capn) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Nester1Capn) where
-    type Cerial msg Nester1Capn = (Capnp.Gen.ById.X832bcc6686a26d56.Nester1Capn msg)
-    decerialize raw = (Nester1Capn <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Nester1Capn'strs raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Nester1Capn) where
-    marshalInto raw_ value_ = case value_ of
-        Nester1Capn{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) strs) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Nester1Capn'strs raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Nester1Capn)
-instance (Classes.Cerialize s (V.Vector Nester1Capn)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Nester1Capn))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Nester1Capn)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Nester1Capn))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Nester1Capn)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Nester1Capn))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Nester1Capn)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data RWTestCapn 
-    = RWTestCapn 
-        {nestMatrix :: (V.Vector (V.Vector Nester1Capn))}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default RWTestCapn) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const RWTestCapn) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize RWTestCapn) where
-    type Cerial msg RWTestCapn = (Capnp.Gen.ById.X832bcc6686a26d56.RWTestCapn msg)
-    decerialize raw = (RWTestCapn <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_RWTestCapn'nestMatrix raw) >>= Classes.decerialize))
-instance (Classes.Marshal s RWTestCapn) where
-    marshalInto raw_ value_ = case value_ of
-        RWTestCapn{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) nestMatrix) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_RWTestCapn'nestMatrix raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s RWTestCapn)
-instance (Classes.Cerialize s (V.Vector RWTestCapn)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector RWTestCapn))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector RWTestCapn)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector RWTestCapn))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector RWTestCapn)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector RWTestCapn))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector RWTestCapn)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data ListStructCapn 
-    = ListStructCapn 
-        {vec :: (V.Vector Nester1Capn)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default ListStructCapn) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const ListStructCapn) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize ListStructCapn) where
-    type Cerial msg ListStructCapn = (Capnp.Gen.ById.X832bcc6686a26d56.ListStructCapn msg)
-    decerialize raw = (ListStructCapn <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_ListStructCapn'vec raw) >>= Classes.decerialize))
-instance (Classes.Marshal s ListStructCapn) where
-    marshalInto raw_ value_ = case value_ of
-        ListStructCapn{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) vec) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_ListStructCapn'vec raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s ListStructCapn)
-instance (Classes.Cerialize s (V.Vector ListStructCapn)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector ListStructCapn))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector ListStructCapn)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector ListStructCapn))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector ListStructCapn)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector ListStructCapn))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector ListStructCapn)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-newtype Echo 
-    = Echo Message.Client
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-class ((MonadIO.MonadIO m)
-      ,(Server.Server m cap)) => (Echo'server_ m cap) where
-    {-# MINIMAL echo'echo #-}
-    echo'echo :: cap -> (Server.MethodHandler m Echo'echo'params Echo'echo'results)
-    echo'echo _ = Server.methodUnimplemented
-export_Echo :: ((STM.MonadSTM m)
-               ,(Echo'server_ Std_.IO cap)) => Supervisors.Supervisor -> cap -> (m Echo)
-export_Echo sup_ server_ = (STM.liftSTM (Echo <$> (Rpc.export sup_ Server.ServerOps{handleCast = (Server.unwrap server_)
-                                                                                   ,handleStop = (Server.shutdown server_)
-                                                                                   ,handleCall = (\interfaceId_ methodId_ -> case interfaceId_ of
-                                                                                       10255578992688506164 ->
-                                                                                           case methodId_ of
-                                                                                               0 ->
-                                                                                                   (Server.toUntypedHandler (echo'echo server_))
-                                                                                               _ ->
-                                                                                                   Server.methodUnimplemented
-                                                                                       _ ->
-                                                                                           Server.methodUnimplemented)})))
-instance (Rpc.IsClient Echo) where
-    fromClient  = Echo
-    toClient (Echo client) = client
-instance (Classes.FromPtr msg Echo) where
-    fromPtr  = RpcHelpers.isClientFromPtr
-instance (Classes.ToPtr s Echo) where
-    toPtr  = RpcHelpers.isClientToPtr
-instance (Classes.Decerialize Echo) where
-    type Cerial msg Echo = (Capnp.Gen.ById.X832bcc6686a26d56.Echo msg)
-    decerialize (Capnp.Gen.ById.X832bcc6686a26d56.Echo'newtype_ maybeCap) = case maybeCap of
-        (Std_.Nothing) ->
-            (Std_.pure (Echo Message.nullClient))
-        (Std_.Just cap) ->
-            (Echo <$> (Untyped.getClient cap))
-instance (Classes.Cerialize s Echo) where
-    cerialize msg (Echo client) = (Capnp.Gen.ById.X832bcc6686a26d56.Echo'newtype_ <$> (Std_.Just <$> (Untyped.appendCap msg client)))
-instance (Server.Server Std_.IO Echo)
-instance (Echo'server_ Std_.IO Echo) where
-    echo'echo (Echo client) = (Rpc.clientMethodHandler 10255578992688506164 0 client)
-data Echo'echo'params 
-    = Echo'echo'params 
-        {in_ :: T.Text}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Echo'echo'params) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Echo'echo'params) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Echo'echo'params) where
-    type Cerial msg Echo'echo'params = (Capnp.Gen.ById.X832bcc6686a26d56.Echo'echo'params msg)
-    decerialize raw = (Echo'echo'params <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Echo'echo'params'in_ raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Echo'echo'params) where
-    marshalInto raw_ value_ = case value_ of
-        Echo'echo'params{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) in_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Echo'echo'params'in_ raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Echo'echo'params)
-instance (Classes.Cerialize s (V.Vector Echo'echo'params)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Echo'echo'params))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Echo'echo'params)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Echo'echo'params))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Echo'echo'params)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Echo'echo'params))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Echo'echo'params)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Echo'echo'results 
-    = Echo'echo'results 
-        {out :: T.Text}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Echo'echo'results) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Echo'echo'results) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Echo'echo'results) where
-    type Cerial msg Echo'echo'results = (Capnp.Gen.ById.X832bcc6686a26d56.Echo'echo'results msg)
-    decerialize raw = (Echo'echo'results <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Echo'echo'results'out raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Echo'echo'results) where
-    marshalInto raw_ value_ = case value_ of
-        Echo'echo'results{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) out) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Echo'echo'results'out raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Echo'echo'results)
-instance (Classes.Cerialize s (V.Vector Echo'echo'results)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Echo'echo'results))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Echo'echo'results)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Echo'echo'results))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Echo'echo'results)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Echo'echo'results))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Echo'echo'results)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Hoth 
-    = Hoth 
-        {base :: EchoBase}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Hoth) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Hoth) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Hoth) where
-    type Cerial msg Hoth = (Capnp.Gen.ById.X832bcc6686a26d56.Hoth msg)
-    decerialize raw = (Hoth <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Hoth'base raw) >>= Classes.decerialize))
-instance (Classes.Marshal s Hoth) where
-    marshalInto raw_ value_ = case value_ of
-        Hoth{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) base) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Hoth'base raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Hoth)
-instance (Classes.Cerialize s (V.Vector Hoth)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Hoth))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Hoth)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Hoth))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Hoth)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Hoth))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Hoth)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data EchoBase 
-    = EchoBase 
-        {echo :: Echo}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default EchoBase) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const EchoBase) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize EchoBase) where
-    type Cerial msg EchoBase = (Capnp.Gen.ById.X832bcc6686a26d56.EchoBase msg)
-    decerialize raw = (EchoBase <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_EchoBase'echo raw) >>= Classes.decerialize))
-instance (Classes.Marshal s EchoBase) where
-    marshalInto raw_ value_ = case value_ of
-        EchoBase{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) echo) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_EchoBase'echo raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s EchoBase)
-instance (Classes.Cerialize s (V.Vector EchoBase)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector EchoBase))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector EchoBase)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector EchoBase))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector EchoBase)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector EchoBase))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector EchoBase)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data EchoBases 
-    = EchoBases 
-        {bases :: (V.Vector EchoBase)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default EchoBases) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const EchoBases) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize EchoBases) where
-    type Cerial msg EchoBases = (Capnp.Gen.ById.X832bcc6686a26d56.EchoBases msg)
-    decerialize raw = (EchoBases <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_EchoBases'bases raw) >>= Classes.decerialize))
-instance (Classes.Marshal s EchoBases) where
-    marshalInto raw_ value_ = case value_ of
-        EchoBases{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) bases) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_EchoBases'bases raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s EchoBases)
-instance (Classes.Cerialize s (V.Vector EchoBases)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector EchoBases))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector EchoBases)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector EchoBases))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector EchoBases)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector EchoBases))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector EchoBases)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data StackingRoot 
-    = StackingRoot 
-        {aWithDefault :: StackingA
-        ,a :: StackingA}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default StackingRoot) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const StackingRoot) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize StackingRoot) where
-    type Cerial msg StackingRoot = (Capnp.Gen.ById.X832bcc6686a26d56.StackingRoot msg)
-    decerialize raw = (StackingRoot <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_StackingRoot'aWithDefault raw) >>= Classes.decerialize)
-                                    <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_StackingRoot'a raw) >>= Classes.decerialize))
-instance (Classes.Marshal s StackingRoot) where
-    marshalInto raw_ value_ = case value_ of
-        StackingRoot{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) aWithDefault) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_StackingRoot'aWithDefault raw_))
-                ((Classes.cerialize (Untyped.message raw_) a) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_StackingRoot'a raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s StackingRoot)
-instance (Classes.Cerialize s (V.Vector StackingRoot)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector StackingRoot))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector StackingRoot)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector StackingRoot))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector StackingRoot)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector StackingRoot))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector StackingRoot)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data StackingA 
-    = StackingA 
-        {num :: Std_.Int32
-        ,b :: StackingB}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default StackingA) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const StackingA) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize StackingA) where
-    type Cerial msg StackingA = (Capnp.Gen.ById.X832bcc6686a26d56.StackingA msg)
-    decerialize raw = (StackingA <$> (Capnp.Gen.ById.X832bcc6686a26d56.get_StackingA'num raw)
-                                 <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_StackingA'b raw) >>= Classes.decerialize))
-instance (Classes.Marshal s StackingA) where
-    marshalInto raw_ value_ = case value_ of
-        StackingA{..} ->
-            (do
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_StackingA'num raw_ num)
-                ((Classes.cerialize (Untyped.message raw_) b) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_StackingA'b raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s StackingA)
-instance (Classes.Cerialize s (V.Vector StackingA)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector StackingA))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector StackingA)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector StackingA))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector StackingA)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector StackingA))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector StackingA)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data StackingB 
-    = StackingB 
-        {num :: Std_.Int32}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default StackingB) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const StackingB) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize StackingB) where
-    type Cerial msg StackingB = (Capnp.Gen.ById.X832bcc6686a26d56.StackingB msg)
-    decerialize raw = (StackingB <$> (Capnp.Gen.ById.X832bcc6686a26d56.get_StackingB'num raw))
-instance (Classes.Marshal s StackingB) where
-    marshalInto raw_ value_ = case value_ of
-        StackingB{..} ->
-            (do
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_StackingB'num raw_ num)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s StackingB)
-instance (Classes.Cerialize s (V.Vector StackingB)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector StackingB))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector StackingB)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector StackingB))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector StackingB)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector StackingB))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector StackingB)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-newtype CallSequence 
-    = CallSequence Message.Client
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-class ((MonadIO.MonadIO m)
-      ,(Server.Server m cap)) => (CallSequence'server_ m cap) where
-    {-# MINIMAL callSequence'getNumber #-}
-    callSequence'getNumber :: cap -> (Server.MethodHandler m CallSequence'getNumber'params CallSequence'getNumber'results)
-    callSequence'getNumber _ = Server.methodUnimplemented
-export_CallSequence :: ((STM.MonadSTM m)
-                       ,(CallSequence'server_ Std_.IO cap)) => Supervisors.Supervisor -> cap -> (m CallSequence)
-export_CallSequence sup_ server_ = (STM.liftSTM (CallSequence <$> (Rpc.export sup_ Server.ServerOps{handleCast = (Server.unwrap server_)
-                                                                                                   ,handleStop = (Server.shutdown server_)
-                                                                                                   ,handleCall = (\interfaceId_ methodId_ -> case interfaceId_ of
-                                                                                                       12371070827563042848 ->
-                                                                                                           case methodId_ of
-                                                                                                               0 ->
-                                                                                                                   (Server.toUntypedHandler (callSequence'getNumber server_))
-                                                                                                               _ ->
-                                                                                                                   Server.methodUnimplemented
-                                                                                                       _ ->
-                                                                                                           Server.methodUnimplemented)})))
-instance (Rpc.IsClient CallSequence) where
-    fromClient  = CallSequence
-    toClient (CallSequence client) = client
-instance (Classes.FromPtr msg CallSequence) where
-    fromPtr  = RpcHelpers.isClientFromPtr
-instance (Classes.ToPtr s CallSequence) where
-    toPtr  = RpcHelpers.isClientToPtr
-instance (Classes.Decerialize CallSequence) where
-    type Cerial msg CallSequence = (Capnp.Gen.ById.X832bcc6686a26d56.CallSequence msg)
-    decerialize (Capnp.Gen.ById.X832bcc6686a26d56.CallSequence'newtype_ maybeCap) = case maybeCap of
-        (Std_.Nothing) ->
-            (Std_.pure (CallSequence Message.nullClient))
-        (Std_.Just cap) ->
-            (CallSequence <$> (Untyped.getClient cap))
-instance (Classes.Cerialize s CallSequence) where
-    cerialize msg (CallSequence client) = (Capnp.Gen.ById.X832bcc6686a26d56.CallSequence'newtype_ <$> (Std_.Just <$> (Untyped.appendCap msg client)))
-instance (Server.Server Std_.IO CallSequence)
-instance (CallSequence'server_ Std_.IO CallSequence) where
-    callSequence'getNumber (CallSequence client) = (Rpc.clientMethodHandler 12371070827563042848 0 client)
-data CallSequence'getNumber'params 
-    = CallSequence'getNumber'params 
-        {}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default CallSequence'getNumber'params) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const CallSequence'getNumber'params) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize CallSequence'getNumber'params) where
-    type Cerial msg CallSequence'getNumber'params = (Capnp.Gen.ById.X832bcc6686a26d56.CallSequence'getNumber'params msg)
-    decerialize raw = (Std_.pure CallSequence'getNumber'params)
-instance (Classes.Marshal s CallSequence'getNumber'params) where
-    marshalInto raw_ value_ = case value_ of
-        (CallSequence'getNumber'params) ->
-            (do
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s CallSequence'getNumber'params)
-instance (Classes.Cerialize s (V.Vector CallSequence'getNumber'params)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector CallSequence'getNumber'params))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector CallSequence'getNumber'params)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector CallSequence'getNumber'params))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CallSequence'getNumber'params)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CallSequence'getNumber'params))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CallSequence'getNumber'params)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data CallSequence'getNumber'results 
-    = CallSequence'getNumber'results 
-        {n :: Std_.Word32}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default CallSequence'getNumber'results) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const CallSequence'getNumber'results) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize CallSequence'getNumber'results) where
-    type Cerial msg CallSequence'getNumber'results = (Capnp.Gen.ById.X832bcc6686a26d56.CallSequence'getNumber'results msg)
-    decerialize raw = (CallSequence'getNumber'results <$> (Capnp.Gen.ById.X832bcc6686a26d56.get_CallSequence'getNumber'results'n raw))
-instance (Classes.Marshal s CallSequence'getNumber'results) where
-    marshalInto raw_ value_ = case value_ of
-        CallSequence'getNumber'results{..} ->
-            (do
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_CallSequence'getNumber'results'n raw_ n)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s CallSequence'getNumber'results)
-instance (Classes.Cerialize s (V.Vector CallSequence'getNumber'results)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector CallSequence'getNumber'results))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector CallSequence'getNumber'results)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector CallSequence'getNumber'results))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CallSequence'getNumber'results)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CallSequence'getNumber'results))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CallSequence'getNumber'results)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-newtype CounterFactory 
-    = CounterFactory Message.Client
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-class ((MonadIO.MonadIO m)
-      ,(Server.Server m cap)) => (CounterFactory'server_ m cap) where
-    {-# MINIMAL counterFactory'newCounter #-}
-    counterFactory'newCounter :: cap -> (Server.MethodHandler m CounterFactory'newCounter'params CounterFactory'newCounter'results)
-    counterFactory'newCounter _ = Server.methodUnimplemented
-export_CounterFactory :: ((STM.MonadSTM m)
-                         ,(CounterFactory'server_ Std_.IO cap)) => Supervisors.Supervisor -> cap -> (m CounterFactory)
-export_CounterFactory sup_ server_ = (STM.liftSTM (CounterFactory <$> (Rpc.export sup_ Server.ServerOps{handleCast = (Server.unwrap server_)
-                                                                                                       ,handleStop = (Server.shutdown server_)
-                                                                                                       ,handleCall = (\interfaceId_ methodId_ -> case interfaceId_ of
-                                                                                                           15610220054254702620 ->
-                                                                                                               case methodId_ of
-                                                                                                                   0 ->
-                                                                                                                       (Server.toUntypedHandler (counterFactory'newCounter server_))
-                                                                                                                   _ ->
-                                                                                                                       Server.methodUnimplemented
-                                                                                                           _ ->
-                                                                                                               Server.methodUnimplemented)})))
-instance (Rpc.IsClient CounterFactory) where
-    fromClient  = CounterFactory
-    toClient (CounterFactory client) = client
-instance (Classes.FromPtr msg CounterFactory) where
-    fromPtr  = RpcHelpers.isClientFromPtr
-instance (Classes.ToPtr s CounterFactory) where
-    toPtr  = RpcHelpers.isClientToPtr
-instance (Classes.Decerialize CounterFactory) where
-    type Cerial msg CounterFactory = (Capnp.Gen.ById.X832bcc6686a26d56.CounterFactory msg)
-    decerialize (Capnp.Gen.ById.X832bcc6686a26d56.CounterFactory'newtype_ maybeCap) = case maybeCap of
-        (Std_.Nothing) ->
-            (Std_.pure (CounterFactory Message.nullClient))
-        (Std_.Just cap) ->
-            (CounterFactory <$> (Untyped.getClient cap))
-instance (Classes.Cerialize s CounterFactory) where
-    cerialize msg (CounterFactory client) = (Capnp.Gen.ById.X832bcc6686a26d56.CounterFactory'newtype_ <$> (Std_.Just <$> (Untyped.appendCap msg client)))
-instance (Server.Server Std_.IO CounterFactory)
-instance (CounterFactory'server_ Std_.IO CounterFactory) where
-    counterFactory'newCounter (CounterFactory client) = (Rpc.clientMethodHandler 15610220054254702620 0 client)
-data CounterFactory'newCounter'params 
-    = CounterFactory'newCounter'params 
-        {start :: Std_.Word32}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default CounterFactory'newCounter'params) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const CounterFactory'newCounter'params) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize CounterFactory'newCounter'params) where
-    type Cerial msg CounterFactory'newCounter'params = (Capnp.Gen.ById.X832bcc6686a26d56.CounterFactory'newCounter'params msg)
-    decerialize raw = (CounterFactory'newCounter'params <$> (Capnp.Gen.ById.X832bcc6686a26d56.get_CounterFactory'newCounter'params'start raw))
-instance (Classes.Marshal s CounterFactory'newCounter'params) where
-    marshalInto raw_ value_ = case value_ of
-        CounterFactory'newCounter'params{..} ->
-            (do
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_CounterFactory'newCounter'params'start raw_ start)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s CounterFactory'newCounter'params)
-instance (Classes.Cerialize s (V.Vector CounterFactory'newCounter'params)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector CounterFactory'newCounter'params))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector CounterFactory'newCounter'params)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector CounterFactory'newCounter'params))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CounterFactory'newCounter'params)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CounterFactory'newCounter'params))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CounterFactory'newCounter'params)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data CounterFactory'newCounter'results 
-    = CounterFactory'newCounter'results 
-        {counter :: CallSequence}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default CounterFactory'newCounter'results) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const CounterFactory'newCounter'results) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize CounterFactory'newCounter'results) where
-    type Cerial msg CounterFactory'newCounter'results = (Capnp.Gen.ById.X832bcc6686a26d56.CounterFactory'newCounter'results msg)
-    decerialize raw = (CounterFactory'newCounter'results <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_CounterFactory'newCounter'results'counter raw) >>= Classes.decerialize))
-instance (Classes.Marshal s CounterFactory'newCounter'results) where
-    marshalInto raw_ value_ = case value_ of
-        CounterFactory'newCounter'results{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) counter) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_CounterFactory'newCounter'results'counter raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s CounterFactory'newCounter'results)
-instance (Classes.Cerialize s (V.Vector CounterFactory'newCounter'results)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector CounterFactory'newCounter'results))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector CounterFactory'newCounter'results)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector CounterFactory'newCounter'results))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CounterFactory'newCounter'results)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CounterFactory'newCounter'results))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CounterFactory'newCounter'results)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-newtype CounterAcceptor 
-    = CounterAcceptor Message.Client
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-class ((MonadIO.MonadIO m)
-      ,(Server.Server m cap)) => (CounterAcceptor'server_ m cap) where
-    {-# MINIMAL counterAcceptor'accept #-}
-    counterAcceptor'accept :: cap -> (Server.MethodHandler m CounterAcceptor'accept'params CounterAcceptor'accept'results)
-    counterAcceptor'accept _ = Server.methodUnimplemented
-export_CounterAcceptor :: ((STM.MonadSTM m)
-                          ,(CounterAcceptor'server_ Std_.IO cap)) => Supervisors.Supervisor -> cap -> (m CounterAcceptor)
-export_CounterAcceptor sup_ server_ = (STM.liftSTM (CounterAcceptor <$> (Rpc.export sup_ Server.ServerOps{handleCast = (Server.unwrap server_)
-                                                                                                         ,handleStop = (Server.shutdown server_)
-                                                                                                         ,handleCall = (\interfaceId_ methodId_ -> case interfaceId_ of
-                                                                                                             14317498215560924065 ->
-                                                                                                                 case methodId_ of
-                                                                                                                     0 ->
-                                                                                                                         (Server.toUntypedHandler (counterAcceptor'accept server_))
-                                                                                                                     _ ->
-                                                                                                                         Server.methodUnimplemented
-                                                                                                             _ ->
-                                                                                                                 Server.methodUnimplemented)})))
-instance (Rpc.IsClient CounterAcceptor) where
-    fromClient  = CounterAcceptor
-    toClient (CounterAcceptor client) = client
-instance (Classes.FromPtr msg CounterAcceptor) where
-    fromPtr  = RpcHelpers.isClientFromPtr
-instance (Classes.ToPtr s CounterAcceptor) where
-    toPtr  = RpcHelpers.isClientToPtr
-instance (Classes.Decerialize CounterAcceptor) where
-    type Cerial msg CounterAcceptor = (Capnp.Gen.ById.X832bcc6686a26d56.CounterAcceptor msg)
-    decerialize (Capnp.Gen.ById.X832bcc6686a26d56.CounterAcceptor'newtype_ maybeCap) = case maybeCap of
-        (Std_.Nothing) ->
-            (Std_.pure (CounterAcceptor Message.nullClient))
-        (Std_.Just cap) ->
-            (CounterAcceptor <$> (Untyped.getClient cap))
-instance (Classes.Cerialize s CounterAcceptor) where
-    cerialize msg (CounterAcceptor client) = (Capnp.Gen.ById.X832bcc6686a26d56.CounterAcceptor'newtype_ <$> (Std_.Just <$> (Untyped.appendCap msg client)))
-instance (Server.Server Std_.IO CounterAcceptor)
-instance (CounterAcceptor'server_ Std_.IO CounterAcceptor) where
-    counterAcceptor'accept (CounterAcceptor client) = (Rpc.clientMethodHandler 14317498215560924065 0 client)
-data CounterAcceptor'accept'params 
-    = CounterAcceptor'accept'params 
-        {counter :: CallSequence}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default CounterAcceptor'accept'params) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const CounterAcceptor'accept'params) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize CounterAcceptor'accept'params) where
-    type Cerial msg CounterAcceptor'accept'params = (Capnp.Gen.ById.X832bcc6686a26d56.CounterAcceptor'accept'params msg)
-    decerialize raw = (CounterAcceptor'accept'params <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_CounterAcceptor'accept'params'counter raw) >>= Classes.decerialize))
-instance (Classes.Marshal s CounterAcceptor'accept'params) where
-    marshalInto raw_ value_ = case value_ of
-        CounterAcceptor'accept'params{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) counter) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_CounterAcceptor'accept'params'counter raw_))
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s CounterAcceptor'accept'params)
-instance (Classes.Cerialize s (V.Vector CounterAcceptor'accept'params)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector CounterAcceptor'accept'params))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector CounterAcceptor'accept'params)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector CounterAcceptor'accept'params))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CounterAcceptor'accept'params)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CounterAcceptor'accept'params))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CounterAcceptor'accept'params)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data CounterAcceptor'accept'results 
-    = CounterAcceptor'accept'results 
-        {}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default CounterAcceptor'accept'results) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const CounterAcceptor'accept'results) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize CounterAcceptor'accept'results) where
-    type Cerial msg CounterAcceptor'accept'results = (Capnp.Gen.ById.X832bcc6686a26d56.CounterAcceptor'accept'results msg)
-    decerialize raw = (Std_.pure CounterAcceptor'accept'results)
-instance (Classes.Marshal s CounterAcceptor'accept'results) where
-    marshalInto raw_ value_ = case value_ of
-        (CounterAcceptor'accept'results) ->
-            (do
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s CounterAcceptor'accept'results)
-instance (Classes.Cerialize s (V.Vector CounterAcceptor'accept'results)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector CounterAcceptor'accept'results))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector CounterAcceptor'accept'results)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector CounterAcceptor'accept'results))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CounterAcceptor'accept'results)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CounterAcceptor'accept'results))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector CounterAcceptor'accept'results)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-newtype Top 
-    = Top Message.Client
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-class ((MonadIO.MonadIO m)
-      ,(Server.Server m cap)) => (Top'server_ m cap) where
-    {-# MINIMAL top'top #-}
-    top'top :: cap -> (Server.MethodHandler m Top'top'params Top'top'results)
-    top'top _ = Server.methodUnimplemented
-export_Top :: ((STM.MonadSTM m)
-              ,(Top'server_ Std_.IO cap)) => Supervisors.Supervisor -> cap -> (m Top)
-export_Top sup_ server_ = (STM.liftSTM (Top <$> (Rpc.export sup_ Server.ServerOps{handleCast = (Server.unwrap server_)
-                                                                                 ,handleStop = (Server.shutdown server_)
-                                                                                 ,handleCall = (\interfaceId_ methodId_ -> case interfaceId_ of
-                                                                                     17861645508359101525 ->
-                                                                                         case methodId_ of
-                                                                                             0 ->
-                                                                                                 (Server.toUntypedHandler (top'top server_))
-                                                                                             _ ->
-                                                                                                 Server.methodUnimplemented
-                                                                                     _ ->
-                                                                                         Server.methodUnimplemented)})))
-instance (Rpc.IsClient Top) where
-    fromClient  = Top
-    toClient (Top client) = client
-instance (Classes.FromPtr msg Top) where
-    fromPtr  = RpcHelpers.isClientFromPtr
-instance (Classes.ToPtr s Top) where
-    toPtr  = RpcHelpers.isClientToPtr
-instance (Classes.Decerialize Top) where
-    type Cerial msg Top = (Capnp.Gen.ById.X832bcc6686a26d56.Top msg)
-    decerialize (Capnp.Gen.ById.X832bcc6686a26d56.Top'newtype_ maybeCap) = case maybeCap of
-        (Std_.Nothing) ->
-            (Std_.pure (Top Message.nullClient))
-        (Std_.Just cap) ->
-            (Top <$> (Untyped.getClient cap))
-instance (Classes.Cerialize s Top) where
-    cerialize msg (Top client) = (Capnp.Gen.ById.X832bcc6686a26d56.Top'newtype_ <$> (Std_.Just <$> (Untyped.appendCap msg client)))
-instance (Server.Server Std_.IO Top)
-instance (Top'server_ Std_.IO Top) where
-    top'top (Top client) = (Rpc.clientMethodHandler 17861645508359101525 0 client)
-data Top'top'params 
-    = Top'top'params 
-        {}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Top'top'params) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Top'top'params) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Top'top'params) where
-    type Cerial msg Top'top'params = (Capnp.Gen.ById.X832bcc6686a26d56.Top'top'params msg)
-    decerialize raw = (Std_.pure Top'top'params)
-instance (Classes.Marshal s Top'top'params) where
-    marshalInto raw_ value_ = case value_ of
-        (Top'top'params) ->
-            (do
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Top'top'params)
-instance (Classes.Cerialize s (V.Vector Top'top'params)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Top'top'params))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Top'top'params)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Top'top'params))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Top'top'params)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Top'top'params))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Top'top'params)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Top'top'results 
-    = Top'top'results 
-        {}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Top'top'results) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Top'top'results) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Top'top'results) where
-    type Cerial msg Top'top'results = (Capnp.Gen.ById.X832bcc6686a26d56.Top'top'results msg)
-    decerialize raw = (Std_.pure Top'top'results)
-instance (Classes.Marshal s Top'top'results) where
-    marshalInto raw_ value_ = case value_ of
-        (Top'top'results) ->
-            (do
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Top'top'results)
-instance (Classes.Cerialize s (V.Vector Top'top'results)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Top'top'results))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Top'top'results)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Top'top'results))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Top'top'results)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Top'top'results))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Top'top'results)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-newtype Left 
-    = Left Message.Client
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-class ((MonadIO.MonadIO m)
-      ,(Top'server_ m cap)) => (Left'server_ m cap) where
-    {-# MINIMAL left'left #-}
-    left'left :: cap -> (Server.MethodHandler m Left'left'params Left'left'results)
-    left'left _ = Server.methodUnimplemented
-export_Left :: ((STM.MonadSTM m)
-               ,(Left'server_ Std_.IO cap)) => Supervisors.Supervisor -> cap -> (m Left)
-export_Left sup_ server_ = (STM.liftSTM (Left <$> (Rpc.export sup_ Server.ServerOps{handleCast = (Server.unwrap server_)
-                                                                                   ,handleStop = (Server.shutdown server_)
-                                                                                   ,handleCall = (\interfaceId_ methodId_ -> case interfaceId_ of
-                                                                                       17679152961798450446 ->
-                                                                                           case methodId_ of
-                                                                                               0 ->
-                                                                                                   (Server.toUntypedHandler (left'left server_))
-                                                                                               _ ->
-                                                                                                   Server.methodUnimplemented
-                                                                                       17861645508359101525 ->
-                                                                                           case methodId_ of
-                                                                                               0 ->
-                                                                                                   (Server.toUntypedHandler (top'top server_))
-                                                                                               _ ->
-                                                                                                   Server.methodUnimplemented
-                                                                                       _ ->
-                                                                                           Server.methodUnimplemented)})))
-instance (Rpc.IsClient Left) where
-    fromClient  = Left
-    toClient (Left client) = client
-instance (Classes.FromPtr msg Left) where
-    fromPtr  = RpcHelpers.isClientFromPtr
-instance (Classes.ToPtr s Left) where
-    toPtr  = RpcHelpers.isClientToPtr
-instance (Classes.Decerialize Left) where
-    type Cerial msg Left = (Capnp.Gen.ById.X832bcc6686a26d56.Left msg)
-    decerialize (Capnp.Gen.ById.X832bcc6686a26d56.Left'newtype_ maybeCap) = case maybeCap of
-        (Std_.Nothing) ->
-            (Std_.pure (Left Message.nullClient))
-        (Std_.Just cap) ->
-            (Left <$> (Untyped.getClient cap))
-instance (Classes.Cerialize s Left) where
-    cerialize msg (Left client) = (Capnp.Gen.ById.X832bcc6686a26d56.Left'newtype_ <$> (Std_.Just <$> (Untyped.appendCap msg client)))
-instance (Server.Server Std_.IO Left)
-instance (Left'server_ Std_.IO Left) where
-    left'left (Left client) = (Rpc.clientMethodHandler 17679152961798450446 0 client)
-instance (Top'server_ Std_.IO Left) where
-    top'top (Left client) = (Rpc.clientMethodHandler 17861645508359101525 0 client)
-data Left'left'params 
-    = Left'left'params 
-        {}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Left'left'params) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Left'left'params) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Left'left'params) where
-    type Cerial msg Left'left'params = (Capnp.Gen.ById.X832bcc6686a26d56.Left'left'params msg)
-    decerialize raw = (Std_.pure Left'left'params)
-instance (Classes.Marshal s Left'left'params) where
-    marshalInto raw_ value_ = case value_ of
-        (Left'left'params) ->
-            (do
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Left'left'params)
-instance (Classes.Cerialize s (V.Vector Left'left'params)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Left'left'params))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Left'left'params)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Left'left'params))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Left'left'params)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Left'left'params))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Left'left'params)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Left'left'results 
-    = Left'left'results 
-        {}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Left'left'results) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Left'left'results) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Left'left'results) where
-    type Cerial msg Left'left'results = (Capnp.Gen.ById.X832bcc6686a26d56.Left'left'results msg)
-    decerialize raw = (Std_.pure Left'left'results)
-instance (Classes.Marshal s Left'left'results) where
-    marshalInto raw_ value_ = case value_ of
-        (Left'left'results) ->
-            (do
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Left'left'results)
-instance (Classes.Cerialize s (V.Vector Left'left'results)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Left'left'results))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Left'left'results)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Left'left'results))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Left'left'results)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Left'left'results))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Left'left'results)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-newtype Right 
-    = Right Message.Client
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-class ((MonadIO.MonadIO m)
-      ,(Top'server_ m cap)) => (Right'server_ m cap) where
-    {-# MINIMAL right'right #-}
-    right'right :: cap -> (Server.MethodHandler m Right'right'params Right'right'results)
-    right'right _ = Server.methodUnimplemented
-export_Right :: ((STM.MonadSTM m)
-                ,(Right'server_ Std_.IO cap)) => Supervisors.Supervisor -> cap -> (m Right)
-export_Right sup_ server_ = (STM.liftSTM (Right <$> (Rpc.export sup_ Server.ServerOps{handleCast = (Server.unwrap server_)
-                                                                                     ,handleStop = (Server.shutdown server_)
-                                                                                     ,handleCall = (\interfaceId_ methodId_ -> case interfaceId_ of
-                                                                                         14712639595305348988 ->
-                                                                                             case methodId_ of
-                                                                                                 0 ->
-                                                                                                     (Server.toUntypedHandler (right'right server_))
-                                                                                                 _ ->
-                                                                                                     Server.methodUnimplemented
-                                                                                         17861645508359101525 ->
-                                                                                             case methodId_ of
-                                                                                                 0 ->
-                                                                                                     (Server.toUntypedHandler (top'top server_))
-                                                                                                 _ ->
-                                                                                                     Server.methodUnimplemented
-                                                                                         _ ->
-                                                                                             Server.methodUnimplemented)})))
-instance (Rpc.IsClient Right) where
-    fromClient  = Right
-    toClient (Right client) = client
-instance (Classes.FromPtr msg Right) where
-    fromPtr  = RpcHelpers.isClientFromPtr
-instance (Classes.ToPtr s Right) where
-    toPtr  = RpcHelpers.isClientToPtr
-instance (Classes.Decerialize Right) where
-    type Cerial msg Right = (Capnp.Gen.ById.X832bcc6686a26d56.Right msg)
-    decerialize (Capnp.Gen.ById.X832bcc6686a26d56.Right'newtype_ maybeCap) = case maybeCap of
-        (Std_.Nothing) ->
-            (Std_.pure (Right Message.nullClient))
-        (Std_.Just cap) ->
-            (Right <$> (Untyped.getClient cap))
-instance (Classes.Cerialize s Right) where
-    cerialize msg (Right client) = (Capnp.Gen.ById.X832bcc6686a26d56.Right'newtype_ <$> (Std_.Just <$> (Untyped.appendCap msg client)))
-instance (Server.Server Std_.IO Right)
-instance (Right'server_ Std_.IO Right) where
-    right'right (Right client) = (Rpc.clientMethodHandler 14712639595305348988 0 client)
-instance (Top'server_ Std_.IO Right) where
-    top'top (Right client) = (Rpc.clientMethodHandler 17861645508359101525 0 client)
-data Right'right'params 
-    = Right'right'params 
-        {}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Right'right'params) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Right'right'params) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Right'right'params) where
-    type Cerial msg Right'right'params = (Capnp.Gen.ById.X832bcc6686a26d56.Right'right'params msg)
-    decerialize raw = (Std_.pure Right'right'params)
-instance (Classes.Marshal s Right'right'params) where
-    marshalInto raw_ value_ = case value_ of
-        (Right'right'params) ->
-            (do
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Right'right'params)
-instance (Classes.Cerialize s (V.Vector Right'right'params)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Right'right'params))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Right'right'params)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Right'right'params))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Right'right'params)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Right'right'params))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Right'right'params)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Right'right'results 
-    = Right'right'results 
-        {}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Right'right'results) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Right'right'results) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Right'right'results) where
-    type Cerial msg Right'right'results = (Capnp.Gen.ById.X832bcc6686a26d56.Right'right'results msg)
-    decerialize raw = (Std_.pure Right'right'results)
-instance (Classes.Marshal s Right'right'results) where
-    marshalInto raw_ value_ = case value_ of
-        (Right'right'results) ->
-            (do
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Right'right'results)
-instance (Classes.Cerialize s (V.Vector Right'right'results)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Right'right'results))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Right'right'results)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Right'right'results))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Right'right'results)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Right'right'results))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Right'right'results)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-newtype Bottom 
-    = Bottom Message.Client
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-class ((MonadIO.MonadIO m)
-      ,(Left'server_ m cap)
-      ,(Right'server_ m cap)) => (Bottom'server_ m cap) where
-    {-# MINIMAL bottom'bottom #-}
-    bottom'bottom :: cap -> (Server.MethodHandler m Bottom'bottom'params Bottom'bottom'results)
-    bottom'bottom _ = Server.methodUnimplemented
-export_Bottom :: ((STM.MonadSTM m)
-                 ,(Bottom'server_ Std_.IO cap)) => Supervisors.Supervisor -> cap -> (m Bottom)
-export_Bottom sup_ server_ = (STM.liftSTM (Bottom <$> (Rpc.export sup_ Server.ServerOps{handleCast = (Server.unwrap server_)
-                                                                                       ,handleStop = (Server.shutdown server_)
-                                                                                       ,handleCall = (\interfaceId_ methodId_ -> case interfaceId_ of
-                                                                                           18402872613340521775 ->
-                                                                                               case methodId_ of
-                                                                                                   0 ->
-                                                                                                       (Server.toUntypedHandler (bottom'bottom server_))
-                                                                                                   _ ->
-                                                                                                       Server.methodUnimplemented
-                                                                                           17679152961798450446 ->
-                                                                                               case methodId_ of
-                                                                                                   0 ->
-                                                                                                       (Server.toUntypedHandler (left'left server_))
-                                                                                                   _ ->
-                                                                                                       Server.methodUnimplemented
-                                                                                           17861645508359101525 ->
-                                                                                               case methodId_ of
-                                                                                                   0 ->
-                                                                                                       (Server.toUntypedHandler (top'top server_))
-                                                                                                   _ ->
-                                                                                                       Server.methodUnimplemented
-                                                                                           14712639595305348988 ->
-                                                                                               case methodId_ of
-                                                                                                   0 ->
-                                                                                                       (Server.toUntypedHandler (right'right server_))
-                                                                                                   _ ->
-                                                                                                       Server.methodUnimplemented
-                                                                                           _ ->
-                                                                                               Server.methodUnimplemented)})))
-instance (Rpc.IsClient Bottom) where
-    fromClient  = Bottom
-    toClient (Bottom client) = client
-instance (Classes.FromPtr msg Bottom) where
-    fromPtr  = RpcHelpers.isClientFromPtr
-instance (Classes.ToPtr s Bottom) where
-    toPtr  = RpcHelpers.isClientToPtr
-instance (Classes.Decerialize Bottom) where
-    type Cerial msg Bottom = (Capnp.Gen.ById.X832bcc6686a26d56.Bottom msg)
-    decerialize (Capnp.Gen.ById.X832bcc6686a26d56.Bottom'newtype_ maybeCap) = case maybeCap of
-        (Std_.Nothing) ->
-            (Std_.pure (Bottom Message.nullClient))
-        (Std_.Just cap) ->
-            (Bottom <$> (Untyped.getClient cap))
-instance (Classes.Cerialize s Bottom) where
-    cerialize msg (Bottom client) = (Capnp.Gen.ById.X832bcc6686a26d56.Bottom'newtype_ <$> (Std_.Just <$> (Untyped.appendCap msg client)))
-instance (Server.Server Std_.IO Bottom)
-instance (Bottom'server_ Std_.IO Bottom) where
-    bottom'bottom (Bottom client) = (Rpc.clientMethodHandler 18402872613340521775 0 client)
-instance (Left'server_ Std_.IO Bottom) where
-    left'left (Bottom client) = (Rpc.clientMethodHandler 17679152961798450446 0 client)
-instance (Top'server_ Std_.IO Bottom) where
-    top'top (Bottom client) = (Rpc.clientMethodHandler 17861645508359101525 0 client)
-instance (Right'server_ Std_.IO Bottom) where
-    right'right (Bottom client) = (Rpc.clientMethodHandler 14712639595305348988 0 client)
-data Bottom'bottom'params 
-    = Bottom'bottom'params 
-        {}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Bottom'bottom'params) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Bottom'bottom'params) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Bottom'bottom'params) where
-    type Cerial msg Bottom'bottom'params = (Capnp.Gen.ById.X832bcc6686a26d56.Bottom'bottom'params msg)
-    decerialize raw = (Std_.pure Bottom'bottom'params)
-instance (Classes.Marshal s Bottom'bottom'params) where
-    marshalInto raw_ value_ = case value_ of
-        (Bottom'bottom'params) ->
-            (do
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Bottom'bottom'params)
-instance (Classes.Cerialize s (V.Vector Bottom'bottom'params)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Bottom'bottom'params))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Bottom'bottom'params)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Bottom'bottom'params))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Bottom'bottom'params)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Bottom'bottom'params))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Bottom'bottom'params)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Bottom'bottom'results 
-    = Bottom'bottom'results 
-        {}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Bottom'bottom'results) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Bottom'bottom'results) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Bottom'bottom'results) where
-    type Cerial msg Bottom'bottom'results = (Capnp.Gen.ById.X832bcc6686a26d56.Bottom'bottom'results msg)
-    decerialize raw = (Std_.pure Bottom'bottom'results)
-instance (Classes.Marshal s Bottom'bottom'results) where
-    marshalInto raw_ value_ = case value_ of
-        (Bottom'bottom'results) ->
-            (do
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Bottom'bottom'results)
-instance (Classes.Cerialize s (V.Vector Bottom'bottom'results)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Bottom'bottom'results))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Bottom'bottom'results)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Bottom'bottom'results))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Bottom'bottom'results)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Bottom'bottom'results))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Bottom'bottom'results)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Defaults 
-    = Defaults 
-        {text :: T.Text
-        ,data_ :: BS.ByteString
-        ,float :: Std_.Float
-        ,int :: Std_.Int32
-        ,uint :: Std_.Word32}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default Defaults) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const Defaults) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize Defaults) where
-    type Cerial msg Defaults = (Capnp.Gen.ById.X832bcc6686a26d56.Defaults msg)
-    decerialize raw = (Defaults <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Defaults'text raw) >>= Classes.decerialize)
-                                <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_Defaults'data_ raw) >>= Classes.decerialize)
-                                <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_Defaults'float raw)
-                                <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_Defaults'int raw)
-                                <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_Defaults'uint raw))
-instance (Classes.Marshal s Defaults) where
-    marshalInto raw_ value_ = case value_ of
-        Defaults{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) text) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Defaults'text raw_))
-                ((Classes.cerialize (Untyped.message raw_) data_) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_Defaults'data_ raw_))
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_Defaults'float raw_ float)
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_Defaults'int raw_ int)
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_Defaults'uint raw_ uint)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s Defaults)
-instance (Classes.Cerialize s (V.Vector Defaults)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Defaults))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Defaults)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Defaults))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Defaults)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Defaults))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Defaults)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data BenchmarkA 
-    = BenchmarkA 
-        {name :: T.Text
-        ,birthDay :: Std_.Int64
-        ,phone :: T.Text
-        ,siblings :: Std_.Int32
-        ,spouse :: Std_.Bool
-        ,money :: Std_.Double}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance (Default.Default BenchmarkA) where
-    def  = GenHelpersPure.defaultStruct
-instance (Classes.FromStruct Message.Const BenchmarkA) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance (Classes.Decerialize BenchmarkA) where
-    type Cerial msg BenchmarkA = (Capnp.Gen.ById.X832bcc6686a26d56.BenchmarkA msg)
-    decerialize raw = (BenchmarkA <$> ((Capnp.Gen.ById.X832bcc6686a26d56.get_BenchmarkA'name raw) >>= Classes.decerialize)
-                                  <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_BenchmarkA'birthDay raw)
-                                  <*> ((Capnp.Gen.ById.X832bcc6686a26d56.get_BenchmarkA'phone raw) >>= Classes.decerialize)
-                                  <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_BenchmarkA'siblings raw)
-                                  <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_BenchmarkA'spouse raw)
-                                  <*> (Capnp.Gen.ById.X832bcc6686a26d56.get_BenchmarkA'money raw))
-instance (Classes.Marshal s BenchmarkA) where
-    marshalInto raw_ value_ = case value_ of
-        BenchmarkA{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) name) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_BenchmarkA'name raw_))
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_BenchmarkA'birthDay raw_ birthDay)
-                ((Classes.cerialize (Untyped.message raw_) phone) >>= (Capnp.Gen.ById.X832bcc6686a26d56.set_BenchmarkA'phone raw_))
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_BenchmarkA'siblings raw_ siblings)
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_BenchmarkA'spouse raw_ spouse)
-                (Capnp.Gen.ById.X832bcc6686a26d56.set_BenchmarkA'money raw_ money)
-                (Std_.pure ())
-                )
-instance (Classes.Cerialize s BenchmarkA)
-instance (Classes.Cerialize s (V.Vector BenchmarkA)) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance (Classes.Cerialize s (V.Vector (V.Vector BenchmarkA))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector BenchmarkA)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector BenchmarkA))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector BenchmarkA)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector BenchmarkA))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector BenchmarkA)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance (Classes.Decerialize Capnp.Gen.ById.X832bcc6686a26d56.Airport) where
-    type Cerial msg Capnp.Gen.ById.X832bcc6686a26d56.Airport = Capnp.Gen.ById.X832bcc6686a26d56.Airport
-    decerialize  = Std_.pure
-instance (Classes.Cerialize s Capnp.Gen.ById.X832bcc6686a26d56.Airport) where
-    cerialize _ = Std_.pure
-instance (Classes.Cerialize s (V.Vector Capnp.Gen.ById.X832bcc6686a26d56.Airport)) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector Capnp.Gen.ById.X832bcc6686a26d56.Airport))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.X832bcc6686a26d56.Airport)))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.X832bcc6686a26d56.Airport))))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.X832bcc6686a26d56.Airport)))))) where
-    cerialize  = Classes.cerializeBasicVec
-instance (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Capnp.Gen.ById.X832bcc6686a26d56.Airport))))))) where
-    cerialize  = Classes.cerializeBasicVec
diff --git a/gen/tests/Capnp/Gen/ById/X832bcc6686a26d56.hs b/gen/tests/Capnp/Gen/ById/X832bcc6686a26d56.hs
deleted file mode 100644
--- a/gen/tests/Capnp/Gen/ById/X832bcc6686a26d56.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.X832bcc6686a26d56(module Capnp.Gen.Aircraft) where
-import Capnp.Gen.Aircraft
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/tests/Capnp/Gen/ById/X832bcc6686a26d56/Pure.hs b/gen/tests/Capnp/Gen/ById/X832bcc6686a26d56/Pure.hs
deleted file mode 100644
--- a/gen/tests/Capnp/Gen/ById/X832bcc6686a26d56/Pure.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.X832bcc6686a26d56.Pure(module Capnp.Gen.Aircraft.Pure) where
-import Capnp.Gen.Aircraft.Pure
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/tests/Capnp/Gen/ById/Xb6421fb8e478d144.hs b/gen/tests/Capnp/Gen/ById/Xb6421fb8e478d144.hs
deleted file mode 100644
--- a/gen/tests/Capnp/Gen/ById/Xb6421fb8e478d144.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.Xb6421fb8e478d144(module Capnp.Gen.Generics) where
-import Capnp.Gen.Generics
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/tests/Capnp/Gen/ById/Xb6421fb8e478d144/Pure.hs b/gen/tests/Capnp/Gen/ById/Xb6421fb8e478d144/Pure.hs
deleted file mode 100644
--- a/gen/tests/Capnp/Gen/ById/Xb6421fb8e478d144/Pure.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.ById.Xb6421fb8e478d144.Pure(module Capnp.Gen.Generics.Pure) where
-import Capnp.Gen.Generics.Pure
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
diff --git a/gen/tests/Capnp/Gen/Generics.hs b/gen/tests/Capnp/Gen/Generics.hs
deleted file mode 100644
--- a/gen/tests/Capnp/Gen/Generics.hs
+++ /dev/null
@@ -1,514 +0,0 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Generics where
-import qualified Capnp.Message as Message
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Basics as Basics
-import qualified Capnp.GenHelpers as GenHelpers
-import qualified Capnp.Classes as Classes
-import qualified GHC.Generics as Generics
-import qualified Capnp.Bits as Std_
-import qualified Data.Maybe as Std_
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-newtype Maybe t msg
-    = Maybe'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Maybe t msg)) where
-    fromStruct struct = (Std_.pure (Maybe'newtype_ struct))
-instance (Classes.ToStruct msg (Maybe t msg)) where
-    toStruct (Maybe'newtype_ struct) = struct
-instance (Untyped.HasMessage (Maybe t mut) mut) where
-    message (Maybe'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Maybe t mut) mut) where
-    messageDefault msg = (Maybe'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Maybe t msg)) where
-    fromPtr msg ptr = (Maybe'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Maybe t (Message.Mut s))) where
-    toPtr msg (Maybe'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Maybe t (Message.Mut s))) where
-    new msg = (Maybe'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (Maybe t mut)) where
-    newtype List mut (Maybe t mut)
-        = Maybe'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Maybe'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Maybe'List_ l) = (Untyped.ListStruct l)
-    length (Maybe'List_ l) = (Untyped.length l)
-    index i (Maybe'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Maybe t (Message.Mut s))) where
-    setIndex (Maybe'newtype_ elt) i (Maybe'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Maybe'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-data Maybe' t (mut :: Message.Mutability)
-    = Maybe'nothing 
-    | Maybe'just t
-    | Maybe'unknown' Std_.Word16
-instance ((Classes.FromPtr mut t)) => (Classes.FromStruct mut (Maybe' t mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 0)
-        case tag of
-            0 ->
-                (Std_.pure Maybe'nothing)
-            1 ->
-                (Maybe'just <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            _ ->
-                (Std_.pure (Maybe'unknown' (Std_.fromIntegral tag)))
-        )
-get_Maybe' :: ((Untyped.ReadCtx m msg)
-              ,(Classes.FromStruct msg (Maybe' t msg))) => (Maybe t msg) -> (m (Maybe' t msg))
-get_Maybe' (Maybe'newtype_ struct) = (Classes.fromStruct struct)
-set_Maybe'nothing :: ((Untyped.RWCtx m s)) => (Maybe t (Message.Mut s)) -> (m ())
-set_Maybe'nothing (Maybe'newtype_ struct) = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 0 0)
-    (Std_.pure ())
-    )
-set_Maybe'just :: ((Untyped.RWCtx m s)
-                  ,(Classes.ToPtr s t)) => (Maybe t (Message.Mut s)) -> t -> (m ())
-set_Maybe'just (Maybe'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Maybe'unknown' :: ((Untyped.RWCtx m s)) => (Maybe t (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Maybe'unknown' (Maybe'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-newtype Either a b msg
-    = Either'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Either a b msg)) where
-    fromStruct struct = (Std_.pure (Either'newtype_ struct))
-instance (Classes.ToStruct msg (Either a b msg)) where
-    toStruct (Either'newtype_ struct) = struct
-instance (Untyped.HasMessage (Either a b mut) mut) where
-    message (Either'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Either a b mut) mut) where
-    messageDefault msg = (Either'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Either a b msg)) where
-    fromPtr msg ptr = (Either'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Either a b (Message.Mut s))) where
-    toPtr msg (Either'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Either a b (Message.Mut s))) where
-    new msg = (Either'newtype_ <$> (Untyped.allocStruct msg 1 1))
-instance (Basics.ListElem mut (Either a b mut)) where
-    newtype List mut (Either a b mut)
-        = Either'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Either'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Either'List_ l) = (Untyped.ListStruct l)
-    length (Either'List_ l) = (Untyped.length l)
-    index i (Either'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Either a b (Message.Mut s))) where
-    setIndex (Either'newtype_ elt) i (Either'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Either'List_ <$> (Untyped.allocCompositeList msg 1 1 len))
-data Either' a b (mut :: Message.Mutability)
-    = Either'left a
-    | Either'right b
-    | Either'unknown' Std_.Word16
-instance ((Classes.FromPtr mut a)
-         ,(Classes.FromPtr mut b)) => (Classes.FromStruct mut (Either' a b mut)) where
-    fromStruct struct = (do
-        tag <- (GenHelpers.getTag struct 0)
-        case tag of
-            0 ->
-                (Either'left <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            1 ->
-                (Either'right <$> (do
-                    ptr <- (Untyped.getPtr 0 struct)
-                    (Classes.fromPtr (Untyped.message struct) ptr)
-                    ))
-            _ ->
-                (Std_.pure (Either'unknown' (Std_.fromIntegral tag)))
-        )
-get_Either' :: ((Untyped.ReadCtx m msg)
-               ,(Classes.FromStruct msg (Either' a b msg))) => (Either a b msg) -> (m (Either' a b msg))
-get_Either' (Either'newtype_ struct) = (Classes.fromStruct struct)
-set_Either'left :: ((Untyped.RWCtx m s)
-                   ,(Classes.ToPtr s a)) => (Either a b (Message.Mut s)) -> a -> (m ())
-set_Either'left (Either'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (0 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Either'right :: ((Untyped.RWCtx m s)
-                    ,(Classes.ToPtr s b)) => (Either a b (Message.Mut s)) -> b -> (m ())
-set_Either'right (Either'newtype_ struct) value = (do
-    (GenHelpers.setWordField struct (1 :: Std_.Word16) 0 0 0)
-    (do
-        ptr <- (Classes.toPtr (Untyped.message struct) value)
-        (Untyped.setPtr ptr 0 struct)
-        )
-    )
-set_Either'unknown' :: ((Untyped.RWCtx m s)) => (Either a b (Message.Mut s)) -> Std_.Word16 -> (m ())
-set_Either'unknown' (Either'newtype_ struct) value = (GenHelpers.setWordField struct ((Std_.fromIntegral (Classes.toWord value)) :: Std_.Word16) 0 0 0)
-newtype Pair a b msg
-    = Pair'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Pair a b msg)) where
-    fromStruct struct = (Std_.pure (Pair'newtype_ struct))
-instance (Classes.ToStruct msg (Pair a b msg)) where
-    toStruct (Pair'newtype_ struct) = struct
-instance (Untyped.HasMessage (Pair a b mut) mut) where
-    message (Pair'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Pair a b mut) mut) where
-    messageDefault msg = (Pair'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Pair a b msg)) where
-    fromPtr msg ptr = (Pair'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Pair a b (Message.Mut s))) where
-    toPtr msg (Pair'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Pair a b (Message.Mut s))) where
-    new msg = (Pair'newtype_ <$> (Untyped.allocStruct msg 0 2))
-instance (Basics.ListElem mut (Pair a b mut)) where
-    newtype List mut (Pair a b mut)
-        = Pair'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Pair'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Pair'List_ l) = (Untyped.ListStruct l)
-    length (Pair'List_ l) = (Untyped.length l)
-    index i (Pair'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Pair a b (Message.Mut s))) where
-    setIndex (Pair'newtype_ elt) i (Pair'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Pair'List_ <$> (Untyped.allocCompositeList msg 0 2 len))
-get_Pair'fst :: ((Untyped.ReadCtx m msg)
-                ,(Classes.FromPtr msg a)) => (Pair a b msg) -> (m a)
-get_Pair'fst (Pair'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Pair'fst :: ((Untyped.RWCtx m s)
-                ,(Classes.ToPtr s a)) => (Pair a b (Message.Mut s)) -> a -> (m ())
-set_Pair'fst (Pair'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Pair'fst :: ((Untyped.ReadCtx m msg)) => (Pair a b msg) -> (m Std_.Bool)
-has_Pair'fst (Pair'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-get_Pair'snd :: ((Untyped.ReadCtx m msg)
-                ,(Classes.FromPtr msg b)) => (Pair a b msg) -> (m b)
-get_Pair'snd (Pair'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Pair'snd :: ((Untyped.RWCtx m s)
-                ,(Classes.ToPtr s b)) => (Pair a b (Message.Mut s)) -> b -> (m ())
-set_Pair'snd (Pair'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Pair'snd :: ((Untyped.ReadCtx m msg)) => (Pair a b msg) -> (m Std_.Bool)
-has_Pair'snd (Pair'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-newtype Nested t msg
-    = Nested'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Nested t msg)) where
-    fromStruct struct = (Std_.pure (Nested'newtype_ struct))
-instance (Classes.ToStruct msg (Nested t msg)) where
-    toStruct (Nested'newtype_ struct) = struct
-instance (Untyped.HasMessage (Nested t mut) mut) where
-    message (Nested'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Nested t mut) mut) where
-    messageDefault msg = (Nested'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Nested t msg)) where
-    fromPtr msg ptr = (Nested'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Nested t (Message.Mut s))) where
-    toPtr msg (Nested'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Nested t (Message.Mut s))) where
-    new msg = (Nested'newtype_ <$> (Untyped.allocStruct msg 0 0))
-instance (Basics.ListElem mut (Nested t mut)) where
-    newtype List mut (Nested t mut)
-        = Nested'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Nested'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Nested'List_ l) = (Untyped.ListStruct l)
-    length (Nested'List_ l) = (Untyped.length l)
-    index i (Nested'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Nested t (Message.Mut s))) where
-    setIndex (Nested'newtype_ elt) i (Nested'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Nested'List_ <$> (Untyped.allocCompositeList msg 0 0 len))
-newtype Nested'SomeStruct t msg
-    = Nested'SomeStruct'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Nested'SomeStruct t msg)) where
-    fromStruct struct = (Std_.pure (Nested'SomeStruct'newtype_ struct))
-instance (Classes.ToStruct msg (Nested'SomeStruct t msg)) where
-    toStruct (Nested'SomeStruct'newtype_ struct) = struct
-instance (Untyped.HasMessage (Nested'SomeStruct t mut) mut) where
-    message (Nested'SomeStruct'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Nested'SomeStruct t mut) mut) where
-    messageDefault msg = (Nested'SomeStruct'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Nested'SomeStruct t msg)) where
-    fromPtr msg ptr = (Nested'SomeStruct'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Nested'SomeStruct t (Message.Mut s))) where
-    toPtr msg (Nested'SomeStruct'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Nested'SomeStruct t (Message.Mut s))) where
-    new msg = (Nested'SomeStruct'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Nested'SomeStruct t mut)) where
-    newtype List mut (Nested'SomeStruct t mut)
-        = Nested'SomeStruct'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Nested'SomeStruct'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Nested'SomeStruct'List_ l) = (Untyped.ListStruct l)
-    length (Nested'SomeStruct'List_ l) = (Untyped.length l)
-    index i (Nested'SomeStruct'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Nested'SomeStruct t (Message.Mut s))) where
-    setIndex (Nested'SomeStruct'newtype_ elt) i (Nested'SomeStruct'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Nested'SomeStruct'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Nested'SomeStruct'value :: ((Untyped.ReadCtx m msg)
-                               ,(Classes.FromPtr msg t)) => (Nested'SomeStruct t msg) -> (m t)
-get_Nested'SomeStruct'value (Nested'SomeStruct'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Nested'SomeStruct'value :: ((Untyped.RWCtx m s)
-                               ,(Classes.ToPtr s t)) => (Nested'SomeStruct t (Message.Mut s)) -> t -> (m ())
-set_Nested'SomeStruct'value (Nested'SomeStruct'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Nested'SomeStruct'value :: ((Untyped.ReadCtx m msg)) => (Nested'SomeStruct t msg) -> (m Std_.Bool)
-has_Nested'SomeStruct'value (Nested'SomeStruct'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-newtype Nested'SomeInterface t msg
-    = Nested'SomeInterface'newtype_ (Std_.Maybe (Untyped.Cap msg))
-instance (Classes.FromPtr msg (Nested'SomeInterface t msg)) where
-    fromPtr msg ptr = (Nested'SomeInterface'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Nested'SomeInterface t (Message.Mut s))) where
-    toPtr msg (Nested'SomeInterface'newtype_ (Std_.Nothing)) = (Std_.pure Std_.Nothing)
-    toPtr msg (Nested'SomeInterface'newtype_ (Std_.Just cap)) = (Std_.pure (Std_.Just (Untyped.PtrCap cap)))
-newtype Nested'SomeInterface'method'params t msg
-    = Nested'SomeInterface'method'params'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Nested'SomeInterface'method'params t msg)) where
-    fromStruct struct = (Std_.pure (Nested'SomeInterface'method'params'newtype_ struct))
-instance (Classes.ToStruct msg (Nested'SomeInterface'method'params t msg)) where
-    toStruct (Nested'SomeInterface'method'params'newtype_ struct) = struct
-instance (Untyped.HasMessage (Nested'SomeInterface'method'params t mut) mut) where
-    message (Nested'SomeInterface'method'params'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Nested'SomeInterface'method'params t mut) mut) where
-    messageDefault msg = (Nested'SomeInterface'method'params'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Nested'SomeInterface'method'params t msg)) where
-    fromPtr msg ptr = (Nested'SomeInterface'method'params'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Nested'SomeInterface'method'params t (Message.Mut s))) where
-    toPtr msg (Nested'SomeInterface'method'params'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Nested'SomeInterface'method'params t (Message.Mut s))) where
-    new msg = (Nested'SomeInterface'method'params'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Nested'SomeInterface'method'params t mut)) where
-    newtype List mut (Nested'SomeInterface'method'params t mut)
-        = Nested'SomeInterface'method'params'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Nested'SomeInterface'method'params'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Nested'SomeInterface'method'params'List_ l) = (Untyped.ListStruct l)
-    length (Nested'SomeInterface'method'params'List_ l) = (Untyped.length l)
-    index i (Nested'SomeInterface'method'params'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Nested'SomeInterface'method'params t (Message.Mut s))) where
-    setIndex (Nested'SomeInterface'method'params'newtype_ elt) i (Nested'SomeInterface'method'params'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Nested'SomeInterface'method'params'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Nested'SomeInterface'method'params'arg :: ((Untyped.ReadCtx m msg)
-                                              ,(Classes.FromPtr msg t)) => (Nested'SomeInterface'method'params t msg) -> (m t)
-get_Nested'SomeInterface'method'params'arg (Nested'SomeInterface'method'params'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Nested'SomeInterface'method'params'arg :: ((Untyped.RWCtx m s)
-                                              ,(Classes.ToPtr s t)) => (Nested'SomeInterface'method'params t (Message.Mut s)) -> t -> (m ())
-set_Nested'SomeInterface'method'params'arg (Nested'SomeInterface'method'params'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Nested'SomeInterface'method'params'arg :: ((Untyped.ReadCtx m msg)) => (Nested'SomeInterface'method'params t msg) -> (m Std_.Bool)
-has_Nested'SomeInterface'method'params'arg (Nested'SomeInterface'method'params'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-newtype Nested'SomeInterface'method'results t msg
-    = Nested'SomeInterface'method'results'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Nested'SomeInterface'method'results t msg)) where
-    fromStruct struct = (Std_.pure (Nested'SomeInterface'method'results'newtype_ struct))
-instance (Classes.ToStruct msg (Nested'SomeInterface'method'results t msg)) where
-    toStruct (Nested'SomeInterface'method'results'newtype_ struct) = struct
-instance (Untyped.HasMessage (Nested'SomeInterface'method'results t mut) mut) where
-    message (Nested'SomeInterface'method'results'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Nested'SomeInterface'method'results t mut) mut) where
-    messageDefault msg = (Nested'SomeInterface'method'results'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Nested'SomeInterface'method'results t msg)) where
-    fromPtr msg ptr = (Nested'SomeInterface'method'results'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Nested'SomeInterface'method'results t (Message.Mut s))) where
-    toPtr msg (Nested'SomeInterface'method'results'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Nested'SomeInterface'method'results t (Message.Mut s))) where
-    new msg = (Nested'SomeInterface'method'results'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (Nested'SomeInterface'method'results t mut)) where
-    newtype List mut (Nested'SomeInterface'method'results t mut)
-        = Nested'SomeInterface'method'results'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Nested'SomeInterface'method'results'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Nested'SomeInterface'method'results'List_ l) = (Untyped.ListStruct l)
-    length (Nested'SomeInterface'method'results'List_ l) = (Untyped.length l)
-    index i (Nested'SomeInterface'method'results'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Nested'SomeInterface'method'results t (Message.Mut s))) where
-    setIndex (Nested'SomeInterface'method'results'newtype_ elt) i (Nested'SomeInterface'method'results'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Nested'SomeInterface'method'results'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_Nested'SomeInterface'method'results'result :: ((Untyped.ReadCtx m msg)
-                                                  ,(Classes.FromPtr msg t)) => (Nested'SomeInterface'method'results t msg) -> (m t)
-get_Nested'SomeInterface'method'results'result (Nested'SomeInterface'method'results'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Nested'SomeInterface'method'results'result :: ((Untyped.RWCtx m s)
-                                                  ,(Classes.ToPtr s t)) => (Nested'SomeInterface'method'results t (Message.Mut s)) -> t -> (m ())
-set_Nested'SomeInterface'method'results'result (Nested'SomeInterface'method'results'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Nested'SomeInterface'method'results'result :: ((Untyped.ReadCtx m msg)) => (Nested'SomeInterface'method'results t msg) -> (m Std_.Bool)
-has_Nested'SomeInterface'method'results'result (Nested'SomeInterface'method'results'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-newtype Specialized t msg
-    = Specialized'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (Specialized t msg)) where
-    fromStruct struct = (Std_.pure (Specialized'newtype_ struct))
-instance (Classes.ToStruct msg (Specialized t msg)) where
-    toStruct (Specialized'newtype_ struct) = struct
-instance (Untyped.HasMessage (Specialized t mut) mut) where
-    message (Specialized'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (Specialized t mut) mut) where
-    messageDefault msg = (Specialized'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (Specialized t msg)) where
-    fromPtr msg ptr = (Specialized'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (Specialized t (Message.Mut s))) where
-    toPtr msg (Specialized'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (Specialized t (Message.Mut s))) where
-    new msg = (Specialized'newtype_ <$> (Untyped.allocStruct msg 0 2))
-instance (Basics.ListElem mut (Specialized t mut)) where
-    newtype List mut (Specialized t mut)
-        = Specialized'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (Specialized'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (Specialized'List_ l) = (Untyped.ListStruct l)
-    length (Specialized'List_ l) = (Untyped.length l)
-    index i (Specialized'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (Specialized t (Message.Mut s))) where
-    setIndex (Specialized'newtype_ elt) i (Specialized'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (Specialized'List_ <$> (Untyped.allocCompositeList msg 0 2 len))
-get_Specialized'either :: ((Untyped.ReadCtx m msg)
-                          ,(Classes.FromPtr msg (Either (Basics.Text msg) t msg))) => (Specialized t msg) -> (m (Either (Basics.Text msg) t msg))
-get_Specialized'either (Specialized'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Specialized'either :: ((Untyped.RWCtx m s)
-                          ,(Classes.ToPtr s (Either (Basics.Text (Message.Mut s)) t (Message.Mut s)))) => (Specialized t (Message.Mut s)) -> (Either (Basics.Text (Message.Mut s)) t (Message.Mut s)) -> (m ())
-set_Specialized'either (Specialized'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_Specialized'either :: ((Untyped.ReadCtx m msg)) => (Specialized t msg) -> (m Std_.Bool)
-has_Specialized'either (Specialized'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
-new_Specialized'either :: ((Untyped.RWCtx m s)) => (Specialized t (Message.Mut s)) -> (m (Either (Basics.Text (Message.Mut s)) t (Message.Mut s)))
-new_Specialized'either struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Specialized'either struct result)
-    (Std_.pure result)
-    )
-get_Specialized'nestedStruct :: ((Untyped.ReadCtx m msg)
-                                ,(Classes.FromPtr msg (Nested'SomeStruct (Basics.Data msg) msg))) => (Specialized t msg) -> (m (Nested'SomeStruct (Basics.Data msg) msg))
-get_Specialized'nestedStruct (Specialized'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 1 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_Specialized'nestedStruct :: ((Untyped.RWCtx m s)
-                                ,(Classes.ToPtr s (Nested'SomeStruct (Basics.Data (Message.Mut s)) (Message.Mut s)))) => (Specialized t (Message.Mut s)) -> (Nested'SomeStruct (Basics.Data (Message.Mut s)) (Message.Mut s)) -> (m ())
-set_Specialized'nestedStruct (Specialized'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 1 struct)
-    )
-has_Specialized'nestedStruct :: ((Untyped.ReadCtx m msg)) => (Specialized t msg) -> (m Std_.Bool)
-has_Specialized'nestedStruct (Specialized'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 1 struct))
-new_Specialized'nestedStruct :: ((Untyped.RWCtx m s)) => (Specialized t (Message.Mut s)) -> (m (Nested'SomeStruct (Basics.Data (Message.Mut s)) (Message.Mut s)))
-new_Specialized'nestedStruct struct = (do
-    result <- (Classes.new (Untyped.message struct))
-    (set_Specialized'nestedStruct struct result)
-    (Std_.pure result)
-    )
-newtype HasGroup t msg
-    = HasGroup'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (HasGroup t msg)) where
-    fromStruct struct = (Std_.pure (HasGroup'newtype_ struct))
-instance (Classes.ToStruct msg (HasGroup t msg)) where
-    toStruct (HasGroup'newtype_ struct) = struct
-instance (Untyped.HasMessage (HasGroup t mut) mut) where
-    message (HasGroup'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (HasGroup t mut) mut) where
-    messageDefault msg = (HasGroup'newtype_ <$> (Untyped.messageDefault msg))
-instance (Classes.FromPtr msg (HasGroup t msg)) where
-    fromPtr msg ptr = (HasGroup'newtype_ <$> (Classes.fromPtr msg ptr))
-instance (Classes.ToPtr s (HasGroup t (Message.Mut s))) where
-    toPtr msg (HasGroup'newtype_ struct) = (Classes.toPtr msg struct)
-instance (Classes.Allocate s (HasGroup t (Message.Mut s))) where
-    new msg = (HasGroup'newtype_ <$> (Untyped.allocStruct msg 0 1))
-instance (Basics.ListElem mut (HasGroup t mut)) where
-    newtype List mut (HasGroup t mut)
-        = HasGroup'List_ (Untyped.ListOf mut (Untyped.Struct mut))
-    listFromPtr msg ptr = (HasGroup'List_ <$> (Classes.fromPtr msg ptr))
-    toUntypedList (HasGroup'List_ l) = (Untyped.ListStruct l)
-    length (HasGroup'List_ l) = (Untyped.length l)
-    index i (HasGroup'List_ l) = (do
-        elt <- (Untyped.index i l)
-        (Classes.fromStruct elt)
-        )
-instance (Basics.MutListElem s (HasGroup t (Message.Mut s))) where
-    setIndex (HasGroup'newtype_ elt) i (HasGroup'List_ l) = (Untyped.setIndex elt i l)
-    newList msg len = (HasGroup'List_ <$> (Untyped.allocCompositeList msg 0 1 len))
-get_HasGroup'theGroup :: ((Untyped.ReadCtx m msg)
-                         ,(Classes.FromStruct msg (HasGroup'theGroup t msg))) => (HasGroup t msg) -> (m (HasGroup'theGroup t msg))
-get_HasGroup'theGroup (HasGroup'newtype_ struct) = (Classes.fromStruct struct)
-newtype HasGroup'theGroup t msg
-    = HasGroup'theGroup'newtype_ (Untyped.Struct msg)
-instance (Classes.FromStruct msg (HasGroup'theGroup t msg)) where
-    fromStruct struct = (Std_.pure (HasGroup'theGroup'newtype_ struct))
-instance (Classes.ToStruct msg (HasGroup'theGroup t msg)) where
-    toStruct (HasGroup'theGroup'newtype_ struct) = struct
-instance (Untyped.HasMessage (HasGroup'theGroup t mut) mut) where
-    message (HasGroup'theGroup'newtype_ struct) = (Untyped.message struct)
-instance (Untyped.MessageDefault (HasGroup'theGroup t mut) mut) where
-    messageDefault msg = (HasGroup'theGroup'newtype_ <$> (Untyped.messageDefault msg))
-get_HasGroup'theGroup'value :: ((Untyped.ReadCtx m msg)
-                               ,(Classes.FromPtr msg t)) => (HasGroup'theGroup t msg) -> (m t)
-get_HasGroup'theGroup'value (HasGroup'theGroup'newtype_ struct) = (do
-    ptr <- (Untyped.getPtr 0 struct)
-    (Classes.fromPtr (Untyped.message struct) ptr)
-    )
-set_HasGroup'theGroup'value :: ((Untyped.RWCtx m s)
-                               ,(Classes.ToPtr s t)) => (HasGroup'theGroup t (Message.Mut s)) -> t -> (m ())
-set_HasGroup'theGroup'value (HasGroup'theGroup'newtype_ struct) value = (do
-    ptr <- (Classes.toPtr (Untyped.message struct) value)
-    (Untyped.setPtr ptr 0 struct)
-    )
-has_HasGroup'theGroup'value :: ((Untyped.ReadCtx m msg)) => (HasGroup'theGroup t msg) -> (m Std_.Bool)
-has_HasGroup'theGroup'value (HasGroup'theGroup'newtype_ struct) = (Std_.isJust <$> (Untyped.getPtr 0 struct))
diff --git a/gen/tests/Capnp/Gen/Generics/New.hs b/gen/tests/Capnp/Gen/Generics/New.hs
--- a/gen/tests/Capnp/Gen/Generics/New.hs
+++ b/gen/tests/Capnp/Gen/Generics/New.hs
@@ -27,7 +27,7 @@
 import qualified Capnp.GenHelpers.New as GH
 import qualified Capnp.New.Classes as C
 import qualified GHC.Generics as Generics
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
+import qualified Capnp.GenHelpers.New.Rpc as GH
 import qualified Prelude as Std_
 import qualified Data.Word as Std_
 import qualified Data.Int as Std_
diff --git a/gen/tests/Capnp/Gen/Generics/Pure.hs b/gen/tests/Capnp/Gen/Generics/Pure.hs
deleted file mode 100644
--- a/gen/tests/Capnp/Gen/Generics/Pure.hs
+++ /dev/null
@@ -1,818 +0,0 @@
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE RecordWildCards #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-dodgy-exports #-}
-{-# OPTIONS_GHC -Wno-unused-matches #-}
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Capnp.Gen.Generics.Pure(Maybe(..)
-                              ,Either(..)
-                              ,Pair(..)
-                              ,Nested(..)
-                              ,Nested'SomeStruct(..)
-                              ,Nested'SomeInterface(..)
-                              ,Nested'SomeInterface'server_(..)
-                              ,export_Nested'SomeInterface
-                              ,Nested'SomeInterface'method'params(..)
-                              ,Nested'SomeInterface'method'results(..)
-                              ,Specialized(..)
-                              ,HasGroup(..)
-                              ,HasGroup'theGroup(..)) where
-import qualified Capnp.GenHelpers.ReExports.Data.Vector as V
-import qualified Capnp.GenHelpers.ReExports.Data.Text as T
-import qualified Capnp.GenHelpers.ReExports.Data.ByteString as BS
-import qualified Capnp.GenHelpers.ReExports.Data.Default as Default
-import qualified GHC.Generics as Generics
-import qualified Control.Monad.IO.Class as MonadIO
-import qualified Capnp.Untyped.Pure as UntypedPure
-import qualified Capnp.Untyped as Untyped
-import qualified Capnp.Message as Message
-import qualified Capnp.Classes as Classes
-import qualified Capnp.Basics.Pure as BasicsPure
-import qualified Capnp.GenHelpers.Pure as GenHelpersPure
-import qualified Capnp.Rpc.Untyped as Rpc
-import qualified Capnp.Rpc.Server as Server
-import qualified Capnp.GenHelpers.Rpc as RpcHelpers
-import qualified Capnp.GenHelpers.ReExports.Control.Concurrent.STM as STM
-import qualified Capnp.GenHelpers.ReExports.Control.Monad.STM.Class as STM
-import qualified Capnp.GenHelpers.ReExports.Supervisors as Supervisors
-import qualified Capnp.Gen.ById.Xb6421fb8e478d144
-import qualified Prelude as Std_
-import qualified Data.Word as Std_
-import qualified Data.Int as Std_
-import Prelude ((<$>), (<*>), (>>=))
-data Maybe t
-    = Maybe'nothing 
-    | Maybe'just t
-    | Maybe'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Default.Default (Maybe t)) where
-    def  = GenHelpersPure.defaultStruct
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Classes.FromStruct Message.Const (Maybe t)) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Classes.Decerialize (Maybe t)) where
-    type Cerial msg (Maybe t) = (Capnp.Gen.ById.Xb6421fb8e478d144.Maybe (Classes.Cerial msg t) msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xb6421fb8e478d144.get_Maybe' raw)
-        case raw of
-            (Capnp.Gen.ById.Xb6421fb8e478d144.Maybe'nothing) ->
-                (Std_.pure Maybe'nothing)
-            (Capnp.Gen.ById.Xb6421fb8e478d144.Maybe'just raw) ->
-                (Maybe'just <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb6421fb8e478d144.Maybe'unknown' tag) ->
-                (Std_.pure (Maybe'unknown' tag))
-        )
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Marshal s (Maybe t)) where
-    marshalInto raw_ value_ = case value_ of
-        (Maybe'nothing) ->
-            (Capnp.Gen.ById.Xb6421fb8e478d144.set_Maybe'nothing raw_)
-        (Maybe'just arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb6421fb8e478d144.set_Maybe'just raw_))
-        (Maybe'unknown' tag) ->
-            (Capnp.Gen.ById.Xb6421fb8e478d144.set_Maybe'unknown' raw_ tag)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (Maybe t))
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (Maybe t))) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (Maybe t)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (Maybe t))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (Maybe t)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Maybe t))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Maybe t)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Maybe t))))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Either a b
-    = Either'left a
-    | Either'right b
-    | Either'unknown' Std_.Word16
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))) => (Default.Default (Either a b)) where
-    def  = GenHelpersPure.defaultStruct
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))) => (Classes.FromStruct Message.Const (Either a b)) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))) => (Classes.Decerialize (Either a b)) where
-    type Cerial msg (Either a b) = (Capnp.Gen.ById.Xb6421fb8e478d144.Either (Classes.Cerial msg a) (Classes.Cerial msg b) msg)
-    decerialize raw = (do
-        raw <- (Capnp.Gen.ById.Xb6421fb8e478d144.get_Either' raw)
-        case raw of
-            (Capnp.Gen.ById.Xb6421fb8e478d144.Either'left raw) ->
-                (Either'left <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb6421fb8e478d144.Either'right raw) ->
-                (Either'right <$> (Classes.decerialize raw))
-            (Capnp.Gen.ById.Xb6421fb8e478d144.Either'unknown' tag) ->
-                (Std_.pure (Either'unknown' tag))
-        )
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Marshal s (Either a b)) where
-    marshalInto raw_ value_ = case value_ of
-        (Either'left arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb6421fb8e478d144.set_Either'left raw_))
-        (Either'right arg_) ->
-            ((Classes.cerialize (Untyped.message raw_) arg_) >>= (Capnp.Gen.ById.Xb6421fb8e478d144.set_Either'right raw_))
-        (Either'unknown' tag) ->
-            (Capnp.Gen.ById.Xb6421fb8e478d144.set_Either'unknown' raw_ tag)
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Cerialize s (Either a b))
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Cerialize s (V.Vector (Either a b))) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Cerialize s (V.Vector (V.Vector (Either a b)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (Either a b))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (Either a b)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Either a b))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Either a b)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Either a b))))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Pair a b
-    = Pair 
-        {fst :: a,snd :: b}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))) => (Default.Default (Pair a b)) where
-    def  = GenHelpersPure.defaultStruct
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))) => (Classes.FromStruct Message.Const (Pair a b)) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))) => (Classes.Decerialize (Pair a b)) where
-    type Cerial msg (Pair a b) = (Capnp.Gen.ById.Xb6421fb8e478d144.Pair (Classes.Cerial msg a) (Classes.Cerial msg b) msg)
-    decerialize raw = (Pair <$> ((Capnp.Gen.ById.Xb6421fb8e478d144.get_Pair'fst raw) >>= Classes.decerialize)
-                            <*> ((Capnp.Gen.ById.Xb6421fb8e478d144.get_Pair'snd raw) >>= Classes.decerialize))
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Marshal s (Pair a b)) where
-    marshalInto raw_ value_ = case value_ of
-        Pair{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) fst) >>= (Capnp.Gen.ById.Xb6421fb8e478d144.set_Pair'fst raw_))
-                ((Classes.cerialize (Untyped.message raw_) snd) >>= (Capnp.Gen.ById.Xb6421fb8e478d144.set_Pair'snd raw_))
-                (Std_.pure ())
-                )
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Cerialize s (Pair a b))
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Cerialize s (V.Vector (Pair a b))) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Cerialize s (V.Vector (V.Vector (Pair a b)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (Pair a b))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (Pair a b)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Pair a b))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Pair a b)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize a)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const a))
-         ,(Classes.Decerialize b)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const b))
-         ,(Classes.Cerialize s a)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) a))
-         ,(Classes.Cerialize s b)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) b))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Pair a b))))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Nested t
-    = Nested 
-        {}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Default.Default (Nested t)) where
-    def  = GenHelpersPure.defaultStruct
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Classes.FromStruct Message.Const (Nested t)) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Classes.Decerialize (Nested t)) where
-    type Cerial msg (Nested t) = (Capnp.Gen.ById.Xb6421fb8e478d144.Nested (Classes.Cerial msg t) msg)
-    decerialize raw = (Std_.pure Nested)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Marshal s (Nested t)) where
-    marshalInto raw_ value_ = case value_ of
-        (Nested) ->
-            (do
-                (Std_.pure ())
-                )
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (Nested t))
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (Nested t))) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (Nested t)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (Nested t))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (Nested t)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Nested t))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Nested t)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Nested t))))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Nested'SomeStruct t
-    = Nested'SomeStruct 
-        {value :: t}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Default.Default (Nested'SomeStruct t)) where
-    def  = GenHelpersPure.defaultStruct
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Classes.FromStruct Message.Const (Nested'SomeStruct t)) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Classes.Decerialize (Nested'SomeStruct t)) where
-    type Cerial msg (Nested'SomeStruct t) = (Capnp.Gen.ById.Xb6421fb8e478d144.Nested'SomeStruct (Classes.Cerial msg t) msg)
-    decerialize raw = (Nested'SomeStruct <$> ((Capnp.Gen.ById.Xb6421fb8e478d144.get_Nested'SomeStruct'value raw) >>= Classes.decerialize))
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Marshal s (Nested'SomeStruct t)) where
-    marshalInto raw_ value_ = case value_ of
-        Nested'SomeStruct{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) value) >>= (Capnp.Gen.ById.Xb6421fb8e478d144.set_Nested'SomeStruct'value raw_))
-                (Std_.pure ())
-                )
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (Nested'SomeStruct t))
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (Nested'SomeStruct t))) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (Nested'SomeStruct t)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (Nested'SomeStruct t))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (Nested'SomeStruct t)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Nested'SomeStruct t))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Nested'SomeStruct t)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Nested'SomeStruct t))))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-newtype Nested'SomeInterface t
-    = Nested'SomeInterface Message.Client
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-class ((MonadIO.MonadIO m)
-      ,(Server.Server m cap)) => (Nested'SomeInterface'server_ m cap t) | cap -> t where
-    {-# MINIMAL nested'SomeInterface'method #-}
-    nested'SomeInterface'method :: cap -> (Server.MethodHandler m (Nested'SomeInterface'method'params t) (Nested'SomeInterface'method'results t))
-    nested'SomeInterface'method _ = Server.methodUnimplemented
-export_Nested'SomeInterface :: ((STM.MonadSTM m)
-                               ,(Nested'SomeInterface'server_ Std_.IO cap t)) => Supervisors.Supervisor -> cap -> (m (Nested'SomeInterface t))
-export_Nested'SomeInterface sup_ server_ = (STM.liftSTM (Nested'SomeInterface <$> (Rpc.export sup_ Server.ServerOps{handleCast = (Server.unwrap server_)
-                                                                                                                   ,handleStop = (Server.shutdown server_)
-                                                                                                                   ,handleCall = (\interfaceId_ methodId_ -> case interfaceId_ of
-                                                                                                                       17400383877992806407 ->
-                                                                                                                           case methodId_ of
-                                                                                                                               0 ->
-                                                                                                                                   (Server.toUntypedHandler (nested'SomeInterface'method server_))
-                                                                                                                               _ ->
-                                                                                                                                   Server.methodUnimplemented
-                                                                                                                       _ ->
-                                                                                                                           Server.methodUnimplemented)})))
-instance (Rpc.IsClient (Nested'SomeInterface t)) where
-    fromClient  = Nested'SomeInterface
-    toClient (Nested'SomeInterface client) = client
-instance (Classes.FromPtr msg (Nested'SomeInterface t)) where
-    fromPtr  = RpcHelpers.isClientFromPtr
-instance (Classes.ToPtr s (Nested'SomeInterface t)) where
-    toPtr  = RpcHelpers.isClientToPtr
-instance (Classes.Decerialize (Nested'SomeInterface t)) where
-    type Cerial msg (Nested'SomeInterface t) = (Capnp.Gen.ById.Xb6421fb8e478d144.Nested'SomeInterface (Classes.Cerial msg t) msg)
-    decerialize (Capnp.Gen.ById.Xb6421fb8e478d144.Nested'SomeInterface'newtype_ maybeCap) = case maybeCap of
-        (Std_.Nothing) ->
-            (Std_.pure (Nested'SomeInterface Message.nullClient))
-        (Std_.Just cap) ->
-            (Nested'SomeInterface <$> (Untyped.getClient cap))
-instance (Classes.Cerialize s (Nested'SomeInterface t)) where
-    cerialize msg (Nested'SomeInterface client) = (Capnp.Gen.ById.Xb6421fb8e478d144.Nested'SomeInterface'newtype_ <$> (Std_.Just <$> (Untyped.appendCap msg client)))
-instance (Server.Server Std_.IO (Nested'SomeInterface t))
-instance (Nested'SomeInterface'server_ Std_.IO (Nested'SomeInterface t) t) where
-    nested'SomeInterface'method (Nested'SomeInterface client) = (Rpc.clientMethodHandler 17400383877992806407 0 client)
-data Nested'SomeInterface'method'params t
-    = Nested'SomeInterface'method'params 
-        {arg :: t}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Default.Default (Nested'SomeInterface'method'params t)) where
-    def  = GenHelpersPure.defaultStruct
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Classes.FromStruct Message.Const (Nested'SomeInterface'method'params t)) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Classes.Decerialize (Nested'SomeInterface'method'params t)) where
-    type Cerial msg (Nested'SomeInterface'method'params t) = (Capnp.Gen.ById.Xb6421fb8e478d144.Nested'SomeInterface'method'params (Classes.Cerial msg t) msg)
-    decerialize raw = (Nested'SomeInterface'method'params <$> ((Capnp.Gen.ById.Xb6421fb8e478d144.get_Nested'SomeInterface'method'params'arg raw) >>= Classes.decerialize))
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Marshal s (Nested'SomeInterface'method'params t)) where
-    marshalInto raw_ value_ = case value_ of
-        Nested'SomeInterface'method'params{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) arg) >>= (Capnp.Gen.ById.Xb6421fb8e478d144.set_Nested'SomeInterface'method'params'arg raw_))
-                (Std_.pure ())
-                )
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (Nested'SomeInterface'method'params t))
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (Nested'SomeInterface'method'params t))) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (Nested'SomeInterface'method'params t)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (Nested'SomeInterface'method'params t))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (Nested'SomeInterface'method'params t)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Nested'SomeInterface'method'params t))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Nested'SomeInterface'method'params t)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Nested'SomeInterface'method'params t))))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Nested'SomeInterface'method'results t
-    = Nested'SomeInterface'method'results 
-        {result :: t}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Default.Default (Nested'SomeInterface'method'results t)) where
-    def  = GenHelpersPure.defaultStruct
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Classes.FromStruct Message.Const (Nested'SomeInterface'method'results t)) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Classes.Decerialize (Nested'SomeInterface'method'results t)) where
-    type Cerial msg (Nested'SomeInterface'method'results t) = (Capnp.Gen.ById.Xb6421fb8e478d144.Nested'SomeInterface'method'results (Classes.Cerial msg t) msg)
-    decerialize raw = (Nested'SomeInterface'method'results <$> ((Capnp.Gen.ById.Xb6421fb8e478d144.get_Nested'SomeInterface'method'results'result raw) >>= Classes.decerialize))
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Marshal s (Nested'SomeInterface'method'results t)) where
-    marshalInto raw_ value_ = case value_ of
-        Nested'SomeInterface'method'results{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) result) >>= (Capnp.Gen.ById.Xb6421fb8e478d144.set_Nested'SomeInterface'method'results'result raw_))
-                (Std_.pure ())
-                )
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (Nested'SomeInterface'method'results t))
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (Nested'SomeInterface'method'results t))) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (Nested'SomeInterface'method'results t)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (Nested'SomeInterface'method'results t))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (Nested'SomeInterface'method'results t)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Nested'SomeInterface'method'results t))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Nested'SomeInterface'method'results t)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Nested'SomeInterface'method'results t))))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data Specialized t
-    = Specialized 
-        {either :: (Either T.Text t)
-        ,nestedStruct :: (Nested'SomeStruct BS.ByteString)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Default.Default (Specialized t)) where
-    def  = GenHelpersPure.defaultStruct
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Classes.FromStruct Message.Const (Specialized t)) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Classes.Decerialize (Specialized t)) where
-    type Cerial msg (Specialized t) = (Capnp.Gen.ById.Xb6421fb8e478d144.Specialized (Classes.Cerial msg t) msg)
-    decerialize raw = (Specialized <$> ((Capnp.Gen.ById.Xb6421fb8e478d144.get_Specialized'either raw) >>= Classes.decerialize)
-                                   <*> ((Capnp.Gen.ById.Xb6421fb8e478d144.get_Specialized'nestedStruct raw) >>= Classes.decerialize))
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Marshal s (Specialized t)) where
-    marshalInto raw_ value_ = case value_ of
-        Specialized{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) either) >>= (Capnp.Gen.ById.Xb6421fb8e478d144.set_Specialized'either raw_))
-                ((Classes.cerialize (Untyped.message raw_) nestedStruct) >>= (Capnp.Gen.ById.Xb6421fb8e478d144.set_Specialized'nestedStruct raw_))
-                (Std_.pure ())
-                )
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (Specialized t))
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (Specialized t))) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (Specialized t)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (Specialized t))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (Specialized t)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Specialized t))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Specialized t)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (Specialized t))))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data HasGroup t
-    = HasGroup 
-        {theGroup :: (HasGroup'theGroup t)}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Default.Default (HasGroup t)) where
-    def  = GenHelpersPure.defaultStruct
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Classes.FromStruct Message.Const (HasGroup t)) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Classes.Decerialize (HasGroup t)) where
-    type Cerial msg (HasGroup t) = (Capnp.Gen.ById.Xb6421fb8e478d144.HasGroup (Classes.Cerial msg t) msg)
-    decerialize raw = (HasGroup <$> ((Capnp.Gen.ById.Xb6421fb8e478d144.get_HasGroup'theGroup raw) >>= Classes.decerialize))
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Marshal s (HasGroup t)) where
-    marshalInto raw_ value_ = case value_ of
-        HasGroup{..} ->
-            (do
-                (do
-                    raw_ <- (Capnp.Gen.ById.Xb6421fb8e478d144.get_HasGroup'theGroup raw_)
-                    (Classes.marshalInto raw_ theGroup)
-                    )
-                (Std_.pure ())
-                )
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (HasGroup t))
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (HasGroup t))) where
-    cerialize  = GenHelpersPure.cerializeCompositeVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (HasGroup t)))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (HasGroup t))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (HasGroup t)))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (HasGroup t))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (HasGroup t)))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector (HasGroup t))))))))) where
-    cerialize  = GenHelpersPure.cerializeBasicVec
-data HasGroup'theGroup t
-    = HasGroup'theGroup' 
-        {value :: t}
-    deriving(Std_.Show
-            ,Std_.Eq
-            ,Generics.Generic)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Default.Default (HasGroup'theGroup t)) where
-    def  = GenHelpersPure.defaultStruct
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Classes.FromStruct Message.Const (HasGroup'theGroup t)) where
-    fromStruct struct = ((Classes.fromStruct struct) >>= Classes.decerialize)
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))) => (Classes.Decerialize (HasGroup'theGroup t)) where
-    type Cerial msg (HasGroup'theGroup t) = (Capnp.Gen.ById.Xb6421fb8e478d144.HasGroup'theGroup (Classes.Cerial msg t) msg)
-    decerialize raw = (HasGroup'theGroup' <$> ((Capnp.Gen.ById.Xb6421fb8e478d144.get_HasGroup'theGroup'value raw) >>= Classes.decerialize))
-instance ((Classes.Decerialize t)
-         ,(Classes.FromPtr Message.Const (Classes.Cerial Message.Const t))
-         ,(Classes.Cerialize s t)
-         ,(Classes.ToPtr s (Classes.Cerial (Message.Mut s) t))) => (Classes.Marshal s (HasGroup'theGroup t)) where
-    marshalInto raw_ value_ = case value_ of
-        HasGroup'theGroup'{..} ->
-            (do
-                ((Classes.cerialize (Untyped.message raw_) value) >>= (Capnp.Gen.ById.Xb6421fb8e478d144.set_HasGroup'theGroup'value raw_))
-                (Std_.pure ())
-                )
diff --git a/lib/Capnp.hs b/lib/Capnp.hs
deleted file mode 100644
--- a/lib/Capnp.hs
+++ /dev/null
@@ -1,90 +0,0 @@
-{- |
-Module: Capnp
-Description: The most commonly used functionality in the capnp package.
-
-This module re-exports the most commonly used functionality from other modules in the
-library.
-
-Users getting acquainted with the library are *strongly* encouraged to read the
-"Capnp.Tutorial" module before anything else.
--}
-module Capnp
-    (
-    -- * Working with capnproto lists
-      Classes.ListElem(..)
-    , Classes.MutListElem(..)
-
-    -- * Working with capnproto Text and Data values.
-    , Basics.Data
-    , Basics.dataBytes
-    , Basics.Text
-    , Basics.textBytes
-
-    -- * Working with messages
-    , Message.Message
-    , Message.Segment
-    , Message.Mutability(..)
-    , Message.MonadReadMessage(..)
-    , Message.newMessage
-    , Message.fromByteString
-    , Message.toByteString
-
-    -- * Canonicalizing messages
-    , canonicalize
-
-    -- * Manipulating the root object of a message
-    , Codec.getRoot
-    , Codec.newRoot
-    , Codec.setRoot
-
-    -- * Marshalling data into and out of messages
-    , Classes.Decerialize(..)
-    , Classes.Cerialize(..)
-
-    -- * IO
-    , module Capnp.IO
-
-    -- * Type aliases for common contexts
-    , Message.WriteCtx
-    , Untyped.ReadCtx
-    , Untyped.RWCtx
-    , Classes.ReadParam
-    , Classes.WriteParam
-
-    -- * Converting between messages, Cap'N Proto values, and raw bytes
-    , module Capnp.Convert
-
-    -- * Managing resource limits
-    , module Capnp.TraversalLimit
-
-    -- * Freezing and thawing values
-    , module Data.Mutable
-
-    -- * Building messages in pure code
-    , PureBuilder
-    , createPure
-
-    -- * Re-exported from "Data.Default", for convienence.
-    , def
-    ) where
-
-import Data.Default (def)
-
-import Capnp.Convert
-import Capnp.IO
-import Capnp.TraversalLimit
-import Data.Mutable
-
-import Capnp.Canonicalize (canonicalize)
-import Internal.BuildPure (PureBuilder, createPure)
-
-import qualified Capnp.Basics  as Basics
-import qualified Capnp.Classes as Classes
-import qualified Capnp.Message as Message
-import qualified Capnp.Untyped as Untyped
-import qualified Codec.Capnp   as Codec
-
-
-
--- Just for instances:
-import Capnp.Basics.Pure ()
diff --git a/lib/Capnp/Basics.hs b/lib/Capnp/Basics.hs
deleted file mode 100644
--- a/lib/Capnp/Basics.hs
+++ /dev/null
@@ -1,180 +0,0 @@
-{-|
-Module: Capnp.Basics
-Description: Handling of "basic" capnp datatypes.
-
-In particular
-
-* 'Text' and 'Data' (which are primitive types in the schema language,
-  but are both the same as @List(UInt8)@ on the wire).
-* Lists of types other than those in "Capnp.Untyped".
-  Whereas 'U.ListOf' only deals with low-level encodings of lists,
-  this module's 'List' type can represent typed lists.
--}
-{-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE FlexibleInstances     #-}
-{-# LANGUAGE GADTs                 #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies          #-}
-module Capnp.Basics
-    ( Text
-    , Data(..)
-    , ListElem(..)
-    , MutListElem(..)
-    , getData
-    , getText
-    , newData
-    , newText
-    , dataBytes
-    , textBuffer
-    , textBytes
-    ) where
-
-import Data.Word
-
-import Control.Monad       (when, (>=>))
-import Control.Monad.Catch (MonadThrow(throwM))
-
-import qualified Data.ByteString as BS
-
-import Capnp.Classes
-    (FromPtr (..), ListElem (..), MutListElem (..), ToPtr (..))
-import Capnp.Message          (Mutability (..))
-import Data.Mutable           (Thaw (..))
-import Internal.Gen.Instances ()
-
-import qualified Capnp.Errors  as E
-import qualified Capnp.Message as M
-import qualified Capnp.Untyped as U
-
-
--- | A textual string (@Text@ in capnproto's schema language). On the wire,
--- this is NUL-terminated. The encoding should be UTF-8, but the library
--- /does not/ verify this; users of the library must do validation themselves, if
--- they care about this.
---
--- Rationale: validation would require doing an up-front pass over the data,
--- which runs counter to the overall design of capnproto.
-newtype Text mut = Text (U.ListOf mut Word8)
--- The argument to the data constructor is the slice of the original message
--- containing the text, including the NUL terminator.
-
-instance Thaw (Text 'Const) where
-    type Mutable s (Text 'Const) = Text ('Mut s)
-    thaw (Text l) = Text <$> thaw l
-    unsafeThaw (Text l) = Text <$> unsafeThaw l
-    freeze (Text l) = Text <$> freeze l
-    unsafeFreeze (Text l) = Text <$> unsafeFreeze l
-
--- | A blob of bytes (@Data@ in capnproto's schema language). The argument
--- to the data constructor is a slice into the message, containing the raw
--- bytes.
-newtype Data mut = Data (U.ListOf mut Word8)
-
-instance Thaw (Data 'Const) where
-    type Mutable s (Data 'Const) = Data ('Mut s)
-    thaw (Data l) = Data <$> thaw l
-    unsafeThaw (Data l) = Data <$> unsafeThaw l
-    freeze (Data l) = Data <$> freeze l
-    unsafeFreeze (Data l) = Data <$> unsafeFreeze l
-
--- | @'newData' msg len@ allocates a new data blob of length @len@ bytes
--- inside the message.
-newData :: M.WriteCtx m s => M.Message ('Mut s) -> Int -> m (Data ('Mut s))
-newData msg len = Data <$> U.allocList8 msg len
-
--- | Interpret a list of 'Word8' as a capnproto 'Data' value.
-getData :: U.ReadCtx m mut => U.ListOf mut Word8 -> m (Data mut)
-getData = pure . Data
-
--- | @'newText' msg len@ Allocates a new 'Text' inside the message. The
--- value has space for @len@ *bytes* (not characters).
-newText :: M.WriteCtx m s => M.Message ('Mut s) -> Int -> m (Text ('Mut s))
-newText msg len =
-    Text <$> U.allocList8 msg (len+1)
-
--- | Interpret a list of 'Word8' as a capnproto 'Text' value.
---
--- This vaildates that the list is NUL-terminated, but not that it is valid
--- UTF-8. If it is not NUL-terminaed, a 'SchemaViolationError' is thrown.
-getText :: U.ReadCtx m mut => U.ListOf mut Word8 -> m (Text mut)
-getText list = do
-    let len = U.length list
-    when (len == 0) $ throwM $ E.SchemaViolationError
-        "Text is not NUL-terminated (list of bytes has length 0)"
-    lastByte <- U.index (len - 1) list
-    when (lastByte /= 0) $ throwM $ E.SchemaViolationError $
-        "Text is not NUL-terminated (last byte is " ++ show lastByte ++ ")"
-    pure $ Text list
-
--- | Convert a 'Data' to a 'BS.ByteString'.
-dataBytes :: U.ReadCtx m 'Const => Data 'Const -> m BS.ByteString
-dataBytes (Data list) = U.rawBytes list
-
--- | Return the underlying buffer containing the text. This does not include the
--- null terminator.
-textBuffer :: U.ReadCtx m mut => Text mut -> m (U.ListOf mut Word8)
-textBuffer (Text list) = U.take (U.length list - 1) list
-
--- | Convert a 'Text' to a 'BS.ByteString', comprising the raw bytes of the text
--- (not counting the NUL terminator).
-textBytes :: U.ReadCtx m 'Const => Text 'Const -> m BS.ByteString
-textBytes = textBuffer >=> U.rawBytes
-
-------------------- (Mut)ListElem instances for text and data ------------------
-
-instance ListElem mut (Data mut) where
-    newtype List mut (Data mut) = DataList (U.ListOf mut (Maybe (U.Ptr mut)))
-
-    listFromPtr msg ptr = DataList <$> fromPtr msg ptr
-    toUntypedList (DataList l) = U.ListPtr l
-
-    length (DataList l) = U.length l
-    index i (DataList l) = ptrListIndex i l
-
-instance MutListElem s (Data ('Mut s)) where
-    setIndex (Data e) i (DataList l) =
-        U.setIndex (Just (U.PtrList (U.List8 e))) i l
-    newList msg len = DataList <$> U.allocListPtr msg len
-
-instance ListElem mut (Text mut) where
-    newtype List mut (Text mut) = TextList (U.ListOf mut (Maybe (U.Ptr mut)))
-
-    listFromPtr msg ptr = TextList <$> fromPtr msg ptr
-    toUntypedList (TextList l) = U.ListPtr l
-
-    length (TextList l) = U.length l
-    index i (TextList l) = ptrListIndex i l
-
-instance MutListElem s (Text ('Mut s)) where
-    setIndex (Text e) i (TextList l) =
-        U.setIndex (Just (U.PtrList (U.List8 e))) i l
-    newList msg len = TextList <$> U.allocListPtr msg len
-
--- helper for the above instances.
-ptrListIndex
-    :: (U.ReadCtx m mut, FromPtr mut a)
-    => Int -> U.ListOf mut (Maybe (U.Ptr mut)) -> m a
-ptrListIndex i list = do
-    ptr <- U.index i list
-    fromPtr (U.message list) ptr
-
---------- To/FromPtr instances for Text and Data. These wrap lists of bytes. --------
-
-instance FromPtr mut (Data mut) where
-    fromPtr msg ptr = fromPtr msg ptr >>= getData
-instance ToPtr s (Data ('Mut s)) where
-    toPtr msg (Data l) = toPtr msg l
-
-instance FromPtr mut (Text mut) where
-    fromPtr msg ptr = case ptr of
-        Just _ ->
-            fromPtr msg ptr >>= getText
-        Nothing -> do
-            -- getText expects and strips off a NUL byte at the end of the
-            -- string. In the case of a null pointer we just want to return
-            -- the empty string, so we bypass it here.
-            Data bytes <- fromPtr msg ptr
-            pure $ Text bytes
-instance ToPtr s (Text ('Mut s)) where
-    toPtr msg (Text l) = toPtr msg l
diff --git a/lib/Capnp/Basics/Pure.hs b/lib/Capnp/Basics/Pure.hs
deleted file mode 100644
--- a/lib/Capnp/Basics/Pure.hs
+++ /dev/null
@@ -1,96 +0,0 @@
-{-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE FlexibleInstances     #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies          #-}
-{-# LANGUAGE UndecidableInstances  #-}
-{- |
-Module: Capnp.Basics.Pure
-Description: Handling of "basic" capnp datatypes (high-level API).
-
-Analogous to 'Capnp.Basics' in the low-level API, this module deals
-with capnproto's @Text@ and @Data@ types. These are simply aliases for
-'BS.ByteString' and the text package's 'T.Text'; mostly this module provides
-helper functions and type class instances.
-
-Unlike with the low-level API, typed lists do not require special
-treatment -- they're just Vectors.
--}
-module Capnp.Basics.Pure
-    ( Data
-    , Text
-    ) where
-
-import Prelude hiding (length)
-
-import Control.Monad       (forM_)
-import Control.Monad.Catch (MonadThrow(throwM))
-import Data.Text.Encoding  (decodeUtf8', encodeUtf8)
-
-import qualified Data.ByteString as BS
-import qualified Data.Text       as T
-import qualified Data.Vector     as V
-
-import Capnp.Classes
-
-import Capnp.Errors  (Error(InvalidUtf8Error))
-import Capnp.Message (Mutability(..))
-import Capnp.Untyped (rawBytes)
-
-import qualified Capnp.Basics  as Basics
-import qualified Capnp.Untyped as Untyped
-
--- | A capnproto @Data@ value. This is just an alias for 'BS.ByteString'.
-type Data = BS.ByteString
-
--- | A capnproto @Text@. This  is just an alias for the text package's 'T.Text'.
-type Text = T.Text
-
-instance Decerialize Data where
-    type Cerial msg Data = Basics.Data msg
-    decerialize (Basics.Data list) = rawBytes list
-
-instance Marshal s Data where
-    marshalInto (Basics.Data list) bytes =
-        forM_ [0..BS.length bytes - 1] $ \i ->
-            Untyped.setIndex (BS.index bytes i) i list
-
-instance Cerialize s Data where
-    cerialize msg bytes = do
-        dest <- Basics.newData msg (BS.length bytes)
-        marshalInto dest bytes
-        pure dest
-
-instance Decerialize Text where
-    type Cerial msg Text = Basics.Text msg
-    decerialize text = do
-            bytes <- Basics.textBytes text
-            case decodeUtf8' bytes of
-                Left e    -> throwM $ InvalidUtf8Error e
-                Right txt -> pure txt
-
-instance Marshal s Text where
-    marshalInto dest text = marshalTextBytes (encodeUtf8 text) dest
-
-instance Cerialize s Text where
-    cerialize msg text = do
-        let bytes = encodeUtf8 text
-        ret <- Basics.newText msg (BS.length bytes)
-        marshalTextBytes bytes ret
-        pure ret
-
-marshalTextBytes :: Untyped.RWCtx m s => BS.ByteString -> Basics.Text ('Mut s) -> m ()
-marshalTextBytes bytes text = do
-    buffer <- Basics.textBuffer text
-    marshalInto (Basics.Data buffer) bytes
-
-instance Cerialize s (V.Vector Text) where cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector Data) where cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector Text)) where cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector Data)) where cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector Text))) where cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector Data))) where cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Text)))) where cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector Data)))) where cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Text))))) where cerialize = cerializeBasicVec
-instance Cerialize s (V.Vector (V.Vector (V.Vector (V.Vector (V.Vector Data))))) where cerialize = cerializeBasicVec
diff --git a/lib/Capnp/Classes.hs b/lib/Capnp/Classes.hs
deleted file mode 100644
--- a/lib/Capnp/Classes.hs
+++ /dev/null
@@ -1,392 +0,0 @@
-{-# LANGUAGE ConstraintKinds        #-}
-{-# LANGUAGE DataKinds              #-}
-{-# LANGUAGE DefaultSignatures      #-}
-{-# LANGUAGE FlexibleContexts       #-}
-{-# LANGUAGE FlexibleInstances      #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE TypeFamilies           #-}
-{-# LANGUAGE UndecidableInstances   #-}
-{- |
-Module: Capnp.Classes
-Description: Misc. type classes
-
-This module defines several type classes concerning encoding and decoding
-values in the capnproto wire format (as well as instances for some basic
-types).
-
-Note that much of this is unlikely to be used directly by developers.
-Typically these are either used internally by generated code, or
-transitively via higher level functions in the API. It is recommended
-to look elsewhere in the library for what you need, and refer to this
-module only when trying to understand what the class constraints on a
-function mean.
--}
-module Capnp.Classes
-    ( IsWord(..)
-    , ListElem(..)
-    , MutListElem(..)
-    , FromPtr(..)
-    , ToPtr(..)
-    , FromStruct(..)
-    , ToStruct(..)
-    , Allocate(..)
-    , Marshal(..)
-    , Cerialize(..)
-    , Decerialize(..)
-    , cerializeBasicVec
-    , cerializeCompositeVec
-    , ReadParam
-    , WriteParam
-    ) where
-
-import Prelude hiding (length)
-
-import Data.Bits
-import Data.Int
-import Data.Word
-
-import Control.Monad.Catch (MonadThrow(throwM))
-import Data.Foldable       (for_)
-import GHC.Float
-    ( castDoubleToWord64
-    , castFloatToWord32
-    , castWord32ToFloat
-    , castWord64ToDouble
-    )
-
-import Capnp.Bits    (Word1(..))
-import Capnp.Errors  (Error(SchemaViolationError))
-import Capnp.Message (Mutability(..))
-import Capnp.Untyped (Cap, ListOf, Ptr(..), ReadCtx, Struct, messageDefault)
-
-import qualified Capnp.Message as M
-import qualified Capnp.Untyped as U
-
-import qualified Data.Vector as V
-
--- | Type alias for the constraints needed for 'a' to be used as a capnp
--- type parameter for pure modules, when reading.
-type ReadParam a =
-    ( Decerialize a
-    , FromPtr 'Const  (Cerial 'Const a)
-    )
--- | Type alias for the constraints needed for 'a' to be used as a capnp
--- type parameter for pure modules, when writing with state token 's'.
-type WriteParam s a =
-    ( Cerialize s a
-    , ToPtr s (Cerial ('Mut s) a)
-    , FromPtr ('Mut s) (Cerial ('Mut s) a)
-    )
-
--- | Types that can be converted to and from a 64-bit word.
---
--- Anything that goes in the data section of a struct will have
--- an instance of this.
-class IsWord a where
-    -- | Convert from a 64-bit words Truncates the word if the
-    -- type has less than 64 bits.
-    fromWord :: Word64 -> a
-
-    -- | Convert to a 64-bit word.
-    toWord :: a -> Word64
-
--- | Types which may be stored as an element of a capnproto list.
-class ListElem mut e where
-    -- | The type of lists of @e@ stored in messages of type @msg@
-    data List mut e
-
-    -- | Convert an untyped list to a list of this type. May fail
-    -- with a 'SchemaViolationError' if the list does not have the
-    -- correct representation.
-    --
-    -- TODO: this is basically just fromPtr; refactor so this is less
-    -- redundant.
-    listFromPtr :: U.ReadCtx m mut => M.Message mut -> Maybe (U.Ptr mut) -> m (List mut e)
-
-    toUntypedList :: List mut e -> U.List mut
-
-    -- | Get the length of a list.
-    length :: List mut e -> Int
-
-    -- | @'index' i list@ gets the @i@th element of a list.
-    index :: U.ReadCtx m mut => Int -> List mut e -> m e
-
--- | Types which may be stored as an element of a *mutable* capnproto list.
-class (ListElem ('Mut s) e) => MutListElem s e where
-    -- | @'setIndex' value i list@ sets the @i@th index in @list@ to @value@
-    setIndex :: U.RWCtx m s => e -> Int -> List ('Mut s) e -> m ()
-
-    -- | @'newList' msg size@ allocates and returns a new list of length
-    -- @size@ inside @msg@.
-    newList :: M.WriteCtx m s => M.Message ('Mut s) -> Int -> m (List ('Mut s) e)
-
--- | Types which may be stored in a capnproto message, and have a fixed size.
---
--- This applies to typed structs, but not e.g. lists, because the length
--- must be known to allocate a list.
-class Allocate s e | e -> s where
-    -- @'new' msg@ allocates a new value of type @e@ inside @msg@.
-    new :: M.WriteCtx m s => M.Message ('Mut s) -> m e
-
--- | Types which may be extracted from a message.
---
--- typically, instances of 'Decerialize' will be the algebraic data types
--- defined in generated code for the high-level API.
-class Decerialize a where
-    -- | A variation on @a@ which is encoded in the message.
-    --
-    -- For the case of instances in generated high-level API code, this will
-    -- be the low-level API analouge of the type.
-    type Cerial (mut :: Mutability) a
-
-    -- | Extract the value from the message.
-    decerialize :: U.ReadCtx m 'Const => Cerial 'Const a -> m a
-
--- | Types which may be marshaled into a pre-allocated object in a message.
-class Decerialize a => Marshal s a where
-
-    -- | Marshal a value into the pre-allocated object inside the message.
-    --
-    -- Note that caller must arrange for the object to be of the correct size.
-    -- This is is not necessarily guaranteed; for example, list types must
-    -- coordinate the length of the list.
-    marshalInto :: U.RWCtx m s => Cerial ('Mut s) a -> a -> m ()
-
--- | Types which may be inserted into a message.
-class Decerialize a => Cerialize s a where
-
-    -- | Cerialize a value into the supplied message, returning the result.
-    cerialize :: U.RWCtx m s => M.Message ('Mut s) -> a -> m (Cerial ('Mut s) a)
-
-    default cerialize :: (U.RWCtx m s, Marshal s a, Allocate s (Cerial ('Mut s) a))
-        => M.Message ('Mut s) -> a -> m (Cerial ('Mut s) a)
-    cerialize msg value = do
-        raw <- new msg
-        marshalInto raw value
-        pure raw
-
--- | Types that can be converted from an untyped pointer.
---
--- Note that decoding does not have to succeed, if the pointer is
--- the wrong type.
-class FromPtr mut a where
-    -- | Convert an untyped pointer to an @a@.
-    fromPtr :: ReadCtx m mut => M.Message mut -> Maybe (Ptr mut) -> m a
-
--- | Types that can be converted to an untyped pointer.
-class ToPtr s a where
-    -- | Convert an @a@ to an untyped pointer.
-    toPtr :: M.WriteCtx m s => M.Message ('Mut s) -> a -> m (Maybe (Ptr ('Mut s)))
-
--- | Types that can be extracted from a struct.
-class FromStruct mut a | a -> mut where
-    -- | Extract a value from a struct.
-    fromStruct :: ReadCtx m mut => Struct mut -> m a
-
--- | Types that can be converted to a struct.
-class ToStruct mut a | a -> mut where
-    -- | Convert a value to a struct.
-    toStruct :: a -> Struct mut
-
-------- instances -------
-
-instance IsWord Bool where
-    fromWord n = (n .&. 1) == 1
-    toWord True  = 1
-    toWord False = 0
-
-instance IsWord Word1 where
-    fromWord = Word1 . fromWord
-    toWord = toWord . word1ToBool
-
--- IsWord instances for integral types; they're all the same.
-instance IsWord Int8 where
-    fromWord = fromIntegral
-    toWord = fromIntegral
-instance IsWord Int16 where
-    fromWord = fromIntegral
-    toWord = fromIntegral
-instance IsWord Int32 where
-    fromWord = fromIntegral
-    toWord = fromIntegral
-instance IsWord Int64 where
-    fromWord = fromIntegral
-    toWord = fromIntegral
-instance IsWord Word8 where
-    fromWord = fromIntegral
-    toWord = fromIntegral
-instance IsWord Word16 where
-    fromWord = fromIntegral
-    toWord = fromIntegral
-instance IsWord Word32 where
-    fromWord = fromIntegral
-    toWord = fromIntegral
-instance IsWord Word64 where
-    fromWord = fromIntegral
-    toWord = fromIntegral
-
-instance IsWord Float where
-    fromWord = castWord32ToFloat . fromIntegral
-    toWord = fromIntegral . castFloatToWord32
-instance IsWord Double where
-    fromWord = castWord64ToDouble
-    toWord = castDoubleToWord64
-
--- helper function for throwing SchemaViolationError "expected ..."
-expected :: MonadThrow m => String -> m a
-expected msg = throwM $ SchemaViolationError $ "expected " ++ msg
-
--- To/FromPtr instance for lists of Void/().
-instance FromPtr mut (ListOf mut ()) where
-    fromPtr msg Nothing                       = messageDefault msg
-    fromPtr _ (Just (PtrList (U.List0 list))) = pure list
-    fromPtr _ _ = expected "pointer to list with element size 0"
-instance ToPtr s (ListOf ('Mut s) ()) where
-    toPtr _ = pure . Just . PtrList . U.List0
-
--- To/FromPtr instances for lists of unsigned integers.
-instance FromPtr mut (ListOf mut Word8) where
-    fromPtr msg Nothing                       = messageDefault msg
-    fromPtr _ (Just (PtrList (U.List8 list))) = pure list
-    fromPtr _ _ = expected "pointer to list with element size 8"
-instance ToPtr s (ListOf ('Mut s) Word8) where
-    toPtr _ = pure . Just . PtrList . U.List8
-instance FromPtr mut (ListOf mut Word16) where
-    fromPtr msg Nothing                       = messageDefault msg
-    fromPtr _ (Just (PtrList (U.List16 list))) = pure list
-    fromPtr _ _ = expected "pointer to list with element size 16"
-instance ToPtr s (ListOf ('Mut s) Word16) where
-    toPtr _ = pure . Just . PtrList . U.List16
-instance FromPtr mut (ListOf mut Word32) where
-    fromPtr msg Nothing                       = messageDefault msg
-    fromPtr _ (Just (PtrList (U.List32 list))) = pure list
-    fromPtr _ _ = expected "pointer to list with element size 32"
-instance ToPtr s (ListOf ('Mut s) Word32) where
-    toPtr _ = pure . Just . PtrList . U.List32
-instance FromPtr mut (ListOf mut Word64) where
-    fromPtr msg Nothing                        = messageDefault msg
-    fromPtr _ (Just (PtrList (U.List64 list))) = pure list
-    fromPtr _ _ = expected "pointer to list with element size 64"
-instance ToPtr s (ListOf ('Mut s) Word64) where
-    toPtr _ = pure . Just . PtrList . U.List64
-
-instance FromPtr mut (ListOf mut Bool) where
-    fromPtr msg Nothing = messageDefault msg
-    fromPtr _ (Just (PtrList (U.List1 list))) = pure list
-    fromPtr _ _ = expected "pointer to list with element size 1."
-instance ToPtr s (ListOf ('Mut s) Bool) where
-    toPtr _ = pure . Just . PtrList . U.List1
-
--- To/FromPtr instance for pointers -- this is just the identity.
-instance FromPtr mut (Maybe (Ptr mut)) where
-    fromPtr _ = pure
-instance ToPtr s (Maybe (Ptr ('Mut s))) where
-    toPtr _ = pure
-
--- To/FromPtr instance for composite lists.
-instance FromPtr mut (ListOf mut (Struct mut)) where
-    fromPtr msg Nothing                            = messageDefault msg
-    fromPtr _ (Just (PtrList (U.ListStruct list))) = pure list
-    fromPtr _ _ = expected "pointer to list of structs"
-instance ToPtr s (ListOf ('Mut s) (Struct ('Mut s))) where
-    toPtr _ = pure . Just . PtrList . U.ListStruct
-
--- To/FromPtr instance for lists of pointers.
-instance FromPtr mut (ListOf mut (Maybe (Ptr mut))) where
-    fromPtr msg Nothing                         = messageDefault msg
-    fromPtr _ (Just (PtrList (U.ListPtr list))) = pure list
-    fromPtr _ _ = expected "pointer to list of pointers"
-instance ToPtr s (ListOf ('Mut s) (Maybe (Ptr ('Mut s)))) where
-    toPtr _ = pure . Just . PtrList . U.ListPtr
-
--- To/FromPtr instance for *typed* lists.
-instance ListElem mut e => FromPtr mut (List mut e) where
-    fromPtr = listFromPtr
-instance ListElem ('Mut s) e => ToPtr s (List ('Mut s) e) where
-    toPtr _ = pure . Just . PtrList . toUntypedList
-
--- ListElem instance for (typed) nested lists.
-instance ListElem mut e => ListElem mut (List mut e) where
-    newtype List mut (List mut e) = NestedList (U.ListOf mut (Maybe (U.Ptr mut)))
-
-    listFromPtr msg ptr = NestedList <$> fromPtr msg ptr
-    toUntypedList (NestedList l) = U.ListPtr l
-
-    length (NestedList l) = U.length l
-    index i (NestedList l) = do
-        ptr <- U.index i l
-        fromPtr (U.message l) ptr
-
-instance MutListElem s e => MutListElem s (List ('Mut s) e) where
-    setIndex e i (NestedList l) = U.setIndex (Just (U.PtrList (toUntypedList e))) i l
-    newList msg len = NestedList <$> U.allocListPtr msg len
-
--- FromStruct instance for Struct; just the identity.
-instance FromStruct mut (Struct mut) where
-    fromStruct = pure
-
-instance ToStruct mut (Struct mut) where
-    toStruct = id
-
-instance FromPtr mut (Struct mut) where
-    fromPtr msg Nothing            = messageDefault msg >>= fromStruct
-    fromPtr _ (Just (PtrStruct s)) = fromStruct s
-    fromPtr _ _                    = expected "pointer to struct"
-instance ToPtr s (Struct ('Mut s)) where
-    toPtr _ = pure . Just . PtrStruct
-
-instance FromPtr mut (Maybe (Cap mut)) where
-    fromPtr _ Nothing             = pure Nothing
-    fromPtr _ (Just (PtrCap cap)) = pure (Just cap)
-    fromPtr _ _                   = expected "pointer to capability"
-instance ToPtr s (Maybe (Cap ('Mut s))) where
-    toPtr _ = pure . fmap PtrCap
-
--- | A valid implementation of 'cerialize', which just cerializes the
--- elements of a list individually and puts them in the list.
---
--- Note that while this is *correct* for composite lists, it is inefficient,
--- since it will separately allocate the elements and then copy them into
--- the list, doing extra work and leaking space. See 'cerializeCompositeVec'.
-cerializeBasicVec ::
-    ( U.RWCtx m s
-    , MutListElem s (Cerial ('Mut s) a)
-    , Cerialize s a
-    )
-    => M.Message ('Mut s)
-    -> V.Vector a
-    -> m (List ('Mut s) (Cerial ('Mut s) a))
-cerializeBasicVec msg vec = do
-    list <- newList msg (V.length vec)
-    for_ [0..V.length vec - 1] $ \i -> do
-        e <- cerialize msg (vec V.! i)
-        setIndex e i list
-    pure list
-
--- | A valid implementation of 'cerialize', which allocates a list of the
--- correct size and then marshals the elements of a vector into the elements
--- of the list. This is more efficient for composite types than
--- 'cerializeBasicVec', hence the name.
-cerializeCompositeVec ::
-    ( U.RWCtx m s
-    , MutListElem s (Cerial ('Mut s) a)
-    , Marshal s a
-    )
-    => M.Message ('Mut s)
-    -> V.Vector a
-    -> m (List ('Mut s) (Cerial ('Mut s) a))
-cerializeCompositeVec msg vec = do
-    list <- newList msg (V.length vec)
-    for_ [0..V.length vec - 1] $ \i -> do
-        targ <- index i list
-        marshalInto targ (vec V.! i)
-    pure list
-
--- Generic decerialize instances for lists, given that the element type has an instance.
-instance
-    ( ListElem 'Const (Cerial 'Const a)
-    , Decerialize a
-    ) => Decerialize (V.Vector a)
-  where
-    type Cerial mut (V.Vector a) = List mut (Cerial mut a)
-    decerialize raw = V.generateM (length raw) (\i -> index i raw >>= decerialize)
diff --git a/lib/Capnp/Convert.hs b/lib/Capnp/Convert.hs
--- a/lib/Capnp/Convert.hs
+++ b/lib/Capnp/Convert.hs
@@ -20,15 +20,8 @@
     ( msgToBuilder
     , msgToLBS
     , msgToBS
-    , msgToValue
     , bsToMsg
-    , bsToValue
     , lbsToMsg
-    , lbsToValue
-    , valueToBuilder
-    , valueToBS
-    , valueToLBS
-    , valueToMsg
 
     -- new API
     , msgToRaw
@@ -44,27 +37,23 @@
     , parsedToLBS
     ) where
 
-import Control.Monad       ((>=>))
 import Control.Monad.Catch (MonadThrow)
-import Data.Foldable       (foldlM)
 
 import qualified Data.ByteString         as BS
 import qualified Data.ByteString.Builder as BB
 import qualified Data.ByteString.Lazy    as LBS
 
-import Capnp.Classes
-
-import Capnp.Bits           (WordCount)
-import Capnp.Message        (Mutability(..))
-import Capnp.New.Classes    (Parse(encode, parse))
-import Capnp.TraversalLimit (LimitT, MonadLimit, evalLimitT)
-import Codec.Capnp          (getRoot, setRoot)
-import Data.Mutable         (freeze)
+import Capnp.Message     (Mutability(..))
+import Capnp.New.Classes (Parse(encode, parse))
+import Data.Mutable      (freeze)
 
 import qualified Capnp.Message as M
 import qualified Capnp.Repr    as R
 import qualified Capnp.Untyped as U
 
+{- TODO: unused currently, but we should put it back into service for things like
+   msgToParsed.
+
 -- | Compute a reasonable limit based on the size of a message. The limit
 -- is the total number of words in all of the message's segments, multiplied
 -- by 10 to provide some slack for decoding default values.
@@ -82,6 +71,7 @@
             )
             0
             [0..segCount - 1]
+-}
 
 -- | Convert an immutable message to a bytestring 'BB.Builder'.
 -- To convert a mutable message, 'freeze' it first.
@@ -98,48 +88,14 @@
 msgToBS :: M.Message 'Const -> BS.ByteString
 msgToBS = LBS.toStrict . msgToLBS
 
--- | Convert a message to a value.
-msgToValue :: (MonadThrow m, M.MonadReadMessage mut (LimitT m), M.MonadReadMessage mut m, FromStruct mut a) => M.Message mut -> m a
-msgToValue msg = do
-    limit <- limitFromMsg msg
-    evalLimitT limit (getRoot msg)
-
 -- | Convert a strict 'BS.ByteString' to a message.
 bsToMsg :: MonadThrow m => BS.ByteString -> m (M.Message 'Const)
 bsToMsg = M.decode
 
--- | Convert a strict 'BS.ByteString' to a value.
-bsToValue :: (MonadThrow m, FromStruct 'Const a) => BS.ByteString -> m a
-bsToValue = bsToMsg >=> msgToValue
-
 -- | Convert a lazy 'LBS.ByteString' to a message.
 lbsToMsg :: MonadThrow m => LBS.ByteString -> m (M.Message 'Const)
 lbsToMsg = bsToMsg . LBS.toStrict
 
--- | Convert a lazy 'LBS.ByteString' to a value.
-lbsToValue :: (MonadThrow m, FromStruct 'Const a) => LBS.ByteString -> m a
-lbsToValue = bsToValue . LBS.toStrict
-
--- | Convert a value to a 'BS.Builder'.
-valueToBuilder :: (MonadLimit m, M.WriteCtx m s, Cerialize s a, ToStruct ('Mut s) (Cerial ('Mut s) a)) => a -> m BB.Builder
-valueToBuilder val = msgToBuilder <$> (valueToMsg val >>= freeze)
-
--- | Convert a value to a strict 'BS.ByteString'.
-valueToBS :: (MonadLimit m, M.WriteCtx m s, Cerialize s a, ToStruct ('Mut s) (Cerial ('Mut s) a)) => a -> m BS.ByteString
-valueToBS = fmap LBS.toStrict . valueToLBS
-
--- | Convert a value to a lazy 'LBS.ByteString'.
-valueToLBS :: (MonadLimit m, M.WriteCtx m s, Cerialize s a, ToStruct ('Mut s) (Cerial ('Mut s) a)) => a -> m LBS.ByteString
-valueToLBS = fmap BB.toLazyByteString . valueToBuilder
-
--- | Convert a value to a message.
-valueToMsg :: (MonadLimit m, M.WriteCtx m s, Cerialize s a, ToStruct ('Mut s) (Cerial ('Mut s) a)) => a -> m (M.Message ('Mut s))
-valueToMsg val = do
-    msg <- M.newMessage Nothing
-    ret <- cerialize msg val
-    setRoot ret
-    pure msg
-
 -- | Get the root pointer of a message, wrapped as a 'R.Raw'.
 msgToRaw :: forall a m mut. (U.ReadCtx m mut, R.IsStruct a) => M.Message mut -> m (R.Raw mut a)
 msgToRaw = fmap R.Raw . U.rootPtr
@@ -149,19 +105,19 @@
 msgToParsed msg = msgToRaw msg >>= parse
 
 -- | Like 'msgToRaw', but takes a (strict) bytestring.
-bsToRaw :: (U.ReadCtx m 'Const, R.IsStruct a) => BS.ByteString -> m (R.Raw 'Const a)
+bsToRaw :: forall a m. (U.ReadCtx m 'Const, R.IsStruct a) => BS.ByteString -> m (R.Raw 'Const a)
 bsToRaw bs = bsToMsg bs >>= msgToRaw
 
 -- | Like 'msgToParsed', but takes a (strict) bytestring.
-bsToParsed :: (U.ReadCtx m 'Const, R.IsStruct a, Parse a pa) => BS.ByteString -> m pa
+bsToParsed :: forall a pa m. (U.ReadCtx m 'Const, R.IsStruct a, Parse a pa) => BS.ByteString -> m pa
 bsToParsed bs = bsToRaw bs >>= parse
 
 -- | Like 'msgToRaw', but takes a (lazy) bytestring.
-lbsToRaw :: (U.ReadCtx m 'Const, R.IsStruct a) => LBS.ByteString -> m (R.Raw 'Const a)
+lbsToRaw :: forall a m. (U.ReadCtx m 'Const, R.IsStruct a) => LBS.ByteString -> m (R.Raw 'Const a)
 lbsToRaw = bsToRaw . LBS.toStrict
 
 -- | Like 'msgToParsed', but takes a (lazzy) bytestring.
-lbsToParsed :: (U.ReadCtx m 'Const, R.IsStruct a, Parse a pa) => LBS.ByteString -> m pa
+lbsToParsed :: forall a pa m. (U.ReadCtx m 'Const, R.IsStruct a, Parse a pa) => LBS.ByteString -> m pa
 lbsToParsed = bsToParsed . LBS.toStrict
 
 -- | Serialize the parsed form of a struct into its 'R.Raw' form, and make it the root
diff --git a/lib/Capnp/Fields.hs b/lib/Capnp/Fields.hs
--- a/lib/Capnp/Fields.hs
+++ b/lib/Capnp/Fields.hs
@@ -28,7 +28,6 @@
 import GHC.OverloadedLabels (IsLabel(..))
 import GHC.TypeLits         (Symbol)
 
-import qualified Capnp.Classes     as C
 import qualified Capnp.Message     as M
 import qualified Capnp.New.Classes as NC
 import qualified Capnp.Repr        as R
@@ -57,7 +56,7 @@
 data FieldLoc (k :: FieldKind) (r :: R.Repr) where
     GroupField :: FieldLoc 'Group ('R.Ptr ('Just 'R.Struct))
     PtrField :: R.IsPtrRepr a => Word16 -> FieldLoc 'Slot ('R.Ptr a)
-    DataField :: C.IsWord (R.UntypedData a) => DataFieldLoc a -> FieldLoc 'Slot ('R.Data a)
+    DataField :: NC.IsWord (R.UntypedData a) => DataFieldLoc a -> FieldLoc 'Slot ('R.Data a)
     VoidField :: FieldLoc 'Slot ('R.Data 'R.Sz0)
 
 -- | The location of a data (non-pointer) field.
diff --git a/lib/Capnp/GenHelpers.hs b/lib/Capnp/GenHelpers.hs
deleted file mode 100644
--- a/lib/Capnp/GenHelpers.hs
+++ /dev/null
@@ -1,77 +0,0 @@
-{- |
-Module: Capnp.GenHelpers
-Description: Misc. helpers for generated code.
-
-This module provides various helpers used by generated code; developers
-are not expected to invoke them directly.
-
-These helpers are used by the low-level api. "Capnp.GenHelpers.Pure"
-defines helpers used by high-level api.
--}
-{-# LANGUAGE DataKinds        #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE TypeFamilies     #-}
-module Capnp.GenHelpers where
-
-import Data.Bits
-import Data.Word
-
-import Data.Maybe (fromJust)
-
-import qualified Data.ByteString as BS
-
-import Capnp.Bits
-
-import Capnp (Mutability (..), bsToMsg, evalLimitT)
-
-import qualified Capnp.Classes as C
-import qualified Capnp.Message as M
-import qualified Capnp.Untyped as U
-
--- | @'getWordField' struct index offset def@ fetches a field from the
--- struct's data section. @index@ is the index of the 64-bit word in the data
--- section in which the field resides. @offset@ is the offset in bits from the
--- start of that word to the field. @def@ is the default value for this field.
-getWordField :: (U.ReadCtx m mut, C.IsWord a) => U.Struct mut -> Int -> Int -> Word64 -> m a
-getWordField struct idx offset def = fmap
-    ( C.fromWord
-    . xor def
-    . (`shiftR` offset)
-    )
-    (U.getData idx struct)
-
--- | @'setWordField' struct value index offset def@ sets a field in the
--- struct's data section. The meaning of the parameters are as in
--- 'getWordField', with @value@ being the value to set. The width of the
--- value is inferred from its type.
-setWordField ::
-    ( U.RWCtx m s
-    , Bounded a, Integral a, C.IsWord a, Bits a
-    )
-    => U.Struct ('Mut s) -> a -> Int -> Int -> Word64 -> m ()
-setWordField struct value idx offset def = do
-    old <- U.getData idx struct
-    let new = replaceBits (value `xor` C.fromWord def) old offset
-    U.setData new idx struct
-
-embedCapPtr :: M.WriteCtx m s => M.Message ('Mut s) -> M.Client -> m (Maybe (U.Ptr ('Mut s)))
-embedCapPtr msg client =
-    Just . U.PtrCap <$> U.appendCap msg client
-
--- | Get a pointer from a ByteString, where the root object is a struct with
--- one pointer, which is the pointer we will retrieve. This is only safe for
--- trusted inputs; it reads the message with a traversal limit of 'maxBound'
--- (and so is suseptable to denial of service attacks), and it calls 'error'
--- if decoding is not successful.
---
--- The purpose of this is for defining constants of pointer type from a schema.
-getPtrConst :: C.FromPtr 'Const a => BS.ByteString -> a
-getPtrConst bytes = fromJust $ do
-    msg <- bsToMsg bytes
-    evalLimitT maxBound $ U.rootPtr msg >>= U.getPtr 0 >>= C.fromPtr msg
-
-
-getTag :: U.ReadCtx m mut => U.Struct mut -> Int -> m Word16
-getTag struct offset = do
-    word <- U.getData (offset `div` 4) struct
-    pure $ fromIntegral $ word `shiftR` ((offset `mod` 4) * 16)
diff --git a/lib/Capnp/GenHelpers/New.hs b/lib/Capnp/GenHelpers/New.hs
--- a/lib/Capnp/GenHelpers/New.hs
+++ b/lib/Capnp/GenHelpers/New.hs
@@ -15,23 +15,12 @@
     , Mutability(..)
     , TypeParam
     , newStruct
-    , parseField
-    , encodeField
-    , encodeVariant
-    , initVariant
-    , unionWhich
-    , readField
-    , structUnion
-    , unionStruct
     , parseEnum
     , encodeEnum
-    , parseCap
-    , encodeCap
     , getPtrConst
+    , BS.ByteString
     , module F
-    , module Capnp.Repr.Methods
-    , module Capnp.New.Rpc.Server
-    , buildCallHandler
+    , module Capnp.New.Accessors
 
     -- * Re-exports from the standard library.
     , Proxy(..)
@@ -40,38 +29,28 @@
 
 
 import           Capnp.Bits
-import qualified Capnp.Classes        as C
-import           Capnp.Fields         as F
-import           Capnp.GenHelpers     (getPtrConst)
-import           Capnp.Message        (Mutability(..))
-import qualified Capnp.Message        as M
-import           Capnp.New
-    ( TypeParam
-    , encodeField
-    , encodeVariant
-    , initVariant
-    , parseField
-    , readField
-    , structUnion
-    , unionStruct
-    , unionWhich
-    )
-import qualified Capnp.New.Basics     as NB
-import qualified Capnp.New.Classes    as NC
-import           Capnp.New.Rpc.Server
-import qualified Capnp.Repr           as R
-import           Capnp.Repr.Methods
-import qualified Capnp.Untyped        as U
+import           Capnp.Convert         (bsToRaw)
+import           Capnp.Fields          as F
+import           Capnp.Message         (Mutability(..))
+import qualified Capnp.Message         as M
+import           Capnp.New.Accessors
+import qualified Capnp.New.Basics      as NB
+import qualified Capnp.New.Classes     as NC
+import           Capnp.New.Constraints (TypeParam)
+import qualified Capnp.Repr            as R
+import           Capnp.TraversalLimit  (evalLimitT)
+import qualified Capnp.Untyped         as U
 import           Data.Bits
-import qualified Data.Map.Strict      as M
-import           Data.Proxy           (Proxy(..))
-import qualified Data.Vector          as V
+import qualified Data.ByteString       as BS
+import           Data.Functor          ((<&>))
+import           Data.Maybe            (fromJust)
+import           Data.Proxy            (Proxy(..))
 import           Data.Word
 
 dataField
     :: forall b a sz.
     ( R.ReprFor b ~ 'R.Data sz
-    , C.IsWord (R.UntypedData sz)
+    , NC.IsWord (R.UntypedData sz)
     )
     => BitCount -> Word16 -> BitCount -> Word64 -> F.Field 'F.Slot a b
 dataField shift index nbits defaultValue = F.Field $ F.DataField @sz F.DataFieldLoc
@@ -112,12 +91,16 @@
     => M.Message ('Mut s) -> a -> m (R.Raw ('Mut s) a)
 encodeEnum _msg value = pure $ R.Raw $ fromIntegral $ fromEnum @a value
 
-parseCap :: (R.IsCap a, U.ReadCtx m 'Const) => R.Raw 'Const a -> m (Client a)
-parseCap (R.Raw cap) = Client <$> U.getClient cap
-
-encodeCap :: (R.IsCap a, U.RWCtx m s) => M.Message ('Mut s) -> Client a -> m (R.Raw ('Mut s) a)
-encodeCap msg (Client c) = R.Raw <$> U.appendCap msg c
-
-
-buildCallHandler :: [(Word64, [UntypedMethodHandler])] -> CallHandler
-buildCallHandler hs = M.fromList [ (k, V.fromList v) | (k, v) <- hs ]
+-- | Get a pointer from a ByteString, where the root object is a struct with
+-- one pointer, which is the pointer we will retrieve. This is only safe for
+-- trusted inputs; it reads the message with a traversal limit of 'maxBound'
+-- (and so is suseptable to denial of service attacks), and it calls 'error'
+-- if decoding is not successful.
+--
+-- The purpose of this is for defining constants of pointer type from a schema.
+getPtrConst :: forall a. R.IsPtr a => BS.ByteString -> R.Raw 'Const a
+getPtrConst bytes = fromJust $ evalLimitT maxBound $ do
+    R.Raw root <- bsToRaw @NB.AnyStruct bytes
+    U.getPtr 0 root
+        >>= R.fromPtr @(R.PtrReprFor (R.ReprFor a)) (U.message root)
+        <&> R.Raw
diff --git a/lib/Capnp/GenHelpers/New/Rpc.hs b/lib/Capnp/GenHelpers/New/Rpc.hs
new file mode 100644
--- /dev/null
+++ b/lib/Capnp/GenHelpers/New/Rpc.hs
@@ -0,0 +1,22 @@
+{-# LANGUAGE DataKinds        #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE TypeFamilies     #-}
+module Capnp.GenHelpers.New.Rpc
+    ( module Capnp.New.Rpc.Server
+    , module Capnp.Repr.Methods
+    , parseCap
+    , encodeCap
+    ) where
+
+import           Capnp.Message        (Mutability(..))
+import qualified Capnp.Message        as M
+import           Capnp.New.Rpc.Server
+import qualified Capnp.Repr           as R
+import           Capnp.Repr.Methods
+import qualified Capnp.Untyped        as U
+
+parseCap :: (R.IsCap a, U.ReadCtx m 'Const) => R.Raw 'Const a -> m (Client a)
+parseCap (R.Raw cap) = Client <$> U.getClient cap
+
+encodeCap :: (R.IsCap a, U.RWCtx m s) => M.Message ('Mut s) -> Client a -> m (R.Raw ('Mut s) a)
+encodeCap msg (Client c) = R.Raw <$> U.appendCap msg c
diff --git a/lib/Capnp/GenHelpers/Pure.hs b/lib/Capnp/GenHelpers/Pure.hs
deleted file mode 100644
--- a/lib/Capnp/GenHelpers/Pure.hs
+++ /dev/null
@@ -1,65 +0,0 @@
-{-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE FlexibleInstances     #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE ScopedTypeVariables   #-}
-{-# LANGUAGE TypeFamilies          #-}
-{- |
-Module: Capnp.GenHelpers.Pure
-Description: Misc. helpers for generated code.
-
-This module provides various helpers used by generated code; developers
-are not expected to invoke them directly.
-
-These helpers are only used by the high-level api. "Capnp.GenHelpers"
-defines helpers used by the low-level api.
--}
-module Capnp.GenHelpers.Pure
-    ( defaultStruct
-    , convertValue
-    , getRoot
-    , createPure
-    , toPurePtrConst
-    , cerializeBasicVec
-    , cerializeCompositeVec
-    ) where
-
-import Data.Maybe (fromJust)
-
-import Capnp.Classes        (cerializeBasicVec, cerializeCompositeVec)
-import Capnp.Message        (Mutability(..))
-import Capnp.TraversalLimit (evalLimitT)
-import Codec.Capnp          (getRoot)
-
-import Data.Mutable       (freeze)
-import Internal.BuildPure (createPure)
-
-import qualified Capnp.Classes as C
-import qualified Capnp.Convert as Convert
-import qualified Capnp.Message as M
-import qualified Capnp.Untyped as U
-
--- | A valid implementation for 'Data.Default.Default' for any type that meets
--- the given constraints.
-defaultStruct :: (C.Decerialize a, C.FromStruct 'Const (C.Cerial 'Const a)) => a
-defaultStruct =
-    fromJust $
-    evalLimitT maxBound $
-        U.rootPtr M.empty >>= C.fromStruct >>= C.decerialize
-
-convertValue ::
-    ( U.RWCtx m s
-    , M.MonadReadMessage 'Const m
-    , C.Cerialize s a
-    , C.ToStruct ('Mut s) (C.Cerial ('Mut s) a)
-    , C.Decerialize b
-    , C.FromStruct 'Const (C.Cerial 'Const b)
-    ) => a -> m b
-convertValue from = do
-    constMsg :: M.Message 'Const <- Convert.valueToMsg from >>= freeze
-    Convert.msgToValue constMsg >>= C.decerialize
-
--- | convert a low-level value to a high-level one. This is not safe against
--- malicious or invalid input; it is used for declaring top-level constants.
-toPurePtrConst :: C.Decerialize a => C.Cerial 'Const a -> a
-toPurePtrConst = fromJust . evalLimitT maxBound . C.decerialize
diff --git a/lib/Capnp/GenHelpers/ReExports.hs b/lib/Capnp/GenHelpers/ReExports.hs
deleted file mode 100644
--- a/lib/Capnp/GenHelpers/ReExports.hs
+++ /dev/null
@@ -1,11 +0,0 @@
--- |
--- Module: Capnp.GenHelpers.ReExports
--- Description: Re-exported modules from common libraries.
---
--- This module heirarchy exists so that generated code doesn't have to
--- import anything outside of base and the capnp package; the generated
--- code uses modules from several common libraries (bytestring, vector,
--- text...), but we would prefer not to burden developers packaging schema
--- with having to list each of these in their build-depends, so instead
--- we re-export the modules from here.
-module Capnp.GenHelpers.ReExports() where
diff --git a/lib/Capnp/GenHelpers/ReExports/Control/Concurrent/STM.hs b/lib/Capnp/GenHelpers/ReExports/Control/Concurrent/STM.hs
deleted file mode 100644
--- a/lib/Capnp/GenHelpers/ReExports/Control/Concurrent/STM.hs
+++ /dev/null
@@ -1,5 +0,0 @@
-module Capnp.GenHelpers.ReExports.Control.Concurrent.STM
-    ( module Control.Concurrent.STM
-    ) where
-
-import Control.Concurrent.STM
diff --git a/lib/Capnp/GenHelpers/ReExports/Control/Monad/STM/Class.hs b/lib/Capnp/GenHelpers/ReExports/Control/Monad/STM/Class.hs
deleted file mode 100644
--- a/lib/Capnp/GenHelpers/ReExports/Control/Monad/STM/Class.hs
+++ /dev/null
@@ -1,5 +0,0 @@
-module Capnp.GenHelpers.ReExports.Control.Monad.STM.Class
-    ( module Control.Monad.STM.Class
-    ) where
-
-import Control.Monad.STM.Class
diff --git a/lib/Capnp/GenHelpers/ReExports/Data/ByteString.hs b/lib/Capnp/GenHelpers/ReExports/Data/ByteString.hs
deleted file mode 100644
--- a/lib/Capnp/GenHelpers/ReExports/Data/ByteString.hs
+++ /dev/null
@@ -1,5 +0,0 @@
-module Capnp.GenHelpers.ReExports.Data.ByteString
-    ( module Data.ByteString
-    ) where
-
-import Data.ByteString
diff --git a/lib/Capnp/GenHelpers/ReExports/Data/Default.hs b/lib/Capnp/GenHelpers/ReExports/Data/Default.hs
deleted file mode 100644
--- a/lib/Capnp/GenHelpers/ReExports/Data/Default.hs
+++ /dev/null
@@ -1,5 +0,0 @@
-module Capnp.GenHelpers.ReExports.Data.Default
-    ( module Data.Default
-    ) where
-
-import Data.Default
diff --git a/lib/Capnp/GenHelpers/ReExports/Data/Text.hs b/lib/Capnp/GenHelpers/ReExports/Data/Text.hs
deleted file mode 100644
--- a/lib/Capnp/GenHelpers/ReExports/Data/Text.hs
+++ /dev/null
@@ -1,5 +0,0 @@
-module Capnp.GenHelpers.ReExports.Data.Text
-    ( module Data.Text
-    ) where
-
-import Data.Text
diff --git a/lib/Capnp/GenHelpers/ReExports/Data/Vector.hs b/lib/Capnp/GenHelpers/ReExports/Data/Vector.hs
deleted file mode 100644
--- a/lib/Capnp/GenHelpers/ReExports/Data/Vector.hs
+++ /dev/null
@@ -1,5 +0,0 @@
-module Capnp.GenHelpers.ReExports.Data.Vector
-    ( module Data.Vector
-    ) where
-
-import Data.Vector
diff --git a/lib/Capnp/GenHelpers/ReExports/Supervisors.hs b/lib/Capnp/GenHelpers/ReExports/Supervisors.hs
deleted file mode 100644
--- a/lib/Capnp/GenHelpers/ReExports/Supervisors.hs
+++ /dev/null
@@ -1,5 +0,0 @@
-module Capnp.GenHelpers.ReExports.Supervisors
-    ( module Supervisors
-    ) where
-
-import Supervisors
diff --git a/lib/Capnp/GenHelpers/Rpc.hs b/lib/Capnp/GenHelpers/Rpc.hs
deleted file mode 100644
--- a/lib/Capnp/GenHelpers/Rpc.hs
+++ /dev/null
@@ -1,64 +0,0 @@
-{-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE OverloadedStrings     #-}
-{-# LANGUAGE TypeFamilies          #-}
--- |
--- Module: Capnp.GenHelpers.Rpc
--- Description: Rpc-system helpers for genrated code.
---
--- This module defines various helpers used by generated code. Users
--- of the library are not expected to use this module directly.
-module Capnp.GenHelpers.Rpc where
-
-import Control.Exception.Safe (fromException, tryAny)
-import Control.Monad.Catch    (MonadThrow(..))
-import Data.Default           (def)
-
-import Capnp.Classes        (Decerialize(..), FromPtr(..))
-import Capnp.Message        (Mutability(..))
-import Capnp.TraversalLimit (evalLimitT)
-
-import qualified Capnp.Errors          as E
-import qualified Capnp.GenHelpers.Pure as PH
-import qualified Capnp.Message         as M
-import qualified Capnp.Rpc.Promise     as Promise
-import qualified Capnp.Rpc.Untyped     as Rpc
-import qualified Capnp.Untyped         as U
-
-handleMethod server method paramContent fulfiller = do
-    ret <- tryAny $ do
-        content <- evalLimitT maxBound $
-            fromPtr M.empty paramContent >>= decerialize
-        results <- method content server
-        evalLimitT maxBound $ PH.convertValue results
-    case ret of
-        Right resultStruct ->
-            Promise.fulfill fulfiller resultStruct
-        Left e ->
-            case fromException e of
-                Just exn ->
-                    Promise.breakPromise fulfiller exn
-                Nothing ->
-                    Promise.breakPromise fulfiller def
-                        { Rpc.type_ = Rpc.Exception'Type'failed
-                        , Rpc.reason = "Method threw an unhandled exception."
-                        }
-
--- | A valid implementation of 'fromPtr' for any type that implements 'IsClient'.
---
--- GHC gets very confused if we try to just define a single instance
--- @IsClient a => FromPtr msg a@, so instead we define this helper function and
--- emit a trivial instance for each type from the code generator.
-isClientFromPtr :: (Rpc.IsClient a, U.ReadCtx m mut) => M.Message mut -> Maybe (U.Ptr mut) -> m a
-isClientFromPtr _ Nothing                     = pure $ Rpc.fromClient Rpc.nullClient
-isClientFromPtr _ (Just (U.PtrCap cap)) = Rpc.fromClient <$> U.getClient cap
-isClientFromPtr _ (Just _) = throwM $ E.SchemaViolationError "Expected capability pointer"
-
--- | A valid implementation of 'toPtr' for any type that implements 'IsClient'.
---
--- See the notes for 'isClientFromPtr'.
-isClientToPtr :: (Rpc.IsClient a, M.WriteCtx m s) => M.Message ('Mut s) -> a -> m (Maybe (U.Ptr ('Mut s)))
-isClientToPtr msg client = do
-    cap <- U.appendCap msg (Rpc.toClient client)
-    pure $ Just $ U.PtrCap cap
diff --git a/lib/Capnp/IO.hs b/lib/Capnp/IO.hs
--- a/lib/Capnp/IO.hs
+++ b/lib/Capnp/IO.hs
@@ -12,13 +12,7 @@
 {-# LANGUAGE TypeApplications    #-}
 {-# LANGUAGE TypeFamilies        #-}
 module Capnp.IO
-    ( hGetValue
-    , getValue
-    , sGetMsg
-    , sGetValue
-    , hPutValue
-    , putValue
-    , sPutValue
+    ( sGetMsg
     , sPutMsg
     , M.hGetMsg
     , M.getMsg
@@ -39,7 +33,6 @@
 import Data.Bits
 
 import Control.Exception         (throwIO)
-import Control.Monad.Primitive   (RealWorld)
 import Control.Monad.Trans.Class (lift)
 import Network.Simple.TCP        (Socket, recv, sendLazy)
 import System.IO                 (Handle, stdin, stdout)
@@ -49,40 +42,15 @@
 import qualified Data.ByteString.Builder as BB
 
 import Capnp.Bits           (WordCount, wordsToBytes)
-import Capnp.Classes
-    (Cerialize(..), Decerialize(..), FromStruct(..), ToStruct(..))
 import Capnp.Convert
-    (msgToLBS, msgToParsed, msgToRaw, parsedToBuilder, parsedToLBS, valueToLBS)
+    (msgToLBS, msgToParsed, msgToRaw, parsedToBuilder, parsedToLBS)
 import Capnp.Message        (Mutability(..))
 import Capnp.New.Classes    (Parse)
 import Capnp.TraversalLimit (evalLimitT)
-import Codec.Capnp          (getRoot, setRoot)
-import Data.Mutable         (Thaw(..))
 
 import qualified Capnp.Message as M
 import qualified Capnp.Repr    as R
 
--- | @'hGetValue' limit handle@ reads a message from @handle@, returning its root object.
--- @limit@ is used as both a cap on the size of a message which may be read and, for types
--- in the high-level API, the traversal limit when decoding the message.
---
--- It may throw a 'Capnp.Errors.Error' if there is a problem decoding the message,
--- or an 'IOError' raised by the underlying IO libraries.
-hGetValue :: FromStruct 'Const a => Handle -> WordCount -> IO a
-hGetValue handle limit = do
-    msg <- M.hGetMsg handle limit
-    evalLimitT limit (getRoot msg)
-
--- | @'getValue'@ is equivalent to @'hGetValue' 'stdin'@.
-getValue :: FromStruct 'Const a => WordCount -> IO a
-getValue = hGetValue stdin
-
--- | Like 'hGetValue', except that it takes a socket instead of a 'Handle'.
-sGetValue :: FromStruct 'Const a => Socket -> WordCount -> IO a
-sGetValue socket limit = do
-    msg <- sGetMsg socket limit
-    evalLimitT limit (getRoot msg)
-
 -- | Like 'hGetMsg', except that it takes a socket instead of a 'Handle'.
 sGetMsg :: Socket -> WordCount -> IO (M.Message 'Const)
 sGetMsg socket limit =
@@ -113,33 +81,9 @@
                 | otherwise ->
                     (bytes <>) <$> recvFull (count - BS.length bytes)
 
--- | @'hPutValue' handle value@ writes @value@ to handle, as the root object of
--- a message. If it throws an exception, it will be an 'IOError' raised by the
--- underlying IO libraries.
-hPutValue :: (Cerialize RealWorld a, ToStruct ('Mut RealWorld) (Cerial ('Mut RealWorld) a))
-    => Handle -> a -> IO ()
-hPutValue handle value = do
-    msg <- M.newMessage Nothing
-    root <- evalLimitT maxBound $ cerialize msg value
-    setRoot root
-    constMsg <- freeze msg
-    M.hPutMsg handle constMsg
-
--- | 'putValue' is equivalent to @'hPutValue' 'stdin'@
-putValue :: (Cerialize RealWorld a, ToStruct ('Mut RealWorld) (Cerial ('Mut RealWorld) a))
-    => a -> IO ()
-putValue = hPutValue stdout
-
 -- | Like 'hPutMsg', except that it takes a 'Socket' instead of a 'Handle'.
 sPutMsg :: Socket -> M.Message 'Const -> IO ()
 sPutMsg socket = sendLazy socket . msgToLBS
-
--- | Like 'hPutValue', except that it takes a 'Socket' instead of a 'Handle'.
-sPutValue :: (Cerialize RealWorld a, ToStruct ('Mut RealWorld) (Cerial ('Mut RealWorld) a))
-    => Socket -> a -> IO ()
-sPutValue socket value = do
-    lbs <- evalLimitT maxBound $ valueToLBS value
-    sendLazy socket lbs
 
 -- | Read a struct from the handle in its parsed form, using the supplied
 -- read limit.
diff --git a/lib/Capnp/New.hs b/lib/Capnp/New.hs
--- a/lib/Capnp/New.hs
+++ b/lib/Capnp/New.hs
@@ -45,6 +45,11 @@
     , handleRaw
     , methodUnimplemented
 
+    -- * Shorthands for types
+    , R.IsStruct
+    , R.IsCap
+    , R.IsPtr
+
     -- * Re-exported from "Data.Default", for convienence.
     , def
     ) where
diff --git a/lib/Capnp/New/Basics.hs b/lib/Capnp/New/Basics.hs
--- a/lib/Capnp/New/Basics.hs
+++ b/lib/Capnp/New/Basics.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE BangPatterns          #-}
 {-# LANGUAGE DataKinds             #-}
 {-# LANGUAGE DeriveGeneric         #-}
 {-# LANGUAGE EmptyDataDeriving     #-}
@@ -141,8 +142,8 @@
 instance C.EstimateListAlloc AnyStruct (C.Parsed AnyStruct) where
     estimateListAlloc structs =
         let len = V.length structs
-            nWords = foldl' max 0 $ map (V.length . structData) $ V.toList structs
-            nPtrs  = foldl' max 0 $ map (V.length . structPtrs) $ V.toList structs
+            !nWords = foldl' max 0 $ map (V.length . structData) $ V.toList structs
+            !nPtrs  = foldl' max 0 $ map (V.length . structPtrs) $ V.toList structs
         in
         (len, (fromIntegral nWords, fromIntegral nPtrs))
 
diff --git a/lib/Capnp/New/Classes.hs b/lib/Capnp/New/Classes.hs
--- a/lib/Capnp/New/Classes.hs
+++ b/lib/Capnp/New/Classes.hs
@@ -30,6 +30,9 @@
     , EstimateListAlloc(..)
     , newFromRepr
 
+    -- * Setting the root of a message
+    , setRoot
+
     -- * Working with Cap'n Proto types
     , HasTypeId(..)
 
@@ -46,12 +49,13 @@
     , IsWord(..)
     ) where
 
-import           Capnp.Classes        (IsWord(..))
+import           Capnp.Bits
 import           Capnp.Message        (Mutability(..))
 import qualified Capnp.Message        as M
 import qualified Capnp.Repr           as R
 import           Capnp.TraversalLimit (evalLimitT)
 import qualified Capnp.Untyped        as U
+import           Data.Bits
 import           Data.Default         (Default(..))
 import           Data.Foldable        (for_)
 import           Data.Int
@@ -195,11 +199,15 @@
     :: forall a m s. (U.RWCtx m s, R.IsStruct a, Allocate a)
     => AllocHint a -> M.Message ('Mut s) -> m (R.Raw ('Mut s) a)
 newRoot hint msg = do
-    raw@(R.Raw struct) <- new @a hint msg
-    U.setRoot struct
+    raw <- new @a hint msg
+    setRoot raw
     pure raw
 
+-- | Sets the struct to be the root of its containing message.
+setRoot :: (U.RWCtx m s, R.IsStruct a) => R.Raw ('Mut s) a -> m ()
+setRoot (R.Raw struct) = U.setRoot struct
 
+
 ------ Instances for basic types -------
 
 parseId :: (R.Untyped mut (R.ReprFor a) ~ a, U.ReadCtx m mut) => R.Raw mut a -> m a
@@ -327,3 +335,59 @@
         , merge $ map mkInt ints
         , merge $ map mkAll allTys
         ]
+
+-- | Types that can be converted to and from a 64-bit word.
+--
+-- Anything that goes in the data section of a struct will have
+-- an instance of this.
+class IsWord a where
+    -- | Convert from a 64-bit words Truncates the word if the
+    -- type has less than 64 bits.
+    fromWord :: Word64 -> a
+
+    -- | Convert to a 64-bit word.
+    toWord :: a -> Word64
+
+------- IsWord instances. TODO: fold into TH above. -------
+
+instance IsWord Bool where
+    fromWord n = (n .&. 1) == 1
+    toWord True  = 1
+    toWord False = 0
+
+instance IsWord Word1 where
+    fromWord = Word1 . fromWord
+    toWord = toWord . word1ToBool
+
+-- IsWord instances for integral types; they're all the same.
+instance IsWord Int8 where
+    fromWord = fromIntegral
+    toWord = fromIntegral
+instance IsWord Int16 where
+    fromWord = fromIntegral
+    toWord = fromIntegral
+instance IsWord Int32 where
+    fromWord = fromIntegral
+    toWord = fromIntegral
+instance IsWord Int64 where
+    fromWord = fromIntegral
+    toWord = fromIntegral
+instance IsWord Word8 where
+    fromWord = fromIntegral
+    toWord = fromIntegral
+instance IsWord Word16 where
+    fromWord = fromIntegral
+    toWord = fromIntegral
+instance IsWord Word32 where
+    fromWord = fromIntegral
+    toWord = fromIntegral
+instance IsWord Word64 where
+    fromWord = fromIntegral
+    toWord = fromIntegral
+
+instance IsWord Float where
+    fromWord = F.castWord32ToFloat . fromIntegral
+    toWord = fromIntegral . F.castFloatToWord32
+instance IsWord Double where
+    fromWord = F.castWord64ToDouble
+    toWord = F.castDoubleToWord64
diff --git a/lib/Capnp/New/Rpc/Common.hs b/lib/Capnp/New/Rpc/Common.hs
new file mode 100644
--- /dev/null
+++ b/lib/Capnp/New/Rpc/Common.hs
@@ -0,0 +1,13 @@
+module Capnp.New.Rpc.Common
+    ( Client(..)
+    , Pipeline(..)
+    ) where
+
+import {-# SOURCE #-} qualified Capnp.Rpc.Untyped as Rpc
+
+-- | A @'Pipeline' a@ is a reference to possibly-not-resolved result from
+-- a method call.
+newtype Pipeline a = Pipeline Rpc.Pipeline
+
+newtype Client a = Client Rpc.Client
+    deriving(Show, Eq)
diff --git a/lib/Capnp/Repr.hs b/lib/Capnp/Repr.hs
--- a/lib/Capnp/Repr.hs
+++ b/lib/Capnp/Repr.hs
@@ -71,7 +71,6 @@
 
 import Prelude hiding (length)
 
-import qualified Capnp.Classes        as C
 import qualified Capnp.Errors         as E
 import           Capnp.Message        (Mutability(..))
 import qualified Capnp.Message        as M
@@ -284,11 +283,6 @@
     ) => Raw ('Mut s) a -> Int -> Raw ('Mut s) (List a) -> m ()
 setIndex (Raw v) i (Raw l) = U.setIndex (toElement @(ReprFor a) @('Mut s) v) i l
 
-instance (ReprFor a ~ 'Ptr ('Just 'Struct)) => C.ToStruct mut (Raw mut a) where
-    toStruct = fromRaw
-instance (ReprFor a ~ 'Ptr ('Just 'Struct)) => C.FromStruct mut (Raw mut a) where
-    fromStruct = pure . Raw
-
 instance U.HasMessage (Untyped mut (ReprFor a)) mut => U.HasMessage (Raw mut a) mut where
     message (Raw r) = U.message r
 instance U.MessageDefault (Untyped mut (ReprFor a)) mut => U.MessageDefault (Raw mut a) mut where
@@ -387,11 +381,6 @@
           , "composite list"
           )
         ]
-
-instance (IsPtrRepr r, ReprFor a ~ 'Ptr r) => C.ToPtr s (Raw ('Mut s) a) where
-    toPtr _msg (Raw p) = pure $ toPtr @r p
-instance (IsPtrRepr r, ReprFor a ~ 'Ptr r) => C.FromPtr mut (Raw mut a) where
-    fromPtr msg p = Raw <$> fromPtr @r msg p
 
 instance Allocate 'Struct where
     type AllocHint 'Struct = (Word16, Word16)
diff --git a/lib/Capnp/Repr/Methods.hs b/lib/Capnp/Repr/Methods.hs
--- a/lib/Capnp/Repr/Methods.hs
+++ b/lib/Capnp/Repr/Methods.hs
@@ -34,6 +34,7 @@
 import           Capnp.Message           (Mutability(..), newMessage)
 import qualified Capnp.Message           as M
 import qualified Capnp.New.Classes       as NC
+import           Capnp.New.Rpc.Common    (Client(..), Pipeline(..))
 import qualified Capnp.Repr              as R
 import           Capnp.Rpc.Promise       (newPromise)
 import qualified Capnp.Rpc.Server        as Server
@@ -65,13 +66,6 @@
 
 instance HasMethod name c p r => IsLabel name (Method c p r) where
     fromLabel = methodByLabel @name @c @p @r
-
--- | A @'Pipeline' a@ is a reference to possibly-not-resolved result from
--- a method call.
-newtype Pipeline a = Pipeline Rpc.Pipeline
-
-newtype Client a = Client Rpc.Client
-    deriving(Show, Eq)
 
 -- | The 'AsClient' class allows callers of rpc methods to abstract over 'Client's
 -- and 'Pipeline's. @'asClient'@ converts either of those to a client so that
diff --git a/lib/Capnp/Repr/Parsed.hs b/lib/Capnp/Repr/Parsed.hs
--- a/lib/Capnp/Repr/Parsed.hs
+++ b/lib/Capnp/Repr/Parsed.hs
@@ -11,8 +11,8 @@
 import qualified Capnp.New.Basics  as B
 import qualified Capnp.New.Classes as C
 
-import Capnp.Repr         (List, PtrRepr(..), Repr(..), ReprFor)
-import Capnp.Repr.Methods (Client)
+import Capnp.New.Rpc.Common (Client)
+import Capnp.Repr           (List, PtrRepr(..), Repr(..), ReprFor)
 
 -- | @'Parsed' a@ is the high-level/ADT representation of the capnproto
 -- type @a@. For struct types this is equivalent to @'C.Parsed' a@, but
diff --git a/lib/Capnp/Rpc.hs b/lib/Capnp/Rpc.hs
--- a/lib/Capnp/Rpc.hs
+++ b/lib/Capnp/Rpc.hs
@@ -9,18 +9,6 @@
       handleConn
     , ConnConfig(..)
 
-    -- * Calling methods
-    , (?)
-
-    -- * Handling method calls
-    , Server(..)
-    , MethodHandler
-    , pureHandler
-    , rawHandler
-    , rawAsyncHandler
-    , methodUnimplemented
-    , methodThrow
-
     -- * throwing errors
     , throwFailed
 
@@ -50,18 +38,9 @@
 
 import Supervisors
 
-import Capnp.Rpc.Errors    (throwFailed)
-import Capnp.Rpc.Invoke    ((?))
+import Capnp.Rpc.Errors  (throwFailed)
 import Capnp.Rpc.Promise
-import Capnp.Rpc.Server
-    ( MethodHandler
-    , Server(..)
-    , methodThrow
-    , methodUnimplemented
-    , pureHandler
-    , rawAsyncHandler
-    , rawHandler
-    )
+
 import Capnp.Rpc.Transport
     (Transport(..), handleTransport, socketTransport, tracingTransport)
 import Capnp.Rpc.Untyped
diff --git a/lib/Capnp/Rpc/Errors.hs b/lib/Capnp/Rpc/Errors.hs
--- a/lib/Capnp/Rpc/Errors.hs
+++ b/lib/Capnp/Rpc/Errors.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-|
 Module: Capnp.Rpc.Errors
@@ -26,42 +27,42 @@
 
 import qualified Control.Exception.Safe as E
 
-import Capnp.Gen.Capnp.Rpc.Pure (Exception(..), Exception'Type(..))
+import Capnp.Gen.Capnp.Rpc.New
 
 -- | Construct an exception with a type field of failed and the
 -- given text as its reason.
-eFailed :: Text -> Exception
+eFailed :: Text -> Parsed Exception
 eFailed reason = def
     { type_ = Exception'Type'failed
     , reason = reason
     }
 
 -- | An exception with type = disconnected
-eDisconnected :: Exception
+eDisconnected :: Parsed Exception
 eDisconnected = def
     { type_ = Exception'Type'disconnected
     , reason = "Disconnected"
     }
 
 -- | An exception indicating an unimplemented method.
-eMethodUnimplemented :: Exception
+eMethodUnimplemented :: Parsed Exception
 eMethodUnimplemented =
     eUnimplemented "Method unimplemented"
 
 -- | An @unimplemented@ exception with a custom reason message.
-eUnimplemented :: Text -> Exception
+eUnimplemented :: Text -> Parsed Exception
 eUnimplemented reason = def
     { type_ = Exception'Type'unimplemented
     , reason = reason
     }
 
-instance E.Exception Exception
+instance E.Exception (Parsed Exception)
 
 -- | @'wrapException' debugMode e@ converts an arbitrary haskell exception
 -- @e@ into an rpc exception, which can be communicated to a remote vat.
 -- If @debugMode@ is true, the returned exception's reason field will include
 -- the text of @show e@.
-wrapException :: Bool -> E.SomeException -> Exception
+wrapException :: Bool -> E.SomeException -> Parsed Exception
 wrapException debugMode e = fromMaybe
     def { type_ = Exception'Type'failed
         , reason =
diff --git a/lib/Capnp/Rpc/Invoke.hs b/lib/Capnp/Rpc/Invoke.hs
deleted file mode 100644
--- a/lib/Capnp/Rpc/Invoke.hs
+++ /dev/null
@@ -1,119 +0,0 @@
-{-# LANGUAGE ConstraintKinds  #-}
-{-# LANGUAGE DataKinds        #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE LambdaCase       #-}
-{-# LANGUAGE TypeFamilies     #-}
--- |
--- Module: Capnp.Rpc.Invoke
--- Description: Invoke remote methods
---
--- Support for invoking 'Server.MethodHandler's
-module Capnp.Rpc.Invoke
-    (
-    -- * Using high-level representations
-      invokePurePromise
-    , (?)
-    , invokePure
-    , InvokePureCtx
-
-    -- * Using low level representations
-    , invokeRaw
-    ) where
-
-import Control.Monad.STM.Class
-
-import Control.Monad.Catch     (MonadThrow)
-import Control.Monad.Primitive (PrimMonad, PrimState)
-
-import Capnp.Classes
-    ( Cerialize(cerialize)
-    , Decerialize(Cerial, decerialize)
-    , FromPtr(fromPtr)
-    , ToStruct(toStruct)
-    )
-import Capnp.Message        (Mutability(..))
-import Capnp.TraversalLimit (defaultLimit, evalLimitT)
-import Data.Mutable         (freeze)
-
-import qualified Capnp.Message     as M
-import qualified Capnp.Rpc.Promise as Promise
-import qualified Capnp.Rpc.Server  as Server
-import qualified Capnp.Untyped     as U
-
--- | Invoke a method by passing it the low-level representation of its parameter,
--- and a 'Fulfiller' that can be used to supply (the low-level representation of)
--- its return value.
-invokeRaw ::
-    ( MonadThrow m
-    , MonadSTM m
-    , PrimMonad m
-    , Decerialize r
-    , Decerialize p
-    , ToStruct 'Const (Cerial 'Const p)
-    , FromPtr 'Const (Cerial 'Const r)
-    ) =>
-    Server.MethodHandler m p r
-    -> Cerial 'Const p
-    -> Promise.Fulfiller (Cerial 'Const r)
-    -> m ()
-invokeRaw method params typedFulfiller = do
-    (_, untypedFulfiller) <- liftSTM $ Promise.newPromiseWithCallback $ \case
-        Left e -> Promise.breakPromise typedFulfiller e
-        Right v -> evalLimitT defaultLimit (fromPtr M.empty v) >>= Promise.fulfill typedFulfiller
-    Server.invoke
-        (Server.toUntypedHandler method)
-        (Just (U.PtrStruct (toStruct params)))
-        untypedFulfiller
-
--- | Shorthand for class contstraints needed to invoke a method using
--- the high-level API.
-type InvokePureCtx m p r =
-    ( MonadThrow m
-    , MonadSTM m
-    , PrimMonad m
-    , Decerialize r
-    , ToStruct 'Const (Cerial 'Const p)
-    , ToStruct ('Mut (PrimState m)) (Cerial ('Mut (PrimState m)) p)
-    , Cerialize (PrimState m) p
-    , FromPtr 'Const (Cerial 'Const r)
-    )
-
--- | Like 'invokeRaw', but uses the high-level representations of the data
--- types.
-invokePure
-    :: InvokePureCtx m p r
-    => Server.MethodHandler m p r
-    -> p
-    -> Promise.Fulfiller r
-    -> m ()
-invokePure method params pureFulfiller = do
-    struct <- evalLimitT defaultLimit $ do
-        msg <- M.newMessage Nothing
-        cerialize msg params >>= freeze . toStruct
-    (_, untypedFulfiller) <- liftSTM $ Promise.newPromiseWithCallback $ \case
-        Left e -> Promise.breakPromise pureFulfiller e
-        Right v ->
-            evalLimitT defaultLimit (fromPtr M.empty v >>= decerialize)
-            >>= Promise.fulfill pureFulfiller
-    Server.invoke
-        (Server.toUntypedHandler method)
-        (Just (U.PtrStruct struct))
-        untypedFulfiller
-
--- | Like 'invokePure', but returns a promise  instead of accepting a fulfiller.
-invokePurePromise
-    :: InvokePureCtx m p r
-    => Server.MethodHandler m p r
-    -> p
-    -> m (Promise.Promise r)
-invokePurePromise method params = do
-    (promise, fulfiller) <- Promise.newPromise
-    invokePure method params fulfiller
-    pure promise
-
--- | Alias for 'invokePurePromise'
-(?) :: InvokePureCtx m p r
-    => Server.MethodHandler m p r
-    -> p
-    -> m (Promise.Promise r)
-(?) = invokePurePromise
diff --git a/lib/Capnp/Rpc/Promise.hs b/lib/Capnp/Rpc/Promise.hs
--- a/lib/Capnp/Rpc/Promise.hs
+++ b/lib/Capnp/Rpc/Promise.hs
@@ -31,7 +31,7 @@
 
 import qualified Control.Exception.Safe as HsExn
 
-import Capnp.Gen.Capnp.Rpc.Pure
+import Capnp.Gen.Capnp.Rpc.New
 -- For exception instance:
 import Capnp.Rpc.Errors ()
 
@@ -42,7 +42,7 @@
 
 -- | A 'Fulfiller' is used to fulfill a promise.
 newtype Fulfiller a = Fulfiller
-    { callback :: Either Exception a -> STM ()
+    { callback :: Either (Parsed Exception) a -> STM ()
     }
 
 -- | Fulfill a promise by supplying the specified value. It is an error to
@@ -53,12 +53,12 @@
 -- | Break a promise. When the user of the promise executes 'wait', the
 -- specified exception will be raised. It is an error to call 'breakPromise'
 -- if the promise has already been fulfilled (or broken).
-breakPromise :: MonadSTM m => Fulfiller a -> Exception -> m ()
+breakPromise :: MonadSTM m => Fulfiller a -> Parsed Exception -> m ()
 breakPromise f exn = breakOrFulfill f (Left exn)
 
 -- | 'breakOrFulfill' calls either 'breakPromise' or 'fulfill', depending
 -- on the argument.
-breakOrFulfill :: MonadSTM m => Fulfiller a -> Either Exception a -> m ()
+breakOrFulfill :: MonadSTM m => Fulfiller a -> Either (Parsed Exception) a -> m ()
 breakOrFulfill Fulfiller{callback} result = liftSTM $ callback result
 
 -- | Wait for a promise to resolve, and return the result. If the promise
@@ -96,7 +96,7 @@
         )
 
 -- | Create a new promise which also excecutes an STM action when it is resolved.
-newPromiseWithCallback :: MonadSTM m => (Either Exception a -> STM ()) -> m (Promise a, Fulfiller a)
+newPromiseWithCallback :: MonadSTM m => (Either (Parsed Exception) a -> STM ()) -> m (Promise a, Fulfiller a)
 newPromiseWithCallback callback = liftSTM $ do
     (promise, Fulfiller{callback=oldCallback}) <- newPromise
     pure
@@ -107,11 +107,11 @@
         )
 
 -- | Like 'newPromiseWithCallback', but doesn't return the promise.
-newCallback :: MonadSTM m => (Either Exception a -> STM ()) -> m (Fulfiller a)
+newCallback :: MonadSTM m => (Either (Parsed Exception) a -> STM ()) -> m (Fulfiller a)
 newCallback = liftSTM . fmap snd . newPromiseWithCallback
 
 -- | A promise is a value that may not be ready yet.
 newtype Promise a = Promise
-    { var :: TVar (Maybe (Either Exception a))
+    { var :: TVar (Maybe (Either (Parsed Exception) a))
     }
     deriving(Eq)
diff --git a/lib/Capnp/Rpc/Server.hs b/lib/Capnp/Rpc/Server.hs
--- a/lib/Capnp/Rpc/Server.hs
+++ b/lib/Capnp/Rpc/Server.hs
@@ -23,50 +23,22 @@
 
     -- * Handling methods
     , MethodHandler
-    -- ** Using high-level representations
-    , pureHandler
-    -- ** Using low-level representations
-    , rawHandler
-    , rawAsyncHandler
-    -- ** Always throwing exceptions
-    , methodThrow
-    , methodUnimplemented
     -- ** Working with untyped data
     , untypedHandler
     , toUntypedHandler
     , fromUntypedHandler
-
-    -- * Invoking methods
-    , invoke
     ) where
 
 import Control.Concurrent.STM
-import Control.Monad.STM.Class
 import Data.Word
 
-import Control.Exception.Safe  (MonadCatch, try)
-import Control.Monad.IO.Class  (MonadIO, liftIO)
-import Control.Monad.Primitive (PrimMonad, PrimState)
-import Data.Typeable           (Typeable)
+import Data.Typeable (Typeable)
 
-import Capnp.Classes
-    ( Cerialize
-    , Decerialize(Cerial, decerialize)
-    , FromPtr(fromPtr)
-    , ToStruct(toStruct)
-    )
-import Capnp.Convert        (valueToMsg)
-import Capnp.Message        (Mutability(..))
-import Capnp.Rpc.Errors     (eMethodUnimplemented, wrapException)
-import Capnp.Rpc.Promise    (Fulfiller, breakPromise, fulfill, newCallback)
-import Capnp.TraversalLimit (defaultLimit, evalLimitT)
-import Capnp.Untyped        (Ptr)
-import Data.Mutable         (freeze)
+import Capnp.Message     (Mutability(..))
+import Capnp.Rpc.Promise (Fulfiller)
+import Capnp.Untyped     (Ptr)
 
-import qualified Capnp.Gen.Capnp.Rpc.Pure as RpcGen
-import qualified Capnp.Message            as Message
-import qualified Capnp.Untyped            as Untyped
-import qualified Internal.TCloseQ         as TCloseQ
+import qualified Internal.TCloseQ as TCloseQ
 
 -- | a @'MethodHandler' m p r@ handles a method call with parameters @p@
 -- and return type @r@, in monad @m@.
@@ -89,97 +61,6 @@
         -> m ()
     }
 
-invoke
-    :: MonadSTM m
-    => MethodHandler m (Maybe (Ptr 'Const)) (Maybe (Ptr 'Const))
-    -> Maybe (Ptr 'Const)
-    -> Fulfiller (Maybe (Ptr 'Const))
-    -> m ()
-invoke = handleMethod
-
--- | @'pureHandler' f cap@ is a 'MethodHandler' which calls a function @f@
--- that accepts the receiver and the parameter type as exposed by the
--- high-level API, and returns the high-level API representation of the
--- return type.
-pureHandler ::
-    ( MonadCatch m
-    , MonadSTM m
-    , PrimMonad m
-    , s ~ PrimState m
-    , Decerialize p
-    , FromPtr 'Const (Cerial 'Const p)
-    , Cerialize s r
-    , ToStruct ('Mut s) (Cerial ('Mut s) r)
-    ) =>
-    (cap -> p -> m r)
-    -> cap
-    -> MethodHandler m p r
-pureHandler f cap = MethodHandler
-    { handleMethod = \ptr reply -> do
-        param <- evalLimitT defaultLimit $
-            fromPtr Message.empty ptr >>= decerialize
-        result <- try $ f cap param
-        case result of
-            Right val -> do
-                struct <- evalLimitT defaultLimit $
-                    valueToMsg val >>= freeze >>= Untyped.rootPtr
-                liftSTM $ fulfill reply (Just (Untyped.PtrStruct struct))
-            Left e ->
-                -- TODO: find a way to get the connection config's debugMode
-                -- option to be accessible from here, so we can use it.
-                liftSTM $ breakPromise reply (wrapException False e)
-    }
-
--- | Like 'pureHandler', except that the parameter and return value use the
--- low-level representation.
-rawHandler ::
-    ( MonadCatch m
-    , MonadSTM m
-    , PrimMonad m
-    , s ~ PrimState m
-    , Decerialize p
-    , FromPtr 'Const (Cerial 'Const p)
-    , Decerialize r
-    , ToStruct 'Const (Cerial 'Const r)
-    ) =>
-    (cap -> Cerial 'Const p -> m (Cerial 'Const r))
-    -> cap
-    -> MethodHandler m p r
-rawHandler f cap = MethodHandler
-    { handleMethod = \ptr reply -> do
-        cerial <- evalLimitT defaultLimit $ fromPtr Message.empty ptr
-        result <- try $ f cap cerial
-        case result of
-            Right val -> liftSTM $ fulfill reply (Just (Untyped.PtrStruct (toStruct val)))
-            Left e -> liftSTM $ breakPromise reply (wrapException False e)
-    }
-
--- | Like 'rawHandler', except that it takes a fulfiller for the result,
--- instead of returning it. This allows the result to be supplied some time
--- after the method returns, making it possible to service other method
--- calls before the result is available.
-rawAsyncHandler ::
-    ( MonadCatch m
-    , MonadSTM m
-    , PrimMonad m
-    , s ~ PrimState m
-    , Decerialize p
-    , FromPtr 'Const (Cerial 'Const p)
-    , Decerialize r
-    , ToStruct 'Const (Cerial 'Const r)
-    ) =>
-    (cap -> Cerial 'Const p -> Fulfiller (Cerial 'Const r) -> m ())
-    -> cap
-    -> MethodHandler m p r
-rawAsyncHandler f cap = MethodHandler
-    { handleMethod = \ptr reply -> do
-        fulfiller <- newCallback $ \case
-            Left e  -> breakPromise reply e
-            Right v -> fulfill reply $ Just (Untyped.PtrStruct (toStruct v))
-        cerial <- evalLimitT defaultLimit $ fromPtr Message.empty ptr
-        f cap cerial fulfiller
-    }
-
 -- | Convert a 'MethodHandler' for any parameter and return types into
 -- one that deals with untyped pointers.
 toUntypedHandler
@@ -200,16 +81,6 @@
     :: (Maybe (Ptr 'Const) -> Fulfiller (Maybe (Ptr 'Const)) -> m ())
     -> MethodHandler m (Maybe (Ptr 'Const)) (Maybe (Ptr 'Const))
 untypedHandler = MethodHandler
-
--- | @'methodThrow' exn@ is a 'MethodHandler' which always throws @exn@.
-methodThrow :: MonadIO m => RpcGen.Exception -> MethodHandler m p r
-methodThrow exn = MethodHandler
-    { handleMethod = \_ fulfiller -> liftIO $ breakPromise fulfiller exn
-    }
-
--- | A 'MethodHandler' which always throws an @unimplemented@ exception.
-methodUnimplemented :: MonadIO m => MethodHandler m p r
-methodUnimplemented = methodThrow eMethodUnimplemented
 
 -- | Base class for things that can act as capnproto servers.
 class Monad m => Server m a | a -> m where
diff --git a/lib/Capnp/Rpc/Transport.hs b/lib/Capnp/Rpc/Transport.hs
--- a/lib/Capnp/Rpc/Transport.hs
+++ b/lib/Capnp/Rpc/Transport.hs
@@ -5,7 +5,8 @@
 This module provides a 'Transport' type, which provides operations
 used to transmit messages between vats in the RPC protocol.
 -}
-{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE DataKinds        #-}
+{-# LANGUAGE TypeApplications #-}
 module Capnp.Rpc.Transport
     ( Transport(..)
     , handleTransport
@@ -16,13 +17,14 @@
 import Network.Socket (Socket)
 import System.IO      (Handle)
 
-import Capnp.Bits       (WordCount)
-import Capnp.Convert    (msgToValue)
-import Capnp.IO         (hGetMsg, hPutMsg, sGetMsg, sPutMsg)
-import Capnp.Message    (Message, Mutability(Const))
-import Text.Show.Pretty (ppShow)
+import Capnp.Bits           (WordCount)
+import Capnp.Convert        (msgToParsed)
+import Capnp.IO             (hGetMsg, hPutMsg, sGetMsg, sPutMsg)
+import Capnp.Message        (Message, Mutability(Const))
+import Capnp.TraversalLimit (evalLimitT)
+import Text.Show.Pretty     (ppShow)
 
-import qualified Capnp.Gen.Capnp.Rpc.Pure as R
+import qualified Capnp.Gen.Capnp.Rpc.New as R
 
 -- | A @'Transport'@ handles transmitting RPC messages.
 data Transport = Transport
@@ -56,12 +58,12 @@
 tracingTransport :: (String -> IO ()) -> Transport -> Transport
 tracingTransport log trans = Transport
     { sendMsg = \msg -> do
-        rpcMsg <- msgToValue msg
-        log $ "sending message: " ++ ppShow (rpcMsg :: R.Message)
+        rpcMsg <- evalLimitT maxBound $ msgToParsed @R.Message msg
+        log $ "sending message: " ++ ppShow rpcMsg
         sendMsg trans msg
     , recvMsg = do
         msg <- recvMsg trans
-        rpcMsg <- msgToValue msg
-        log $ "received message: " ++ ppShow (rpcMsg :: R.Message)
+        rpcMsg <- evalLimitT maxBound $ msgToParsed @R.Message msg
+        log $ "received message: " ++ ppShow rpcMsg
         pure msg
     }
diff --git a/lib/Capnp/Rpc/Untyped.hs b/lib/Capnp/Rpc/Untyped.hs
--- a/lib/Capnp/Rpc/Untyped.hs
+++ b/lib/Capnp/Rpc/Untyped.hs
@@ -5,11 +5,13 @@
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE LambdaCase                 #-}
 {-# LANGUAGE NamedFieldPuns             #-}
+{-# LANGUAGE OverloadedLabels           #-}
 {-# LANGUAGE OverloadedStrings          #-}
 {-# LANGUAGE RankNTypes                 #-}
 {-# LANGUAGE RecordWildCards            #-}
 {-# LANGUAGE RecursiveDo                #-}
 {-# LANGUAGE ScopedTypeVariables        #-}
+{-# LANGUAGE TypeApplications           #-}
 {-# LANGUAGE TypeFamilies               #-}
 {-# LANGUAGE ViewPatterns               #-}
 -- |
@@ -50,8 +52,6 @@
 
     -- * Errors
     , RpcError(..)
-    , R.Exception(..)
-    , R.Exception'Type(..)
 
     -- * Shutting down the connection
     ) where
@@ -61,6 +61,7 @@
 import Control.Monad.Trans.Class
 import Data.Word
 
+import Capnp.New.Accessors
 import Control.Concurrent       (threadDelay)
 import Control.Concurrent.Async (concurrently_, race_)
 import Control.Concurrent.MVar  (MVar, newEmptyMVar)
@@ -78,6 +79,7 @@
 import Control.Monad            (forever, void, when)
 import Data.Default             (Default(def))
 import Data.Foldable            (for_, toList, traverse_)
+import Data.Function            ((&))
 import Data.Hashable            (Hashable, hash, hashWithSalt)
 import Data.Maybe               (catMaybes, fromMaybe)
 import Data.String              (fromString)
@@ -93,9 +95,11 @@
 import qualified ListT
 import qualified StmContainers.Map as M
 
-import Capnp.Classes        (cerialize, decerialize, fromStruct, new, toStruct)
-import Capnp.Convert        (valueToMsg)
+import Capnp.Convert        (msgToRaw, parsedToMsg)
+import Capnp.Fields         (Which)
 import Capnp.Message        (Message, Mutability(..))
+import Capnp.New.Classes    (new, newRoot, parse)
+import Capnp.Repr           (Raw(..))
 import Capnp.Rpc.Errors
     ( eDisconnected
     , eFailed
@@ -112,16 +116,15 @@
 import Internal.Rc          (Rc)
 import Internal.SnocList    (SnocList)
 
-import qualified Capnp.Gen.Capnp.Rpc      as RawRpc
-import qualified Capnp.Gen.Capnp.Rpc.Pure as R
-import qualified Capnp.Message            as Message
-import qualified Capnp.Rpc.Server         as Server
-import qualified Capnp.Untyped            as UntypedRaw
-import qualified Capnp.Untyped.Pure       as Untyped
-import qualified Internal.Rc              as Rc
-import qualified Internal.SnocList        as SnocList
-import qualified Internal.TCloseQ         as TCloseQ
-import qualified Lifetimes.Gc             as Fin
+import qualified Capnp.Gen.Capnp.Rpc.New as R
+import qualified Capnp.Message           as Message
+import qualified Capnp.New.Basics        as B
+import qualified Capnp.Rpc.Server        as Server
+import qualified Capnp.Untyped           as UntypedRaw
+import qualified Internal.Rc             as Rc
+import qualified Internal.SnocList       as SnocList
+import qualified Internal.TCloseQ        as TCloseQ
+import qualified Lifetimes.Gc            as Fin
 
 -- Note [Organization]
 -- ===================
@@ -159,9 +162,9 @@
 
 -- | Errors which can be thrown by the rpc system.
 data RpcError
-    = ReceivedAbort R.Exception
+    = ReceivedAbort (R.Parsed R.Exception)
     -- ^ The remote vat sent us an abort message.
-    | SentAbort R.Exception
+    | SentAbort (R.Parsed R.Exception)
     -- ^ We sent an abort to the remote vat.
     deriving(Show, Eq, Generic)
 
@@ -436,7 +439,7 @@
         case result of
             Left (SentAbort e) -> do
                 -- We need to actually send it:
-                rawMsg <- createPure maxBound $ valueToMsg $ R.Message'abort e
+                rawMsg <- createPure maxBound $ parsedToMsg $ R.Message'abort e
                 void $ timeout 1000000 $ sendMsg transport rawMsg
                 throwIO $ SentAbort e
             Left e ->
@@ -512,7 +515,7 @@
     -- a return. Contains two sets of callbacks, to invoke on each type
     -- of message.
     = NewQA
-        { onFinish :: SnocList (R.Finish -> STM ())
+        { onFinish :: SnocList (R.Parsed R.Finish -> STM ())
         , onReturn :: SnocList (Return -> STM ())
         }
     -- | An entry for which we've sent/received a return, but not a finish.
@@ -520,13 +523,13 @@
     -- finish.
     | HaveReturn
         { returnMsg :: Return
-        , onFinish  :: SnocList (R.Finish -> STM ())
+        , onFinish  :: SnocList (R.Parsed R.Finish -> STM ())
         }
     -- | An entry for which we've sent/received a finish, but not a return.
     -- Contains the finish message, and a set of callbacks to invoke on the
     -- return.
     | HaveFinish
-        { finishMsg :: R.Finish
+        { finishMsg :: R.Parsed R.Finish
         , onReturn  :: SnocList (Return -> STM ())
         }
 
@@ -634,7 +637,7 @@
         , conn      :: Conn
         }
     | PendingLocalPipeline (SnocList (Fulfiller RawMPtr))
-    | ReadyPipeline (Either R.Exception RawMPtr)
+    | ReadyPipeline (Either (R.Parsed R.Exception) RawMPtr)
 
 -- | 'walkPipleinePtr' follows a pointer starting from the object referred to by the
 -- 'Pipeline'. The 'Pipeline' must refer to a struct, and the pointer is referred to
@@ -735,7 +738,7 @@
         -- promise to resolve.
         }
     -- | The promise resolved to an exception.
-    | Error R.Exception
+    | Error (R.Parsed R.Exception)
 
 -- | A temporary destination for calls on an unresolved promise.
 data TmpDest
@@ -827,14 +830,14 @@
     }
 data Return'
     = Return'results Payload
-    | Return'exception R.Exception
+    | Return'exception (R.Parsed R.Exception)
     | Return'canceled
     | Return'resultsSentElsewhere
     | Return'takeFromOtherQuestion QAId
     | Return'acceptFromThirdParty RawMPtr
 data Payload = Payload
     { content  :: RawMPtr
-    , capTable :: V.Vector R.CapDescriptor
+    , capTable :: V.Vector (R.Parsed R.CapDescriptor)
     }
 
 -- Note [proxies]
@@ -1003,24 +1006,24 @@
         }
 
 
-marshalMsgTarget :: MsgTarget -> R.MessageTarget
+marshalMsgTarget :: MsgTarget -> R.Parsed R.MessageTarget
 marshalMsgTarget = \case
     ImportTgt importId ->
-        R.MessageTarget'importedCap (ieWord importId)
+        R.MessageTarget $ R.MessageTarget'importedCap (ieWord importId)
     AnswerTgt tgt ->
-        R.MessageTarget'promisedAnswer $ marshalPromisedAnswer tgt
+        R.MessageTarget $ R.MessageTarget'promisedAnswer $ marshalPromisedAnswer tgt
 
-marshalPromisedAnswer :: PromisedAnswer -> R.PromisedAnswer
+marshalPromisedAnswer :: PromisedAnswer -> R.Parsed R.PromisedAnswer
 marshalPromisedAnswer PromisedAnswer{ answerId, transform } =
     R.PromisedAnswer
         { R.questionId = qaWord answerId
         , R.transform =
-            V.fromList $
-                map R.PromisedAnswer'Op'getPointerField $
-                    toList transform
+            V.fromList $ map
+                (R.PromisedAnswer'Op . R.PromisedAnswer'Op'getPointerField)
+                (toList transform)
         }
 
-unmarshalPromisedAnswer :: MonadThrow m => R.PromisedAnswer -> m PromisedAnswer
+unmarshalPromisedAnswer :: MonadThrow m => R.Parsed R.PromisedAnswer -> m PromisedAnswer
 unmarshalPromisedAnswer R.PromisedAnswer { questionId, transform } = do
     idxes <- unmarshalOps (toList transform)
     pure PromisedAnswer
@@ -1028,13 +1031,13 @@
         , transform = SnocList.fromList idxes
         }
 
-unmarshalOps :: MonadThrow m => [R.PromisedAnswer'Op] -> m [Word16]
+unmarshalOps :: MonadThrow m => [R.Parsed R.PromisedAnswer'Op] -> m [Word16]
 unmarshalOps [] = pure []
-unmarshalOps (R.PromisedAnswer'Op'noop:ops) =
+unmarshalOps (R.PromisedAnswer'Op { union' = R.PromisedAnswer'Op'noop }:ops) =
     unmarshalOps ops
-unmarshalOps (R.PromisedAnswer'Op'getPointerField i:ops) =
+unmarshalOps (R.PromisedAnswer'Op { union' = R.PromisedAnswer'Op'getPointerField i }:ops) =
     (i:) <$> unmarshalOps ops
-unmarshalOps (R.PromisedAnswer'Op'unknown' tag:_) =
+unmarshalOps (R.PromisedAnswer'Op { union' = R.PromisedAnswer'Op'unknown' tag }:_) =
     throwM $ eFailed $ "Unknown PromisedAnswer.Op: " <> fromString (show tag)
 
 
@@ -1161,41 +1164,41 @@
     flip catchSTM (throwSTM . makeAbortExn debugMode) $ do
         capnpMsg <- readTBQueue recvQ
         evalLimitT defaultLimit $ do
-            root <- UntypedRaw.rootPtr capnpMsg >>= fromStruct
-            msg' <- RawRpc.get_Message' root
-            case msg' of
-                RawRpc.Message'abort exn ->
-                    decerialize exn >>= lift . handleAbortMsg conn
-                RawRpc.Message'unimplemented oldMsg ->
-                    decerialize oldMsg >>= lift . handleUnimplementedMsg conn
-                RawRpc.Message'bootstrap bs ->
-                    decerialize bs >>= lift . handleBootstrapMsg conn
-                RawRpc.Message'call call ->
+            rpcMsg <- msgToRaw capnpMsg
+            which <- structWhich rpcMsg
+            case which of
+                R.RW_Message'abort exn ->
+                    parse exn >>= lift . handleAbortMsg conn
+                R.RW_Message'unimplemented oldMsg ->
+                    parse oldMsg >>= lift . handleUnimplementedMsg conn
+                R.RW_Message'bootstrap bs ->
+                    parse bs >>= lift . handleBootstrapMsg conn
+                R.RW_Message'call call ->
                     handleCallMsg conn call
-                RawRpc.Message'return ret -> do
+                R.RW_Message'return ret -> do
                     ret' <- acceptReturn conn ret
                     lift $ handleReturnMsg conn ret'
-                RawRpc.Message'finish finish ->
-                    decerialize finish >>= lift . handleFinishMsg conn
-                RawRpc.Message'resolve res ->
-                    decerialize res >>= lift . handleResolveMsg conn
-                RawRpc.Message'release release ->
-                    decerialize release >>= lift . handleReleaseMsg conn
-                RawRpc.Message'disembargo disembargo ->
-                    decerialize disembargo >>= lift . handleDisembargoMsg conn
+                R.RW_Message'finish finish ->
+                    parse finish >>= lift . handleFinishMsg conn
+                R.RW_Message'resolve res ->
+                    parse res >>= lift . handleResolveMsg conn
+                R.RW_Message'release release ->
+                    parse release >>= lift . handleReleaseMsg conn
+                R.RW_Message'disembargo disembargo ->
+                    parse disembargo >>= lift . handleDisembargoMsg conn
                 _ -> do
-                    msg <- decerialize root
+                    msg <- parse rpcMsg
                     lift $ sendPureMsg conn' $ R.Message'unimplemented msg
 
 -- Each function handle*Msg handles a message of a particular type;
 -- 'coordinator' dispatches to these.
 
-handleAbortMsg :: Conn -> R.Exception -> STM ()
+handleAbortMsg :: Conn -> R.Parsed R.Exception -> STM ()
 handleAbortMsg _ exn =
     throwSTM (ReceivedAbort exn)
 
-handleUnimplementedMsg :: Conn -> R.Message -> STM ()
-handleUnimplementedMsg conn msg = getLive conn >>= \conn' -> case msg of
+handleUnimplementedMsg :: Conn -> R.Parsed R.Message -> STM ()
+handleUnimplementedMsg conn (R.Message msg) = getLive conn >>= \conn' -> case msg of
     R.Message'unimplemented _ ->
         -- If the client itself doesn't handle unimplemented messages, that's
         -- weird, but ultimately their problem.
@@ -1209,7 +1212,7 @@
         abortConn conn' $
             eFailed "Received unimplemented response for required message."
 
-handleBootstrapMsg :: Conn -> R.Bootstrap -> STM ()
+handleBootstrapMsg :: Conn -> R.Parsed R.Bootstrap -> STM ()
 handleBootstrapMsg conn R.Bootstrap{ questionId } = getLive conn >>= \conn' -> do
     ret <- case bootstrap conn' of
         Nothing ->
@@ -1224,14 +1227,15 @@
             capDesc <- emitCap conn client
             content <- createPure defaultLimit $ do
                 msg <- Message.newMessage Nothing
-                cerialize msg $ Just (Untyped.PtrCap client)
+                Just . UntypedRaw.PtrCap <$> UntypedRaw.appendCap msg client
             pure Return
                 { answerId = QAId questionId
                 , releaseParamCaps = True -- Not really meaningful for bootstrap, but...
                 , union' =
                     Return'results Payload
                         { content
-                        , capTable = V.singleton (def :: R.CapDescriptor) { R.union' = capDesc }
+                        , capTable = V.singleton
+                            (def { R.union' = capDesc } :: R.Parsed R.CapDescriptor)
                         }
                 }
     M.focus
@@ -1261,14 +1265,14 @@
     insertBootstrap conn' _ (Just _) =
         abortConn conn' $ eFailed "Duplicate question ID"
 
-handleCallMsg :: Conn -> RawRpc.Call 'Const -> LimitT STM ()
+handleCallMsg :: Conn -> Raw 'Const R.Call -> LimitT STM ()
 handleCallMsg conn callMsg = do
     conn'@Conn'{exports, answers} <- lift $ getLive conn
-    questionId <- RawRpc.get_Call'questionId callMsg
-    target <- RawRpc.get_Call'target callMsg >>= decerialize
-    interfaceId <- RawRpc.get_Call'interfaceId callMsg
-    methodId <- RawRpc.get_Call'methodId callMsg
-    payload <- RawRpc.get_Call'params callMsg
+    questionId <- parseField #questionId callMsg
+    R.MessageTarget target <- parseField #target callMsg
+    interfaceId <- parseField #interfaceId callMsg
+    methodId <- parseField #methodId callMsg
+    payload <- readField #params callMsg
 
     Payload{content = callParams, capTable} <- acceptPayload conn payload
 
@@ -1354,7 +1358,7 @@
 ptrPathClient is ptr =
     evalLimitT defaultLimit $ followPtrs is ptr >>= ptrClient
 
-transformClient :: V.Vector R.PromisedAnswer'Op -> RawMPtr -> Conn' -> STM Client
+transformClient :: V.Vector (R.Parsed R.PromisedAnswer'Op) -> RawMPtr -> Conn' -> STM Client
 transformClient transform ptr conn =
     (unmarshalOps (V.toList transform) >>= flip ptrPathClient ptr)
         `catchSTM` abortConn conn
@@ -1387,20 +1391,17 @@
         msg <- case mcontent of
             Just v  -> pure $ UntypedRaw.message v
             Nothing -> Message.newMessage Nothing
-        mcapTable <- cerialize msg capTable
-        payload <- new msg
-        RawRpc.set_Payload'content payload mcontent
-        RawRpc.set_Payload'capTable payload mcapTable
-        call <- new msg
-        RawRpc.set_Call'params call payload
-        RawRpc.set_Call'questionId call (qaWord questionId)
-        RawRpc.set_Call'interfaceId call interfaceId
-        RawRpc.set_Call'methodId call methodId
-        tgt <- cerialize msg $ marshalMsgTarget target
-        RawRpc.set_Call'target call tgt
-        rpcMsg <- new msg
-        RawRpc.set_Message'call rpcMsg call
-        UntypedRaw.setRoot (toStruct rpcMsg)
+        payload <- new @R.Payload () msg
+        payload & setField #content (Raw mcontent)
+        payload & encodeField #capTable capTable
+        call <- new @R.Call () msg
+        setField #params payload call
+        call & encodeField #questionId (qaWord questionId)
+        call & encodeField #interfaceId interfaceId
+        call & encodeField #methodId methodId
+        call & encodeField #target (marshalMsgTarget target)
+        rpcMsg <- newRoot @R.Message () msg
+        setVariant #call rpcMsg call
         pure msg
     )
 
@@ -1412,17 +1413,15 @@
             msg <- case mcontent of
                 Just v  -> pure $ UntypedRaw.message v
                 Nothing -> Message.newMessage Nothing
-            mcapTable <- cerialize msg capTable
-            payload <- new msg
-            RawRpc.set_Payload'content payload mcontent
-            RawRpc.set_Payload'capTable payload mcapTable
-            ret <- new msg
-            RawRpc.set_Return'results ret payload
-            RawRpc.set_Return'answerId ret (qaWord answerId)
-            RawRpc.set_Return'releaseParamCaps ret releaseParamCaps
-            rpcMsg <- new msg
-            RawRpc.set_Message'return rpcMsg ret
-            UntypedRaw.setRoot (toStruct rpcMsg)
+            payload <- new @R.Payload () msg
+            payload & setField #content (Raw mcontent)
+            payload & encodeField #capTable capTable
+            ret <- new @R.Return () msg
+            setVariant #results ret payload
+            ret & encodeField #answerId (qaWord answerId)
+            ret & encodeField #releaseParamCaps releaseParamCaps
+            rpcMsg <- newRoot @R.Message () msg
+            setVariant #return rpcMsg ret
             pure msg
         )
     Return'exception exn ->
@@ -1455,35 +1454,34 @@
             msg <- case mptr of
                 Just v  -> pure $ UntypedRaw.message v
                 Nothing -> Message.newMessage Nothing
-            ret <- new msg
-            RawRpc.set_Return'answerId ret (qaWord answerId)
-            RawRpc.set_Return'releaseParamCaps ret releaseParamCaps
-            RawRpc.set_Return'acceptFromThirdParty ret mptr
-            rpcMsg <- new msg
-            RawRpc.set_Message'return rpcMsg ret
-            UntypedRaw.setRoot (toStruct rpcMsg)
+            ret <- new @R.Return () msg
+            ret & encodeField #answerId (qaWord answerId)
+            ret & encodeField #releaseParamCaps releaseParamCaps
+            setVariant #acceptFromThirdParty ret (Raw @_ @(Maybe B.AnyPointer) mptr)
+            rpcMsg <- newRoot @R.Message () msg
+            setVariant #return rpcMsg ret
             pure msg
         )
 
-acceptReturn :: Conn -> RawRpc.Return 'Const -> LimitT STM Return
+acceptReturn :: Conn -> Raw 'Const R.Return -> LimitT STM Return
 acceptReturn conn ret = do
-    answerId <- QAId <$> RawRpc.get_Return'answerId ret
-    releaseParamCaps <- RawRpc.get_Return'releaseParamCaps ret
-    ret' <- RawRpc.get_Return' ret
-    union' <- case ret' of
-        RawRpc.Return'results payload ->
+    let answerId = QAId (getField #answerId ret)
+        releaseParamCaps = getField #releaseParamCaps ret
+    which <- structWhich ret
+    union' <- case which of
+        R.RW_Return'results payload ->
             Return'results <$> acceptPayload conn payload
-        RawRpc.Return'exception exn ->
-            Return'exception <$> decerialize exn
-        RawRpc.Return'canceled ->
+        R.RW_Return'exception exn ->
+            Return'exception <$> parse exn
+        R.RW_Return'canceled _ ->
             pure Return'canceled
-        RawRpc.Return'resultsSentElsewhere ->
+        R.RW_Return'resultsSentElsewhere _ ->
             pure Return'resultsSentElsewhere
-        RawRpc.Return'takeFromOtherQuestion id ->
-            pure $ Return'takeFromOtherQuestion (QAId id)
-        RawRpc.Return'acceptFromThirdParty ptr ->
+        R.RW_Return'takeFromOtherQuestion id ->
+            Return'takeFromOtherQuestion . QAId <$> parse id
+        R.RW_Return'acceptFromThirdParty (Raw ptr) ->
             pure $ Return'acceptFromThirdParty ptr
-        RawRpc.Return'unknown' ordinal ->
+        R.RW_Return'unknown' ordinal ->
             lift $ throwSTM $ eFailed $ "Unknown return variant #" <> fromString (show ordinal)
     pure Return { answerId, releaseParamCaps, union' }
 
@@ -1491,11 +1489,11 @@
 handleReturnMsg conn ret = getLive conn >>= \conn'@Conn'{questions} ->
     updateQAReturn conn' questions "question" ret
 
-handleFinishMsg :: Conn -> R.Finish -> STM ()
+handleFinishMsg :: Conn -> R.Parsed R.Finish -> STM ()
 handleFinishMsg conn finish = getLive conn >>= \conn'@Conn'{answers} ->
     updateQAFinish conn' answers "answer" finish
 
-handleResolveMsg :: Conn -> R.Resolve -> STM ()
+handleResolveMsg :: Conn -> R.Parsed R.Resolve -> STM ()
 handleResolveMsg conn R.Resolve{promiseId, union'} =
     getLive conn >>= \conn'@Conn'{imports} -> do
         entry <- M.lookup (IEId promiseId) imports
@@ -1535,7 +1533,7 @@
                             , " not understood"
                             ]
 
-handleReleaseMsg :: Conn -> R.Release -> STM ()
+handleReleaseMsg :: Conn -> R.Parsed R.Release -> STM ()
 handleReleaseMsg
         conn
         R.Release
@@ -1565,11 +1563,14 @@
                             eid
                             exports
 
-handleDisembargoMsg :: Conn -> R.Disembargo -> STM ()
+handleDisembargoMsg :: Conn -> R.Parsed R.Disembargo -> STM ()
 handleDisembargoMsg conn d = getLive conn >>= go d
   where
     go
-        R.Disembargo { context=R.Disembargo'context'receiverLoopback (EmbargoId -> eid) }
+        R.Disembargo
+            { context = R.Disembargo'context'
+                (R.Disembargo'context'receiverLoopback (EmbargoId -> eid))
+            }
         conn'@Conn'{embargos}
         = do
             result <- M.lookup eid embargos
@@ -1582,7 +1583,10 @@
                     M.delete eid embargos
                     freeEmbargo conn' eid
     go
-        R.Disembargo{ target, context=R.Disembargo'context'senderLoopback embargoId }
+        R.Disembargo
+            { target = R.MessageTarget target
+            , context = R.Disembargo'context' (R.Disembargo'context'senderLoopback embargoId)
+            }
         conn'@Conn'{exports, answers}
         = case target of
             R.MessageTarget'importedCap exportId ->
@@ -1618,8 +1622,10 @@
                 ImportRef {conn=targetConn, importId}
                     | conn == targetConn ->
                         sendPureMsg conn' $ R.Message'disembargo R.Disembargo
-                            { context = R.Disembargo'context'receiverLoopback embargoId
-                            , target = R.MessageTarget'importedCap (ieWord importId)
+                            { context = R.Disembargo'context' $
+                                R.Disembargo'context'receiverLoopback embargoId
+                            , target = R.MessageTarget $
+                                R.MessageTarget'importedCap (ieWord importId)
                             }
                 _ ->
                     abortDisembargoClient
@@ -1639,7 +1645,7 @@
                 ]
 -- Note [Level 3]
     go d conn' =
-        sendPureMsg conn' $ R.Message'unimplemented $ R.Message'disembargo d
+        sendPureMsg conn' $ R.Message'unimplemented $ R.Message $ R.Message'disembargo d
 
 lookupAbort
     :: (Eq k, Hashable k, Show k)
@@ -1678,13 +1684,13 @@
 genSendableCapTableRaw
     :: Conn
     -> Maybe (UntypedRaw.Ptr 'Const)
-    -> STM (V.Vector R.CapDescriptor)
+    -> STM (V.Vector (R.Parsed R.CapDescriptor))
 genSendableCapTableRaw _ Nothing = pure V.empty
 genSendableCapTableRaw conn (Just ptr) =
     traverse
         (\c -> do
             union' <- emitCap conn c
-            pure (def :: R.CapDescriptor) { R.union' = union' }
+            pure (def :: R.Parsed R.CapDescriptor) { R.union' = union' }
         )
         (Message.getCapTable (UntypedRaw.message ptr))
 
@@ -1695,13 +1701,13 @@
     capTable <- genSendableCapTableRaw conn content
     pure Payload { content, capTable }
 
-sendPureMsg :: Conn' -> R.Message -> STM ()
+sendPureMsg :: Conn' -> R.Parsed (Which R.Message) -> STM ()
 sendPureMsg Conn'{sendQ} msg =
-    createPure maxBound (valueToMsg msg) >>= writeTBQueue sendQ
+    createPure maxBound (parsedToMsg (R.Message msg)) >>= writeTBQueue sendQ
 
 -- | Send a finish message, updating connection state and triggering
 -- callbacks as necessary.
-finishQuestion :: Conn' -> R.Finish -> STM ()
+finishQuestion :: Conn' -> R.Parsed R.Finish -> STM ()
 finishQuestion conn@Conn'{questions} finish@R.Finish{questionId} = do
     -- arrange for the question ID to be returned to the pool once
     -- the return has also been received:
@@ -1741,7 +1747,7 @@
                 "Duplicate return message for " <> tableName <> " #"
                 <> fromString (show answerId)
 
-updateQAFinish :: Conn' -> M.Map QAId EntryQA -> Text -> R.Finish -> STM ()
+updateQAFinish :: Conn' -> M.Map QAId EntryQA -> Text -> R.Parsed R.Finish -> STM ()
 updateQAFinish conn table tableName finish@R.Finish{questionId} =
     lookupAbort tableName conn table (QAId questionId) $ \case
         NewQA{onFinish, onReturn} -> do
@@ -1794,7 +1800,7 @@
 
 -- | Abort the connection, sending an abort message. This is only safe to call
 -- from within either the thread running the coordinator or the callback loop.
-abortConn :: Conn' -> R.Exception -> STM a
+abortConn :: Conn' -> R.Parsed R.Exception -> STM a
 abortConn _ e = throwSTM (SentAbort e)
 
 -- | Gets the live connection state, or throws disconnected if it is not live.
@@ -1826,7 +1832,7 @@
                 }
         pState <- newTVar Pending { tmpDest }
         sendPureMsg conn' $
-            R.Message'bootstrap def { R.questionId = qaWord qid }
+            R.Message'bootstrap (def { R.questionId = qaWord qid } :: R.Parsed R.Bootstrap)
         M.insert
             NewQA
                 { onReturn = SnocList.fromList
@@ -1858,7 +1864,7 @@
 -- to each function.
 
 -- | Resolve a promised client to an exception. See Note [resolveClient]
-resolveClientExn :: TmpDest -> (PromiseState -> STM ()) -> R.Exception -> STM ()
+resolveClientExn :: TmpDest -> (PromiseState -> STM ()) -> R.Parsed R.Exception -> STM ()
 resolveClientExn tmpDest resolve exn = do
     case tmpDest of
         LocalDest LocalBuffer { callBuffer } -> do
@@ -1984,14 +1990,15 @@
 --
 -- The callback may be handed a 'Left' with a disconnected exception if
 -- the connection is dropped before the disembargo is echoed.
-disembargo :: Conn' -> MsgTarget -> (Either R.Exception () -> STM ()) -> STM ()
+disembargo :: Conn' -> MsgTarget -> (Either (R.Parsed R.Exception) () -> STM ()) -> STM ()
 disembargo conn@Conn'{embargos} tgt onEcho = do
     callback <- newCallback onEcho
     eid <- newEmbargo conn
     M.insert callback eid embargos
     sendPureMsg conn $ R.Message'disembargo R.Disembargo
         { target = marshalMsgTarget tgt
-        , context = R.Disembargo'context'senderLoopback (embargoWord eid)
+        , context = R.Disembargo'context' $
+            R.Disembargo'context'senderLoopback (embargoWord eid)
         }
 
 -- | Resolve a promised client to the result of a return. See Note [resolveClient]
@@ -2091,7 +2098,7 @@
 -- | Generate a CapDescriptor', which we can send to the connection's remote
 -- vat to identify client. In the process, this may allocate export ids, update
 -- reference counts, and so forth.
-emitCap :: Conn -> Client -> STM R.CapDescriptor'
+emitCap :: Conn -> Client -> STM (R.Parsed (Which R.CapDescriptor))
 emitCap _targetConn (Client Nothing) =
     pure R.CapDescriptor'none
 emitCap targetConn (Client (Just client')) = case client' of
@@ -2116,17 +2123,17 @@
   where
     newSenderPromise = R.CapDescriptor'senderPromise . ieWord <$> getConnExport targetConn client'
 
-acceptPayload :: Conn -> RawRpc.Payload 'Const -> LimitT STM Payload
+acceptPayload :: Conn -> Raw 'Const R.Payload -> LimitT STM Payload
 acceptPayload conn payload = do
-    capTable <- RawRpc.get_Payload'capTable payload >>= decerialize
+    capTable <- parseField #capTable payload
     clients <- lift $ traverse (\R.CapDescriptor{union'} -> acceptCap conn union') capTable
-    content <- RawRpc.get_Payload'content payload >>=
-        traverse (UntypedRaw.tMsg (pure . Message.withCapTable clients))
+    Raw rawContent <- readField #content payload
+    content <- traverse (UntypedRaw.tMsg (pure . Message.withCapTable clients)) rawContent
     pure Payload {content, capTable}
 
 -- | 'acceptCap' is a dual of 'emitCap'; it derives a Client from a CapDescriptor'
 -- received via the connection. May update connection state as necessary.
-acceptCap :: Conn -> R.CapDescriptor' -> STM Client
+acceptCap :: Conn -> R.Parsed (Which R.CapDescriptor) -> STM Client
 acceptCap conn cap = getLive conn >>= \conn' -> go conn' cap
   where
     go _ R.CapDescriptor'none = pure (Client Nothing)
diff --git a/lib/Capnp/Rpc/Untyped.hs-boot b/lib/Capnp/Rpc/Untyped.hs-boot
--- a/lib/Capnp/Rpc/Untyped.hs-boot
+++ b/lib/Capnp/Rpc/Untyped.hs-boot
@@ -1,6 +1,7 @@
 module Capnp.Rpc.Untyped where
 
 data Client
+data Pipeline
 
 nullClient :: Client
 
diff --git a/lib/Capnp/Tutorial.hs b/lib/Capnp/Tutorial.hs
--- a/lib/Capnp/Tutorial.hs
+++ b/lib/Capnp/Tutorial.hs
@@ -50,10 +50,6 @@
 import qualified Data.ByteString as BS
 import qualified Data.Text       as T
 
-import Capnp
-
-import Capnp.Classes (FromStruct)
-
 -- $overview
 --
 -- This module provides an overview of the capnp library.
@@ -181,7 +177,7 @@
 -- and abbreviated for readability):
 --
 -- > import qualified Capnp.Repr as R
--- > import qualified Capnp.Classes.New as C
+-- > import qualified Capnp.New.Classes as C
 -- > import qualified Capnp.Repr.Parsed as RP
 -- > import GHC.Generics (Generic)
 -- >
diff --git a/lib/Capnp/Untyped/Pure.hs b/lib/Capnp/Untyped/Pure.hs
deleted file mode 100644
--- a/lib/Capnp/Untyped/Pure.hs
+++ /dev/null
@@ -1,241 +0,0 @@
-{-# LANGUAGE BangPatterns               #-}
-{-# LANGUAGE DataKinds                  #-}
-{-# LANGUAGE DeriveGeneric              #-}
-{-# LANGUAGE FlexibleContexts           #-}
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE GADTs                      #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE MultiParamTypeClasses      #-}
-{-# LANGUAGE TypeFamilies               #-}
-{-# LANGUAGE UndecidableInstances       #-}
-{-|
-Module: Capnp.Untyped.Pure
-Description: high-level API for working with untyped Cap'N Proto values.
-
-This module provides an idiomatic Haskell interface for untyped capnp
-data, based on algebraic datatypes. It forgoes some of the benefits of
-the capnp wire format in favor of a more convienient API.
-
-In addition to the algebraic data types themselves, this module also
-provides support for converting from the lower-level types in
-"Capnp.Untyped".
--}
-module Capnp.Untyped.Pure
-    ( Slice(..)
-    , Ptr(..)
-    , Struct(..)
-    , List(..)
-    , ListOf
-    , length
-    , sliceIndex
-    )
-  where
-
-import Prelude hiding (length)
-
-import Data.Word
-
-import Control.Monad                 (forM_)
-import Data.Default                  (Default(def))
-import Data.Default.Instances.Vector ()
-import GHC.Exts                      (IsList (..))
-import GHC.Generics                  (Generic)
-
-import Capnp.Classes
-    ( Cerialize (..)
-    , Decerialize (..)
-    , FromStruct (..)
-    , Marshal (..)
-    , ToPtr (..)
-    )
-import Capnp.Message          (Mutability (..))
-import Internal.Gen.Instances ()
-
-import qualified Capnp.Message as M
-import qualified Capnp.Untyped as U
-import qualified Data.Vector   as V
-
--- | A one of a struct's sections (data or pointer).
---
--- This is just a newtype wrapper around 'ListOf' (which is itself just
--- 'V.Vector'), but critically the notion of equality is different. Two
--- slices are considered equal if all of their elements are equal, but
--- If the slices are different lengths, missing elements are treated as
--- having default values. Accordingly, equality is only defined if the
--- element type is an instance of 'Default'.
-newtype Slice a = Slice (ListOf a)
-    deriving(Generic, Show, Ord, Functor, Default, IsList)
-
--- | A capnproto pointer type.
-data Ptr
-    = PtrStruct !Struct
-    | PtrList   !List
-    | PtrCap    !M.Client
-    deriving(Generic, Show, Eq)
-
--- | A capnproto struct.
-data Struct = Struct
-    { structData :: Slice Word64
-    -- ^ The struct's data section
-    , structPtrs :: Slice (Maybe Ptr)
-    -- ^ The struct's pointer section
-    }
-    deriving(Generic, Show, Eq)
-instance Default Struct
-
--- | An untyped list.
-data List
-    = List0  (ListOf ())
-    | List1  (ListOf Bool)
-    | List8  (ListOf Word8)
-    | List16 (ListOf Word16)
-    | List32 (ListOf Word32)
-    | List64 (ListOf Word64)
-    | ListPtr (ListOf (Maybe Ptr))
-    | ListStruct (ListOf Struct)
-    deriving(Generic, Show, Eq)
-
--- | Alias for 'V.Vector'. Using this alias may make upgrading to future
--- versions of the library easier, as we will likely switch to a more
--- efficient representation at some point.
-type ListOf a = V.Vector a
-
--- | Alias for vector's 'V.length'.
-length :: ListOf a -> Int
-length = V.length
-
--- | Index into a slice, returning a default value if the the index is past
--- the end of the array.
-sliceIndex :: Default a => Int -> Slice a -> a
-sliceIndex i (Slice vec)
-    | i < V.length vec = vec V.! i
-    | otherwise = def
-
-instance (Default a, Eq a) => Eq (Slice a) where
-    -- We define equality specially (rather than just deriving), such that
-    -- slices are padded out with the default values of their elements.
-    l@(Slice vl) == r@(Slice vr) = go (max (length vl) (length vr) - 1)
-      where
-        go (-1) = True -- can happen if both slices are empty.
-        go 0    = True
-        go i    = sliceIndex i l == sliceIndex i r && go (i-1)
-
-instance Decerialize Struct where
-    type Cerial msg Struct = U.Struct msg
-
-    decerialize struct = Struct
-        <$> (Slice <$> decerializeWords)
-        <*> (Slice <$> decerializePtrs)
-      where
-        decerializeWords =
-            let nwords = fromIntegral $ U.structWordCount struct in
-            V.generateM nwords (`U.getData` struct)
-        decerializePtrs =
-            let nptrs = fromIntegral $ U.structPtrCount struct in
-            V.generateM nptrs (\i -> U.getPtr i struct >>= decerialize)
-
-instance FromStruct 'Const Struct where
-    fromStruct = decerialize
-
-instance Marshal s Struct where
-    marshalInto raw (Struct (Slice dataSec) (Slice ptrSec)) = do
-        forM_ [0..V.length dataSec - 1] $ \i ->
-            U.setData (dataSec V.! i) i raw
-        forM_ [0..V.length ptrSec - 1] $ \i -> do
-            ptr <- cerialize (U.message raw) (ptrSec V.! i)
-            U.setPtr ptr i raw
-
-instance Cerialize s Struct where
-    cerialize msg struct@(Struct (Slice dataSec) (Slice ptrSec)) = do
-        raw <- U.allocStruct
-            msg
-            (fromIntegral $ V.length dataSec)
-            (fromIntegral $ V.length ptrSec)
-        marshalInto raw struct
-        pure raw
-
-instance Decerialize (Maybe Ptr) where
-    type Cerial msg (Maybe Ptr) = Maybe (U.Ptr msg)
-
-    decerialize Nothing = pure Nothing
-    decerialize (Just ptr) = Just <$> case ptr of
-        U.PtrCap cap       -> PtrCap <$> U.getClient cap
-        U.PtrStruct struct -> PtrStruct <$> decerialize struct
-        U.PtrList list     -> PtrList <$> decerialize list
-
-instance Cerialize s (Maybe Ptr) where
-    cerialize _ Nothing                     = pure Nothing
-    cerialize msg (Just (PtrStruct struct)) = cerialize msg struct >>= toPtr msg
-    cerialize msg (Just (PtrList     list)) = Just . U.PtrList <$> cerialize msg list
-    cerialize msg (Just (PtrCap       cap)) = Just . U.PtrCap <$> U.appendCap msg cap
-
--- | Decerialize an untyped list, whose elements are instances of Decerialize. This isn't
--- an instance, since it would have to be an instance of (List a), which conflicts with
--- the above.
-decerializeListOf :: (U.ReadCtx m 'Const, Decerialize a)
-    => U.ListOf 'Const (Cerial 'Const a) -> m (ListOf a)
-decerializeListOf raw = V.generateM (U.length raw) (\i -> U.index i raw >>= decerialize)
-
--- | Decerialize an untyped list, leaving the elements of the list as-is. The is most
--- interesting for types that go in the data section of a struct, hence the name.
-decerializeListOfWord :: (U.ReadCtx m 'Const)
-    => U.ListOf 'Const a -> m (ListOf a)
-decerializeListOfWord raw = V.generateM (U.length raw) (`U.index` raw)
-
-instance Decerialize List where
-    type Cerial msg List = U.List msg
-
-    decerialize (U.List0 l)      = List0 <$> decerializeListOfWord l
-    decerialize (U.List1 l)      = List1 <$> decerializeListOfWord l
-    decerialize (U.List8 l)      = List8 <$> decerializeListOfWord l
-    decerialize (U.List16 l)     = List16 <$> decerializeListOfWord l
-    decerialize (U.List32 l)     = List32 <$> decerializeListOfWord l
-    decerialize (U.List64 l)     = List64 <$> decerializeListOfWord l
-    decerialize (U.ListPtr l)    = ListPtr <$> decerializeListOf l
-    decerialize (U.ListStruct l) = ListStruct <$> decerializeListOf l
-
-instance Cerialize s List where
-    cerialize msg (List0   l) = U.List0  <$> U.allocList0 msg (length l)
-    cerialize msg (List1   l) = U.List1  <$> cerializeListOfWord (U.allocList1  msg) l
-    cerialize msg (List8   l) = U.List8  <$> cerializeListOfWord (U.allocList8  msg) l
-    cerialize msg (List16  l) = U.List16 <$> cerializeListOfWord (U.allocList16 msg) l
-    cerialize msg (List32  l) = U.List32 <$> cerializeListOfWord (U.allocList32 msg) l
-    cerialize msg (List64  l) = U.List64 <$> cerializeListOfWord (U.allocList64 msg) l
-    cerialize msg (ListPtr l) = do
-        raw <- U.allocListPtr msg (length l)
-        forM_ [0..length l - 1] $ \i -> do
-            ptr <- cerialize msg (l V.! i)
-            U.setIndex ptr i raw
-        pure $ U.ListPtr raw
-    cerialize msg (ListStruct l) = do
-        let (maxData, maxPtrs) = measureStructSizes l
-        raw <- U.allocCompositeList msg maxData maxPtrs (length l)
-        forM_ [0..length l - 1] $ \i -> do
-            elt <- U.index i raw
-            marshalInto elt (l V.! i)
-        pure $ U.ListStruct raw
-      where
-        -- Find the maximum sizes of each section of any of the structs
-        -- in the list. This is the size we need to set in the tag word.
-        measureStructSizes :: ListOf Struct -> (Word16, Word16)
-        measureStructSizes = foldl
-            (\(!dataSz, !ptrSz) (Struct (Slice dataSec) (Slice ptrSec)) ->
-                ( max dataSz (fromIntegral $ length dataSec)
-                , max ptrSz  (fromIntegral $ length ptrSec)
-                )
-            )
-            (0, 0)
-
-
-cerializeListOfWord
-    :: U.RWCtx m s
-    => (Int -> m (U.ListOf ('Mut s) a)) -> ListOf a -> m (U.ListOf ('Mut s) a)
-cerializeListOfWord alloc list = do
-    ret <- alloc (length list)
-    marshalListOfWord ret list
-    pure ret
-
-marshalListOfWord :: U.RWCtx m s => U.ListOf ('Mut s) a -> ListOf a -> m ()
-marshalListOfWord raw l =
-    forM_ [0..length l - 1] $ \i ->
-        U.setIndex (l V.! i) i raw
diff --git a/lib/Codec/Capnp.hs b/lib/Codec/Capnp.hs
deleted file mode 100644
--- a/lib/Codec/Capnp.hs
+++ /dev/null
@@ -1,33 +0,0 @@
-{-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies          #-}
-module Codec.Capnp
-    ( newRoot
-    , setRoot
-    , getRoot
-    ) where
-
-import Capnp.Classes
-
-import Capnp.Message (Mutability (..))
-
-import qualified Capnp.Message as M
-import qualified Capnp.Untyped as U
-
--- | 'newRoot' allocates and returns a new value inside the message, setting
--- it as the root object of the message.
-newRoot :: (ToStruct ('Mut s) a, Allocate s a, M.WriteCtx m s)
-    => M.Message ('Mut s) -> m a
-newRoot msg = do
-    ret <- new msg
-    setRoot ret
-    pure ret
-
--- | 'setRoot' sets its argument to be the root object in its message.
-setRoot :: (ToStruct ('Mut s) a, M.WriteCtx m s) => a -> m ()
-setRoot = U.setRoot . toStruct
-
--- | 'getRoot' returns the root object of a message.
-getRoot :: (FromStruct mut a, U.ReadCtx m mut) => M.Message mut -> m a
-getRoot msg = U.rootPtr msg >>= fromStruct
diff --git a/scripts/gen-basic-instances.hs b/scripts/gen-basic-instances.hs
deleted file mode 100644
--- a/scripts/gen-basic-instances.hs
+++ /dev/null
@@ -1,105 +0,0 @@
-{-# LANGUAGE RecordWildCards #-}
--- | Script that generates 'Internal.Gen.Instances', which is mostly a
--- bunch of tedious instances for basic types for our various type classes.
-module Main where
-
-header = unlines
-    [ "{-# LANGUAGE TypeFamilies #-}"
-    , "{-# LANGUAGE FlexibleInstances #-}"
-    , "{-# LANGUAGE MultiParamTypeClasses #-}"
-    , "module Internal.Gen.Instances where"
-    , "-- This module is auto-generated by gen-builtintypes-lists.hs; DO NOT EDIT."
-    , ""
-    , "import Data.Int"
-    , "import Data.Word"
-    , ""
-    , "import Capnp.Classes"
-    , "    ( ListElem(..)"
-    , "    , MutListElem(..)"
-    , "    , FromPtr(..)"
-    , "    , Decerialize(..)"
-    , "    , Cerialize(..)"
-    , "    , cerializeBasicVec"
-    , "    )"
-    , ""
-    , "import qualified Capnp.Untyped as U"
-    , "import qualified Data.Vector as V"
-    , "import qualified GHC.Float as F"
-    , ""
-    ]
-
-data InstanceParams = P
-    { to         :: String
-    , from       :: String
-    , typed      :: String
-    , untyped    :: String
-    , listSuffix :: String
-    }
-
-genInstance P{..} = concat $
-    [ "instance ListElem msg ", typed, " where\n"
-    , "    newtype List msg ", typed, " = List", typed, " (U.ListOf msg ", untyped, ")\n"
-    , "    listFromPtr msg ptr = List", typed, " <$> fromPtr msg ptr\n"
-    , "    toUntypedList (List", typed, " l) = U.List", listSuffix, " l\n"
-    , "    length (List", typed, " l) = U.length l\n"
-    , "    index i (List", typed, " l) = ", from, " <$> U.index i l\n"
-    , "instance MutListElem s ", typed, " where\n"
-    , "    setIndex elt i (", dataCon, " l) = U.setIndex (", to, " elt) i l\n"
-    , "    newList msg size = List", typed, " <$> U.allocList", listSuffix, " msg size\n"
-    , "instance Decerialize ", typed, " where\n"
-    , "    type Cerial msg ", typed, " = ", typed, "\n"
-    , "    decerialize val = pure val\n"
-    , "instance Cerialize s ", typed, " where\n"
-    , "    cerialize _ val = pure val\n"
-    ]
-    ++
-    [ "instance Cerialize s (V.Vector " ++  t ++ ") where\n" ++
-      "    cerialize = cerializeBasicVec\n"
-    | t <- take 6 $ iterate (\t -> "(V.Vector " ++ t ++ ")") typed
-    ]
-  where
-    dataCon = "List" ++ typed
-
-sizes = [8, 16, 32, 64]
-
-intInstance size = P
-    { to = "fromIntegral"
-    , from = "fromIntegral"
-    , typed = "Int" ++ show size
-    , untyped = "Word" ++ show size
-    , listSuffix = show size
-    }
-
-wordInstance size = P
-    { to = "id"
-    , from = "id"
-    , typed = "Word" ++ show size
-    , untyped = "Word" ++ show size
-    , listSuffix = show size
-    }
-
-instances =
-    map intInstance sizes ++
-    map wordInstance sizes ++
-    [ P { to = "F.castFloatToWord32"
-        , from = "F.castWord32ToFloat"
-        , typed = "Float"
-        , untyped = "Word32"
-        , listSuffix = "32"
-        }
-    , P { to = "F.castDoubleToWord64"
-        , from = "F.castWord64ToDouble"
-        , typed = "Double"
-        , untyped = "Word64"
-        , listSuffix = "64"
-        }
-    , P { to = "id"
-        , from = "id"
-        , typed = "Bool"
-        , untyped = "Bool"
-        , listSuffix = "1"
-        }
-    ]
-
-main = writeFile "gen/lib/Internal/Gen/Instances.hs" $
-    header ++ concatMap genInstance instances
diff --git a/scripts/regen.sh b/scripts/regen.sh
--- a/scripts/regen.sh
+++ b/scripts/regen.sh
@@ -16,10 +16,6 @@
 repo_root="$(realpath $(dirname $0)/..)"
 cd "$repo_root"
 
-# First, make sure our non-schema generated modules are up to date.
-log "Generating Internal.Gen"
-runhaskell scripts/gen-basic-instances.hs
-
 # Make sure the compiler plugin is up to date.
 log "Rebuilding schema compiler plugin..."
 cabal new-build capnpc-haskell
diff --git a/tests/Instances.hs b/tests/Instances.hs
--- a/tests/Instances.hs
+++ b/tests/Instances.hs
@@ -4,10 +4,11 @@
 
 In particular, stuff from:
 
-* "Capnp.Untyped.Pure"
-* "Capnp.Gen.Capnp.Schema.Pure"
+* "Capnp.New.Basics"
+* "Capnp.Gen.Capnp.Schema.New"
 -}
 {-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE FlexibleInstances     #-}
 {-# LANGUAGE RecordWildCards       #-}
 module Instances () where
 
@@ -18,16 +19,18 @@
 
 import qualified Data.Vector as V
 
-import Capnp.Gen.Capnp.Schema.Pure
+import Capnp.New (Which)
 
-import qualified Capnp.Untyped.Pure as PU
+import Capnp.Gen.Capnp.Schema.New
 
+import qualified Capnp.New.Basics as B
+
 -- Generate an arbitrary "unknown" tag, i.e. one with a value unassigned
 -- by the schema. The parameter is the number of tags assigned by the schema.
 arbitraryTag :: Word16 -> Gen Word16
 arbitraryTag numTags = max numTags <$> arbitrary
 
-instance Arbitrary Node where
+instance Arbitrary (Parsed Node) where
     shrink = genericShrink
     arbitrary = do
         id <- arbitrary
@@ -41,7 +44,7 @@
         union' <- arbitrary
         pure Node{..}
 
-instance Arbitrary Node'SourceInfo where
+instance Arbitrary (Parsed Node'SourceInfo) where
     shrink = genericShrink
     arbitrary = do
         id <- arbitrary
@@ -49,11 +52,11 @@
         members <- arbitrarySmallerVec
         pure Node'SourceInfo{..}
 
-instance Arbitrary Node'SourceInfo'Member where
+instance Arbitrary (Parsed Node'SourceInfo'Member) where
     shrink = genericShrink
     arbitrary = Node'SourceInfo'Member <$> arbitrary
 
-instance Arbitrary Node' where
+instance Arbitrary (Parsed (Which Node)) where
     shrink = genericShrink
     arbitrary = oneof
         [ pure Node'file
@@ -65,11 +68,11 @@
         , Node'unknown' <$> arbitraryTag 6
         ]
 
-instance Arbitrary Node'enum where
+instance Arbitrary (Parsed Node'enum) where
     shrink = genericShrink
     arbitrary = Node'enum' <$> arbitrarySmallerVec
 
-instance Arbitrary Node'struct where
+instance Arbitrary (Parsed Node'struct) where
     shrink = genericShrink
     arbitrary = do
         dataWordCount <- arbitrary
@@ -81,15 +84,15 @@
         fields <- arbitrarySmallerVec
         pure Node'struct'{..}
 
-instance Arbitrary Node'interface where
+instance Arbitrary (Parsed Node'interface) where
     shrink = genericShrink
     arbitrary = Node'interface' <$> arbitrarySmallerVec <*> arbitrarySmallerVec
 
-instance Arbitrary Node'const where
+instance Arbitrary (Parsed Node'const) where
     shrink = genericShrink
     arbitrary = Node'const' <$> arbitrary <*> arbitrary
 
-instance Arbitrary Node'annotation where
+instance Arbitrary (Parsed Node'annotation) where
     shrink = genericShrink
     arbitrary = do
         type_ <- arbitrary
@@ -107,13 +110,13 @@
         targetsAnnotation <- arbitrary
         pure Node'annotation'{..}
 
-instance Arbitrary Node'NestedNode where
+instance Arbitrary (Parsed Node'NestedNode) where
     shrink = genericShrink
     arbitrary = Node'NestedNode
         <$> arbitrary
         <*> arbitrary
 
-instance Arbitrary Field where
+instance Arbitrary (Parsed Field) where
     shrink = genericShrink
     arbitrary = do
         name <- arbitrary
@@ -124,14 +127,14 @@
         ordinal <- arbitrary
         pure Field{..}
 
-instance Arbitrary Field' where
+instance Arbitrary (Parsed (Which Field)) where
     shrink = genericShrink
     arbitrary = oneof
         [ Field'slot <$> arbitrary
         , Field'group <$> arbitrary
         ]
 
-instance Arbitrary Field'slot where
+instance Arbitrary (Parsed Field'slot) where
     shrink = genericShrink
     arbitrary = do
         offset <- arbitrary
@@ -140,31 +143,35 @@
         hadExplicitDefault <- arbitrary
         pure Field'slot'{..}
 
-instance Arbitrary Field'group where
+instance Arbitrary (Parsed Field'group) where
     shrink = genericShrink
     arbitrary = Field'group' <$> arbitrary
 
-instance Arbitrary Field'ordinal where
+instance Arbitrary (Parsed Field'ordinal) where
     shrink = genericShrink
+    arbitrary = Field'ordinal' <$> arbitrary
+
+instance Arbitrary (Parsed (Which Field'ordinal)) where
+    shrink = genericShrink
     arbitrary = oneof
         [ pure Field'ordinal'implicit
         , Field'ordinal'explicit <$> arbitrary
         ]
 
-instance Arbitrary Enumerant where
+instance Arbitrary (Parsed Enumerant) where
     shrink = genericShrink
     arbitrary = Enumerant
         <$> arbitrary
         <*> arbitrary
         <*> arbitrarySmallerVec
 
-instance Arbitrary Superclass where
+instance Arbitrary (Parsed Superclass) where
     shrink = genericShrink
     arbitrary = Superclass
         <$> arbitrary
         <*> arbitrary
 
-instance Arbitrary Method where
+instance Arbitrary (Parsed Method) where
     shrink = genericShrink
     arbitrary = do
         name <- arbitrary
@@ -177,28 +184,28 @@
         annotations <- arbitrary
         pure Method{..}
 
-instance Arbitrary CapnpVersion where
+instance Arbitrary (Parsed CapnpVersion) where
     shrink = genericShrink
     arbitrary = CapnpVersion
         <$> arbitrary
         <*> arbitrary
         <*> arbitrary
 
-instance Arbitrary Node'Parameter where
+instance Arbitrary (Parsed Node'Parameter) where
     shrink = genericShrink
     arbitrary = Node'Parameter <$> arbitrary
 
-instance Arbitrary Brand where
+instance Arbitrary (Parsed Brand) where
     shrink = genericShrink
     arbitrary = Brand <$> arbitrarySmallerVec
 
-instance Arbitrary Brand'Scope where
+instance Arbitrary (Parsed Brand'Scope) where
     shrink = genericShrink
     arbitrary = Brand'Scope
         <$> arbitrary
         <*> arbitrary
 
-instance Arbitrary Brand'Scope' where
+instance Arbitrary (Parsed (Which Brand'Scope)) where
     shrink = genericShrink
     arbitrary = oneof
         [ Brand'Scope'bind <$> arbitrarySmallerVec
@@ -206,16 +213,24 @@
         , Brand'Scope'unknown' <$> arbitraryTag 2
         ]
 
-instance Arbitrary Brand'Binding where
+instance Arbitrary (Parsed Brand'Binding) where
     shrink = genericShrink
+    arbitrary = Brand'Binding <$> arbitrary
+
+instance Arbitrary (Parsed (Which Brand'Binding)) where
+    shrink = genericShrink
     arbitrary = oneof
         [ pure Brand'Binding'unbound
         , Brand'Binding'type_ <$> arbitrary
         , Brand'Binding'unknown' <$> arbitraryTag 2
         ]
 
-instance Arbitrary Value where
+instance Arbitrary (Parsed Value) where
     shrink = genericShrink
+    arbitrary = Value <$> arbitrary
+
+instance Arbitrary (Parsed (Which Value)) where
+    shrink = genericShrink
     arbitrary = oneof
         [ pure Value'void
         , Value'bool <$> arbitrary
@@ -239,7 +254,7 @@
         , Value'unknown' <$> arbitraryTag 19
         ]
 
-instance Arbitrary Annotation where
+instance Arbitrary (Parsed Annotation) where
     shrink = genericShrink
     arbitrary = Annotation
         <$> arbitrary
@@ -260,16 +275,24 @@
         , ElementSize'unknown' <$> arbitraryTag 8
         ]
 
-instance Arbitrary Type'anyPointer where
+instance Arbitrary (Parsed Type'anyPointer) where
     shrink = genericShrink
+    arbitrary = Type'anyPointer' <$> arbitrary
+
+instance Arbitrary (Parsed (Which Type'anyPointer)) where
+    shrink = genericShrink
     arbitrary = oneof
         [ Type'anyPointer'unconstrained <$> arbitrary
         , Type'anyPointer'parameter <$> arbitrary
         , Type'anyPointer'implicitMethodParameter <$> arbitrary
         ]
 
-instance Arbitrary Type'anyPointer'unconstrained where
+instance Arbitrary (Parsed Type'anyPointer'unconstrained) where
     shrink = genericShrink
+    arbitrary = Type'anyPointer'unconstrained' <$> arbitrary
+
+instance Arbitrary (Parsed (Which Type'anyPointer'unconstrained)) where
+    shrink = genericShrink
     arbitrary = oneof
         [ pure Type'anyPointer'unconstrained'anyKind
         , pure Type'anyPointer'unconstrained'struct
@@ -277,18 +300,22 @@
         , pure Type'anyPointer'unconstrained'capability
         ]
 
-instance Arbitrary Type'anyPointer'parameter where
+instance Arbitrary (Parsed Type'anyPointer'parameter) where
     shrink = genericShrink
     arbitrary =
         Type'anyPointer'parameter' <$> arbitrary <*> arbitrary
 
-instance Arbitrary Type'anyPointer'implicitMethodParameter where
+instance Arbitrary (Parsed Type'anyPointer'implicitMethodParameter) where
     shrink = genericShrink
     arbitrary =
         Type'anyPointer'implicitMethodParameter' <$> arbitrary
 
-instance Arbitrary Type where
+instance Arbitrary (Parsed Type) where
     shrink = genericShrink
+    arbitrary = Type <$> arbitrary
+
+instance Arbitrary (Parsed (Which Type)) where
+    shrink = genericShrink
     arbitrary = oneof
         [ pure Type'void
         , pure Type'bool
@@ -312,23 +339,23 @@
         , Type'unknown' <$> arbitraryTag 21
         ]
 
-instance Arbitrary Type'list where
+instance Arbitrary (Parsed Type'list) where
     shrink = genericShrink
     arbitrary = Type'list' <$> arbitrary
 
-instance Arbitrary Type'enum where
+instance Arbitrary (Parsed Type'enum) where
     shrink = genericShrink
     arbitrary = Type'enum' <$> arbitrary <*> arbitrary
 
-instance Arbitrary Type'struct where
+instance Arbitrary (Parsed Type'struct) where
     shrink = genericShrink
     arbitrary = Type'struct' <$> arbitrary <*> arbitrary
 
-instance Arbitrary Type'interface where
+instance Arbitrary (Parsed Type'interface) where
     shrink = genericShrink
     arbitrary = Type'interface' <$> arbitrary <*> arbitrary
 
-instance Arbitrary CodeGeneratorRequest where
+instance Arbitrary (Parsed CodeGeneratorRequest) where
     shrink = genericShrink
     arbitrary = do
         capnpVersion <- arbitrary
@@ -337,23 +364,19 @@
         sourceInfo <- arbitrarySmallerVec
         pure CodeGeneratorRequest{..}
 
-instance Arbitrary CodeGeneratorRequest'RequestedFile where
+instance Arbitrary (Parsed CodeGeneratorRequest'RequestedFile) where
     shrink = genericShrink
     arbitrary = CodeGeneratorRequest'RequestedFile
         <$> arbitrary
         <*> arbitrary
         <*> arbitrary
 
-instance Arbitrary CodeGeneratorRequest'RequestedFile'Import where
+instance Arbitrary (Parsed CodeGeneratorRequest'RequestedFile'Import) where
     shrink = genericShrink
     arbitrary = CodeGeneratorRequest'RequestedFile'Import
         <$> arbitrary
         <*> arbitrary
 
-instance Arbitrary a => Arbitrary (PU.Slice a) where
-    shrink = genericShrink
-    arbitrary = PU.Slice <$> arbitrarySmallerVec
-
 arbitrarySmallerVec :: Arbitrary a => Gen (V.Vector a)
 arbitrarySmallerVec = sized $ \size -> do
     -- Make sure the elements are scaled down relative to
@@ -362,32 +385,32 @@
     let gen = resize (size `div` V.length vec) arbitrary
     traverse (const gen) vec
 
-instance Arbitrary PU.Struct where
+instance Arbitrary (Parsed B.AnyStruct) where
     shrink = genericShrink
-    arbitrary = sized $ \_ -> PU.Struct
-        <$> arbitrary
-        <*> arbitrary
+    arbitrary = sized $ \_ -> B.Struct
+        <$> arbitrarySmallerVec
+        <*> arbitrarySmallerVec
 
-instance Arbitrary PU.List where
+instance Arbitrary (Parsed B.AnyList) where
     shrink = genericShrink
     arbitrary = oneof
-        [ PU.List0 <$> arbitrarySmallerVec
-        , PU.List1 <$> arbitrarySmallerVec
-        , PU.List8 <$> arbitrarySmallerVec
-        , PU.List16 <$> arbitrarySmallerVec
-        , PU.List32 <$> arbitrarySmallerVec
-        , PU.List64 <$> arbitrarySmallerVec
-        , PU.ListPtr <$> arbitrarySmallerVec
-        , PU.ListStruct <$> arbitrarySmallerVec
+        [ B.List0 <$> arbitrarySmallerVec
+        , B.List1 <$> arbitrarySmallerVec
+        , B.List8 <$> arbitrarySmallerVec
+        , B.List16 <$> arbitrarySmallerVec
+        , B.List32 <$> arbitrarySmallerVec
+        , B.List64 <$> arbitrarySmallerVec
+        , B.ListPtr <$> arbitrarySmallerVec
+        , B.ListStruct <$> arbitrarySmallerVec
         ]
 
-instance Arbitrary PU.Ptr where
-    shrink (PU.PtrStruct s) = PU.PtrStruct <$> shrink s
-    shrink (PU.PtrList   l) = PU.PtrList   <$> shrink l
-    shrink (PU.PtrCap    _) = []
+instance Arbitrary (Parsed B.AnyPointer) where
+    shrink (B.PtrStruct s) = B.PtrStruct <$> shrink s
+    shrink (B.PtrList   l) = B.PtrList   <$> shrink l
+    shrink (B.PtrCap    _) = []
     arbitrary = oneof
-        [ PU.PtrStruct <$> arbitrary
-        , PU.PtrList <$> arbitrary
+        [ B.PtrStruct <$> arbitrary
+        , B.PtrList <$> arbitrary
         -- We never generate capabilites, as we can't marshal Clients back in,
         -- so many of the invariants we check don't hold for caps.
         ]
diff --git a/tests/Module/Capnp/Basics.hs b/tests/Module/Capnp/Basics.hs
--- a/tests/Module/Capnp/Basics.hs
+++ b/tests/Module/Capnp/Basics.hs
@@ -1,30 +1,35 @@
+{-# LANGUAGE DataKinds           #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 module Module.Capnp.Basics (basicsTests) where
 
+import Prelude hiding (length)
+
+import Data.Word
 import Test.Hspec
 import Test.QuickCheck
 
 import Control.Monad.IO.Class    (liftIO)
+import GHC.Prim                  (coerce)
 import Test.QuickCheck.IO        (propertyIO)
 import Test.QuickCheck.Instances ()
 
 import qualified Data.ByteString as BS
 import qualified Data.Text       as T
 
-import Capnp.Basics
+import Capnp.New.Basics
 
-import Capnp        (cerialize, evalLimitT, newMessage)
+import Capnp.New
+    (List, Mutability(..), Raw(..), encode, evalLimitT, length, newMessage)
 import Data.Mutable (Thaw(freeze))
 
-import qualified Capnp.Untyped as U
-
 basicsTests :: Spec
 basicsTests =
     describe "textBuffer and textBytes agree" $
         it "Should return the same number of bytes" $
             property $ \(text :: T.Text) -> propertyIO $ evalLimitT maxBound $ do
                 msg <- newMessage Nothing
-                cerial <- cerialize msg text
-                buf <- textBuffer cerial
-                bytes <- freeze cerial >>= textBytes
-                liftIO $ BS.length bytes `shouldBe` U.length buf
+                Raw untyped <- encode msg text
+                raw :: Raw 'Const Text <- Raw <$> freeze untyped
+                buf <- textBuffer raw
+                bytes <- textBytes raw
+                liftIO $ BS.length bytes `shouldBe` length (coerce buf :: Raw 'Const (List Word8))
diff --git a/tests/Module/Capnp/Canonicalize.hs b/tests/Module/Capnp/Canonicalize.hs
--- a/tests/Module/Capnp/Canonicalize.hs
+++ b/tests/Module/Capnp/Canonicalize.hs
@@ -16,11 +16,11 @@
 
 import Capnp.Canonicalize
 
-import Capnp (cerialize, createPure, msgToLBS)
+import Capnp.New (Parsed, Raw(..), createPure, encode, msgToLBS)
 
-import qualified Capnp.Message      as M
-import qualified Capnp.Untyped      as U
-import qualified Capnp.Untyped.Pure as PU
+import qualified Capnp.Message    as M
+import qualified Capnp.New.Basics as B
+import qualified Capnp.Untyped    as U
 
 import Instances ()
 import Util      (capnpCanonicalize)
@@ -30,7 +30,7 @@
     describe "canonicalization tests" $ do
         it "agrees with reference implementation" $
             property $ \case
-                PU.Struct (PU.Slice (V.toList -> [])) (PU.Slice (V.toList -> [])) ->
+                B.Struct (V.toList -> []) (V.toList -> []) ->
                     -- skip this; it fails due to a bug in the reference implementation:
                     --
                     -- https://github.com/capnproto/capnproto/issues/1084
@@ -40,7 +40,7 @@
                 struct ->
                     propertyIO $ implsAgreeOn struct
 
-implsAgreeOn :: PU.Struct -> IO ()
+implsAgreeOn :: Parsed B.AnyStruct -> IO ()
 implsAgreeOn struct = do
     let Just ourMsg = ourImplCanonicalize struct
     refMsg <- refImplCanonicalize struct
@@ -54,18 +54,18 @@
             , show $ LBS.unpack $ msgToLBS refMsg
             ]
 
-ourImplCanonicalize :: PU.Struct -> Maybe (M.Message 'M.Const)
+ourImplCanonicalize :: Parsed B.AnyStruct -> Maybe (M.Message 'M.Const)
 ourImplCanonicalize struct = createPure maxBound $ do
     msg <- M.newMessage Nothing
-    rawStruct <- cerialize msg struct
+    Raw rawStruct <- encode msg struct
     (msg, _) <- canonicalize rawStruct
     pure msg
 
-refImplCanonicalize :: PU.Struct -> IO (M.Message 'M.Const)
+refImplCanonicalize :: Parsed B.AnyStruct -> IO (M.Message 'M.Const)
 refImplCanonicalize struct = do
     msg <- createPure maxBound $ do
         msg <- M.newMessage Nothing
-        rawStruct <- cerialize msg struct
+        Raw rawStruct <- encode msg struct
         U.setRoot rawStruct
         pure msg
     lbs <- capnpCanonicalize (msgToLBS msg)
diff --git a/tests/Module/Capnp/Gen/Capnp/Schema.hs b/tests/Module/Capnp/Gen/Capnp/Schema.hs
--- a/tests/Module/Capnp/Gen/Capnp/Schema.hs
+++ b/tests/Module/Capnp/Gen/Capnp/Schema.hs
@@ -10,10 +10,8 @@
 import Data.Foldable           (traverse_)
 import Data.Function           ((&))
 
-import           Capnp.Gen.Capnp.Schema
 import qualified Capnp.Gen.Capnp.Schema.New as N
 
-import Capnp                (newRoot)
 import Capnp.New            (encodeField, encodeVariant, initVariant, readField)
 import Capnp.TraversalLimit (LimitT, evalLimitT)
 import Data.Mutable         (Thaw(..))
@@ -31,23 +29,6 @@
 schemaTests :: Spec
 schemaTests = describe "tests for typed setters" $ traverse_ testCase
     [ BuildTest
-        { typeName = "Field"
-        , expected = concat
-            [ "( codeOrder = 4,\n"
-            , "  discriminantValue = 6,\n"
-            , "  group = (typeId = 322),\n"
-            , "  ordinal = (explicit = 22) )\n"
-            ]
-        , builder = \msg -> do
-            field <- newRoot msg
-            set_Field'codeOrder field 4
-            set_Field'discriminantValue field 6
-            group <- set_Field'group field
-            set_Field'group'typeId group 322
-            ordinal <- get_Field'ordinal field
-            set_Field'ordinal'explicit ordinal 22
-        }
-    , BuildTest -- same test, but with the repr API.
         { typeName = "Field"
         , expected = concat
             [ "( codeOrder = 4,\n"
diff --git a/tests/Module/Capnp/Gen/Capnp/Schema/Pure.hs b/tests/Module/Capnp/Gen/Capnp/Schema/Pure.hs
--- a/tests/Module/Capnp/Gen/Capnp/Schema/Pure.hs
+++ b/tests/Module/Capnp/Gen/Capnp/Schema/Pure.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE AllowAmbiguousTypes   #-}
 {-# LANGUAGE DataKinds             #-}
 {-# LANGUAGE DuplicateRecordFields #-}
 {-# LANGUAGE FlexibleContexts      #-}
@@ -6,6 +7,8 @@
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE QuasiQuotes           #-}
 {-# LANGUAGE ScopedTypeVariables   #-}
+{-# LANGUAGE TypeApplications      #-}
+{-# LANGUAGE TypeFamilies          #-}
 module Module.Capnp.Gen.Capnp.Schema.Pure (pureSchemaTests) where
 
 import Data.Proxy
@@ -13,13 +16,12 @@
 
 import Control.Exception.Safe    (bracket)
 import Control.Monad             (when)
-import Control.Monad.Primitive   (RealWorld)
-import Data.Default              (Default (..))
+import Data.Default              (Default(..))
 import Data.Foldable             (traverse_)
 import System.Directory          (removeFile)
 import System.IO
     (IOMode(ReadMode, WriteMode), hClose, openBinaryTempFile, withBinaryFile)
-import Test.QuickCheck           (Property, property)
+import Test.QuickCheck           (Arbitrary, Property, property)
 import Test.QuickCheck.IO        (propertyIO)
 import Test.QuickCheck.Instances ()
 import Text.Heredoc              (here)
@@ -28,22 +30,23 @@
 import qualified Data.ByteString.Builder as BB
 import qualified Data.ByteString.Lazy    as LBS
 
-import Capnp.Gen.Capnp.Schema.Pure
+import Capnp.Gen.Capnp.Schema.New
 import Util
 
 import Instances ()
 
-import Capnp
-    (Mutability (..), getRoot, hGetValue, hPutValue, setRoot)
-import Capnp.Classes
-    ( Allocate (..)
-    , Cerialize (..)
-    , Decerialize (..)
-    , FromStruct (..)
-    , ToStruct (..)
+import Capnp.New
+    ( IsStruct
+    , Mutability(..)
+    , Parse(..)
+    , Raw(..)
+    , defaultLimit
+    , evalLimitT
+    , hGetParsed
+    , hPutParsed
+    , msgToParsed
     )
-import Capnp.TraversalLimit (defaultLimit, evalLimitT)
-import Data.Mutable         (Thaw (..))
+import Data.Mutable (Thaw(..))
 
 import qualified Capnp.Message as M
 import qualified Capnp.Untyped as U
@@ -64,31 +67,25 @@
         )
   where
     testCase ::
-        -- TODO: the size of this context is *stupid*
-        ( Show a
-        , Eq a
-        , Cerialize RealWorld a
-        , FromStruct 'Const (Cerial 'Const a)
-        , ToStruct ('Mut RealWorld) (Cerial ('Mut RealWorld) a)
-        , Allocate RealWorld (Cerial ('Mut RealWorld) a)
-        ) => (String, a, String) -> Spec
+        ( IsStruct a
+        , Parse a pa
+        , Show pa
+        , Eq pa
+        ) => (String, pa, String) -> Spec
     testCase (name, expectedValue, expectedText) = describe "cerialize" $
         it ("Should agree with capnp decode (with name = " ++ name ++ ")") $ do
             msg <- evalLimitT maxBound $ do
                 -- TODO: add some helpers for all this.
                 msg <- M.newMessage Nothing
-                cerialOut <- cerialize msg expectedValue
-                setRoot cerialOut
+                Raw cerialOut <- encode msg expectedValue
+                U.setRoot cerialOut
                 freeze msg
             let builder = M.encode msg
             actualText <- capnpDecode
                 (LBS.toStrict $ BB.toLazyByteString builder)
                 (MsgMetaData schemaSchemaSrc name)
             actualText `shouldBe` expectedText
-            actualValue <- evalLimitT maxBound $ do
-                root <- U.rootPtr msg
-                cerialIn <- fromStruct root
-                decerialize cerialIn
+            actualValue <- evalLimitT maxBound $ msgToParsed msg
             actualValue `shouldBe` expectedValue
 
 decodeTests :: Spec
@@ -139,7 +136,7 @@
                 4
                 2
                 [Node'NestedNode "theName" 321]
-                [Annotation 2 (Value'bool True) (Brand [])]
+                [Annotation 2 (Value $ Value'bool True) (Brand [])]
                 [Node'Parameter "theName" ]
                 True
                 unionVal
@@ -177,11 +174,11 @@
                             3
                             [ Annotation
                                 2
-                                (Value'bool True)
+                                (Value $ Value'bool True)
                                 (Brand [])
                             ]
                             7
-                            Field'ordinal'implicit
+                            (Field'ordinal' Field'ordinal'implicit)
                             (Field'group $ Field'group' 4)
                         ]
                     }
@@ -193,7 +190,7 @@
               , Node'interface $ Node'interface' [] [Superclass 0 (Brand [])]
               )
             , ( "const = (type = (bool = void), value = (bool = false))"
-              , Node'const $ Node'const' Type'bool (Value'bool False)
+              , Node'const $ Node'const' (Type Type'bool) (Value $ Value'bool False)
               )
             , ( [here| annotation =
                     ( type = (bool = void)
@@ -212,7 +209,7 @@
                     )
                 |]
               , Node'annotation $ Node'annotation'
-                    Type'bool
+                    (Type Type'bool)
                     True
                     False
                     False
@@ -261,7 +258,7 @@
         ]
     , decodeTests "Annotation"
         [ ( "(id = 323, brand = (scopes = []), value = (bool = true))"
-          , Annotation 323 (Value'bool True) (Brand [])
+          , Annotation 323 (Value $ Value'bool True) (Brand [])
           )
         ]
     , decodeTests "CapnpVersion"
@@ -281,9 +278,9 @@
           , Field
                 "fieldName"
                 3
-                [Annotation 2 (Value'bool True) (Brand [])]
+                [Annotation 2 (Value $ Value'bool True) (Brand [])]
                 3
-                Field'ordinal'implicit
+                (Field'ordinal' Field'ordinal'implicit)
                 (Field'group $ Field'group' 4)
           )
         , ( [here|
@@ -303,13 +300,13 @@
           , Field
                 "fieldName"
                 3
-                [Annotation 2 (Value'bool True) (Brand [])]
+                [Annotation 2 (Value $ Value'bool True) (Brand [])]
                 3
-                (Field'ordinal'explicit 7)
+                (Field'ordinal' $ Field'ordinal'explicit 7)
                 (Field'slot $ Field'slot'
                     3
-                    Type'bool
-                    (Value'bool False)
+                    (Type Type'bool)
+                    (Value $ Value'bool False)
                     True)
           )
         ]
@@ -322,55 +319,60 @@
                     ]
                 )
             |]
-          , Enumerant "red" 4 [Annotation 23 (Value'uint8 3) (Brand [])]
+          , Enumerant "red" 4 [Annotation 23 (Value $ Value'uint8 3) (Brand [])]
           )
         ]
     , decodeTests "Superclass"
         [ ("(id = 34, brand = (scopes = []))", Superclass 34 (Brand []))
         ]
     , decodeTests "Type"
-        [ ("(bool = void)", Type'bool)
-        , ("(int8 = void)", Type'int8)
-        , ("(int16 = void)", Type'int16)
-        , ("(int32 = void)", Type'int32)
-        , ("(int64 = void)", Type'int64)
-        , ("(uint8 = void)", Type'uint8)
-        , ("(uint16 = void)", Type'uint16)
-        , ("(uint32 = void)", Type'uint32)
-        , ("(uint64 = void)", Type'uint64)
-        , ("(float32 = void)", Type'float32)
-        , ("(float64 = void)", Type'float64)
-        , ("(text = void)", Type'text)
-        , ("(data = void)", Type'data_)
+        [ ("(bool = void)", Type Type'bool)
+        , ("(int8 = void)", Type Type'int8)
+        , ("(int16 = void)", Type Type'int16)
+        , ("(int32 = void)", Type Type'int32)
+        , ("(int64 = void)", Type Type'int64)
+        , ("(uint8 = void)", Type Type'uint8)
+        , ("(uint16 = void)", Type Type'uint16)
+        , ("(uint32 = void)", Type Type'uint32)
+        , ("(uint64 = void)", Type Type'uint64)
+        , ("(float32 = void)", Type Type'float32)
+        , ("(float64 = void)", Type Type'float64)
+        , ("(text = void)", Type Type'text)
+        , ("(data = void)", Type Type'data_)
         , ( "(list = (elementType = (list = (elementType = (text = void)))))"
-          , Type'list $ Type'list' $ Type'list $ Type'list' Type'text
+          , Type $ Type'list $ Type'list' $ Type $ Type'list $ Type'list' $ Type Type'text
           )
         , ( "(enum = (typeId = 4, brand = (scopes = [])))"
-          , Type'enum $ Type'enum' 4 (Brand [])
+          , Type $ Type'enum $ Type'enum' 4 (Brand [])
           )
         , ( "(struct = (typeId = 7, brand = (scopes = [])))"
-          , Type'struct $ Type'struct' 7 (Brand [])
+          , Type $ Type'struct $ Type'struct' 7 (Brand [])
           )
         , ( "(interface = (typeId = 1, brand = (scopes = [])))"
-          , Type'interface $ Type'interface' 1 (Brand [])
+          , Type $ Type'interface $ Type'interface' 1 (Brand [])
           )
         , ( "(anyPointer = (unconstrained = (anyKind = void)))"
-          , Type'anyPointer $ Type'anyPointer'unconstrained Type'anyPointer'unconstrained'anyKind
+          , Type $ Type'anyPointer $ Type'anyPointer' $ Type'anyPointer'unconstrained $
+                Type'anyPointer'unconstrained' Type'anyPointer'unconstrained'anyKind
           )
         , ( "(anyPointer = (unconstrained = (struct = void)))"
-          , Type'anyPointer $ Type'anyPointer'unconstrained Type'anyPointer'unconstrained'struct
+          , Type $ Type'anyPointer $ Type'anyPointer' $ Type'anyPointer'unconstrained $
+                Type'anyPointer'unconstrained' Type'anyPointer'unconstrained'struct
           )
         , ( "(anyPointer = (unconstrained = (list = void)))"
-          , Type'anyPointer $ Type'anyPointer'unconstrained Type'anyPointer'unconstrained'list
+          , Type $ Type'anyPointer $ Type'anyPointer' $ Type'anyPointer'unconstrained $
+                Type'anyPointer'unconstrained' Type'anyPointer'unconstrained'list
           )
         , ( "(anyPointer = (unconstrained = (capability = void)))"
-          , Type'anyPointer $ Type'anyPointer'unconstrained Type'anyPointer'unconstrained'capability
+          , Type $ Type'anyPointer $ Type'anyPointer' $ Type'anyPointer'unconstrained $
+                Type'anyPointer'unconstrained' Type'anyPointer'unconstrained'capability
           )
         , ( "(anyPointer = (parameter = (scopeId = 4, parameterIndex = 2)))"
-          , Type'anyPointer $ Type'anyPointer'parameter $ Type'anyPointer'parameter' 4 2
+          , Type $ Type'anyPointer $ Type'anyPointer' $
+                Type'anyPointer'parameter $ Type'anyPointer'parameter' 4 2
           )
         , ( "(anyPointer = (implicitMethodParameter = (parameterIndex = 7)))"
-          , Type'anyPointer $ Type'anyPointer'implicitMethodParameter $
+          , Type $ Type'anyPointer $ Type'anyPointer' $ Type'anyPointer'implicitMethodParameter $
                 Type'anyPointer'implicitMethodParameter' 7
           )
         ]
@@ -390,8 +392,8 @@
           , Brand
                 [ Brand'Scope 32 Brand'Scope'inherit
                 , Brand'Scope 23 $ Brand'Scope'bind
-                    [ Brand'Binding'unbound
-                    , Brand'Binding'type_ Type'bool
+                    [ Brand'Binding Brand'Binding'unbound
+                    , Brand'Binding $ Brand'Binding'type_ $ Type Type'bool
                     ]
                 ]
           )
@@ -401,38 +403,38 @@
     -- TODO: rename this: it's confusing to have both the top level and helper
     -- have the same name; not sure how that happened in the first place.
     decodeTests ::
-        ( Eq a
-        , Show a
-        , Decerialize a
-        , FromStruct 'Const a
-        ) => String -> [(String, a)] -> Spec
+        ( IsStruct a
+        , Parse a pa
+        , Eq pa
+        , Show pa
+        ) => String -> [(String, pa)] -> Spec
     decodeTests typename cases =
         describe ("Decode " ++ typename) $ traverse_ (testCase typename) cases
 
     testCase typename (capnpText, expected) =
         specify ("should agree with `capnp encode` on " ++ capnpText) $ do
             msg <- encodeValue schemaSchemaSrc typename capnpText
-            actual <- evalLimitT 128 $ getRoot msg
+            actual <- evalLimitT 128 $ msgToParsed msg
             ppAssertEqual actual expected
 
 decodeDefaultTests :: Spec
 decodeDefaultTests = describe "Decoding default values" $ do
-    decodeDefault "Type" (Proxy :: Proxy Type)
-    decodeDefault "Value" (Proxy :: Proxy Value)
-    decodeDefault "Node" (Proxy :: Proxy Node)
+    decodeDefault @Type "Type"
+    decodeDefault @Value "Value"
+    decodeDefault @Node "Node"
 
 decodeDefault ::
-    ( Show a
-    , Eq a
-    , Default a
-    , FromStruct 'Const a
-    , Cerialize RealWorld a
-    , ToStruct ('Mut RealWorld) (Cerial ('Mut RealWorld) a)
-    ) => String -> Proxy a -> Spec
-decodeDefault typename proxy =
+    forall a pa.
+    ( IsStruct a
+    , Parse a pa
+    , Show pa
+    , Eq pa
+    , Default pa
+    ) => String -> Spec
+decodeDefault typename =
     specify ("The empty struct decodes to the default value for " ++ typename) $ do
-        actual <- evalLimitT defaultLimit (getRoot M.empty)
-        ppAssertEqual (actual `asProxyTypeOf` proxy) def
+        actual <- evalLimitT defaultLimit (msgToParsed @a M.empty)
+        ppAssertEqual actual def
 
 ppAssertEqual :: (Show a, Eq a) => a -> a -> IO ()
 ppAssertEqual actual expected =
@@ -461,19 +463,25 @@
     propCase "CodeGeneratorRequest.RequestedFile.Import"
         (Proxy :: Proxy CodeGeneratorRequest'RequestedFile'Import)
 
+propCase ::
+    ( IsStruct a
+    , Parse a pa
+    , Arbitrary pa
+    , Show pa
+    , Eq pa
+    ) => String -> Proxy a -> Spec
 propCase name proxy = describe ("...for " ++ name) $ do
     specify "cerialize and decerialize are inverses." $
-        property (prop_cerializeDecerializeInverses proxy)
+        property (prop_encodeParseInverses proxy)
     specify "hPutValue and hGetValue are inverses." $
         property (prop_hGetPutInverses proxy)
 
 prop_hGetPutInverses ::
-    ( Show a
-    , Eq a
-    , FromStruct 'Const a
-    , Cerialize RealWorld a
-    , ToStruct ('Mut RealWorld) (Cerial ('Mut RealWorld) a)
-    ) => Proxy a -> a -> Property
+    ( IsStruct a
+    , Parse a pa
+    , Show pa
+    , Eq pa
+    ) => Proxy a -> pa -> Property
 prop_hGetPutInverses _proxy expected = propertyIO $ do
     -- This is a little more complicated than I'd like due to resource
     -- management issues. We create a temporary file, then immediately
@@ -482,33 +490,29 @@
     -- the handle.
     actual <- bracket
         (do
-            (filename, handle) <- openBinaryTempFile "/tmp" "hPutValue-output"
+            (filename, handle) <- openBinaryTempFile "/tmp" "hPutParsed-output"
             hClose handle
             pure filename)
         removeFile
         (\filename -> do
             withBinaryFile filename WriteMode
-                (`hPutValue` expected)
+                (`hPutParsed` expected)
             withBinaryFile filename ReadMode $ \h ->
-                hGetValue h defaultLimit)
+                hGetParsed h defaultLimit)
     ppAssertEqual actual expected
 
-prop_cerializeDecerializeInverses ::
-    ( Show a
-    , Eq a
-    , Cerialize RealWorld a
-    , FromStruct 'Const (Cerial 'Const a)
-    , ToStruct ('Mut RealWorld) (Cerial ('Mut RealWorld) a)
-    , Allocate RealWorld (Cerial ('M.Mut RealWorld) a)
-    ) => Proxy a -> a -> Property
-prop_cerializeDecerializeInverses _proxy expected = propertyIO $ do
+prop_encodeParseInverses ::
+    ( IsStruct a
+    , Parse a pa
+    , Eq pa
+    , Show pa
+    ) => Proxy a -> pa -> Property
+prop_encodeParseInverses _proxy expected = propertyIO $ do
     actual <- evalLimitT maxBound $ do
         -- TODO: add some helpers for all this.
         msg <- M.newMessage Nothing
-        cerialOut <- cerialize msg expected
-        setRoot cerialOut
+        Raw cerialOut <- encode msg expected
+        U.setRoot cerialOut
         constMsg :: M.Message 'Const <- freeze msg
-        root <- U.rootPtr constMsg
-        cerialIn <- fromStruct root
-        decerialize cerialIn
+        msgToParsed constMsg
     ppAssertEqual actual expected
diff --git a/tests/Module/Capnp/Rpc.hs b/tests/Module/Capnp/Rpc.hs
--- a/tests/Module/Capnp/Rpc.hs
+++ b/tests/Module/Capnp/Rpc.hs
@@ -2,8 +2,11 @@
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE NamedFieldPuns        #-}
+{-# LANGUAGE OverloadedLabels      #-}
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE ScopedTypeVariables   #-}
+{-# LANGUAGE TypeApplications      #-}
+{-# LANGUAGE TypeFamilies          #-}
 {-# OPTIONS_GHC -Wno-error=missing-methods #-}
 module Module.Capnp.Rpc (rpcTests) where
 
@@ -17,7 +20,9 @@
 import Control.Monad.Catch      (throwM)
 import Control.Monad.IO.Class   (liftIO)
 import Data.Foldable            (for_)
+import Data.Function            ((&))
 import Data.Mutable             (freeze)
+import Data.Traversable         (for)
 import System.Timeout           (timeout)
 
 import qualified Data.ByteString.Builder as BB
@@ -25,25 +30,37 @@
 import qualified Network.Socket          as Socket
 import qualified Supervisors
 
-import Capnp
-    ( createPure
+import Capnp.Bits       (WordCount)
+import Capnp.New
+    ( Client
+    , IsCap
+    , Parse(..)
+    , Pipeline
+    , SomeServer
+    , TypeParam
+    , Which
+    , callP
+    , callR
+    , createPure
     , def
     , defaultLimit
     , evalLimitT
+    , export
+    , handleParsed
     , lbsToMsg
-    , msgToValue
-    , valueToMsg
+    , msgToParsed
+    , parsedToMsg
+    , waitPipeline
     )
-import Capnp.Bits       (WordCount)
 import Capnp.Rpc.Errors (eFailed)
 
-import Capnp.Gen.Aircraft.Pure  hiding (Left, Right)
-import Capnp.Gen.Capnp.Rpc.Pure
-import Capnp.Rpc
-import Capnp.Rpc.Untyped
+import Capnp.Gen.Aircraft.New  hiding (Left, Right)
+import Capnp.Gen.Capnp.Rpc.New
+import Capnp.Rpc               hiding (Client)
+import Capnp.Rpc.Untyped       hiding (Client, Pipeline, export, waitPipeline)
 
-import qualified Capnp.Gen.Echo.Pure as E
-import qualified Capnp.Pointer       as P
+import qualified Capnp.Gen.Echo.New as E
+import qualified Capnp.Pointer      as P
 
 rpcTests :: Spec
 rpcTests = do
@@ -58,13 +75,16 @@
 echoTests :: Spec
 echoTests = describe "Echo server & client" $
     it "Should echo back the same message." $ runVatPair
-        (`E.export_Echo` TestEchoServer)
+        (\sup -> export @E.Echo sup TestEchoServer)
         (\_sup echoSrv -> do
                 let msgs =
                         [ def { E.query = "Hello #1" }
                         , def { E.query = "Hello #2" }
                         ]
-                rets <- traverse ((E.echo'echo echoSrv ?) >=> wait) msgs
+                rets <- for msgs $ \arg -> echoSrv
+                    & callP #echo arg
+                    >>= waitPipeline
+                    >>= evalLimitT defaultLimit . parse
                 liftIO $ rets `shouldBe`
                     [ def { E.reply = "Hello #1" }
                     , def { E.reply = "Hello #2" }
@@ -73,9 +93,9 @@
 
 data TestEchoServer = TestEchoServer
 
-instance Server IO TestEchoServer
-instance E.Echo'server_ IO TestEchoServer where
-    echo'echo = pureHandler $ \_ params -> pure def { E.reply = E.query params }
+instance SomeServer TestEchoServer
+instance E.Echo'server_ TestEchoServer where
+    echo'echo _ = handleParsed $ \params -> pure def { E.reply = E.query params }
 
 -------------------------------------------------------------------------------
 -- Tests using aircraft.capnp.
@@ -84,12 +104,14 @@
 -------------------------------------------------------------------------------
 
 -- | Bump a counter n times, returning a list of the results.
-bumpN :: CallSequence -> Int -> IO [CallSequence'getNumber'results]
-bumpN ctr n = bumpNPromise ctr n >>= traverse wait
+bumpN :: Client CallSequence -> Int -> IO [Parsed CallSequence'getNumber'results]
+bumpN ctr n = bumpNPipeline ctr n
+    >>= traverse waitPipeline
+    >>= traverse (evalLimitT defaultLimit . parse)
 
--- | Like 'bumpN', but doesn't wait for the results -- returns a list of promises.
-bumpNPromise :: CallSequence -> Int -> IO [Promise CallSequence'getNumber'results]
-bumpNPromise ctr n = replicateM n (callSequence'getNumber ctr ? def)
+-- | Like 'bumpN', but doesn't wait for the results -- returns a list of pipelines.
+bumpNPipeline :: Client CallSequence -> Int -> IO [Pipeline CallSequence'getNumber'results]
+bumpNPipeline ctr n = replicateM n (ctr & callR #getNumber def)
 
 aircraftTests :: Spec
 aircraftTests = describe "aircraft.capnp rpc tests" $ do
@@ -97,12 +119,13 @@
         it "Should preserve E-order" $
             Supervisors.withSupervisor $ \sup -> do
                 (pc, f) <- newPromiseClient
-                firsts <- bumpNPromise pc 2
+                firsts <- bumpNPipeline pc 2
                 atomically (newTestCtr 0)
-                    >>= export_CallSequence sup
+                    >>= export @CallSequence sup
                     >>= fulfill f
                 nexts <- bumpN pc 2
-                firstsResolved <- traverse wait firsts
+                firstsResolved <- for firsts $
+                    waitPipeline >=> evalLimitT defaultLimit . parse
                 firstsResolved `shouldBe`
                     [ def { n = 1 }
                     , def { n = 2 }
@@ -112,43 +135,43 @@
                     , def { n = 4 }
                     ]
     it "Should propogate server-side exceptions to client method calls" $ runVatPair
-        (`export_CallSequence` ExnCtrServer)
+        (\sup -> export @CallSequence sup ExnCtrServer)
         (\_sup -> expectException
-            (\cap -> callSequence'getNumber cap ? def)
+            (callR #getNumber def)
             def
                 { type_ = Exception'Type'failed
                 , reason = "Something went sideways."
                 }
         )
     it "Should receive unimplemented when calling a method on a null cap." $ runVatPair
-        (\_sup -> pure $ CallSequence nullClient)
+        (\_sup -> pure (fromClient nullClient :: Client CallSequence))
         (\_sup -> expectException
-            (\cap -> callSequence'getNumber cap ? def)
+            (callR #getNumber def)
             def
                 { type_ = Exception'Type'unimplemented
                 , reason = "Method unimplemented"
                 }
         )
     it "Should throw an unimplemented exception if the server doesn't implement a method" $ runVatPair
-        (`export_CallSequence` NoImplServer)
+        (\sup -> export @CallSequence sup NoImplServer)
         (\_sup -> expectException
-            (\cap -> callSequence'getNumber cap ? def)
+            (callR #getNumber def)
             def
                 { type_ = Exception'Type'unimplemented
                 , reason = "Method unimplemented"
                 }
         )
     it "Should throw an opaque exception when the server throws a non-rpc exception" $ runVatPair
-        (`export_CallSequence` NonRpcExnServer)
+        (\sup -> export @CallSequence sup NonRpcExnServer)
         (\_sup -> expectException
-            (\cap -> callSequence'getNumber cap ? def)
+            (callR #getNumber def)
             def
                 { type_ = Exception'Type'failed
                 , reason = "Unhandled exception"
                 }
         )
     it "A counter should maintain state" $ runVatPair
-        (\sup -> newTestCtr 0 >>= export_CallSequence sup)
+        (\sup -> newTestCtr 0 >>= export @CallSequence sup)
         (\_sup ctr -> do
             results <- bumpN ctr 4
             liftIO $ results `shouldBe`
@@ -159,12 +182,13 @@
                 ]
         )
     it "Methods returning interfaces work" $ runVatPair
-        (\sup -> export_CounterFactory sup (TestCtrFactory sup))
+        (\sup -> export @CounterFactory sup (TestCtrFactory sup))
         (\_sup factory -> do
             let newCounter start = do
                     CounterFactory'newCounter'results{counter} <-
-                        counterFactory'newCounter factory ? def { start }
-                        >>= wait
+                        factory & callP #newCounter def { start }
+                        >>= waitPipeline
+                        >>= evalLimitT defaultLimit . parse
                     pure counter
 
             ctrA <- newCounter 2
@@ -201,12 +225,13 @@
         ctrB <- atomically $ newTestCtr 0
         ctrC <- atomically $ newTestCtr 30
         runVatPair
-            (`export_CounterAcceptor` TestCtrAcceptor)
+            (\sup -> export @CounterAcceptor sup TestCtrAcceptor)
             (\sup acceptor -> do
                 for_ [ctrA, ctrB, ctrC] $ \ctrSrv -> do
-                    ctr <- atomically $ export_CallSequence sup ctrSrv
-                    counterAcceptor'accept acceptor ? CounterAcceptor'accept'params { counter = ctr }
-                        >>= wait
+                    ctr <- atomically $ export @CallSequence sup ctrSrv
+                    acceptor
+                        & callP #accept CounterAcceptor'accept'params { counter = ctr }
+                        >>= waitPipeline @CounterAcceptor'accept'results
                 r <- traverse
                     (\(TestCtrServer var) -> liftIO $ readTVarIO var)
                     [ctrA, ctrB, ctrC]
@@ -215,10 +240,10 @@
 
 data TestCtrAcceptor = TestCtrAcceptor
 
-instance Server IO TestCtrAcceptor
-instance CounterAcceptor'server_ IO TestCtrAcceptor where
-    counterAcceptor'accept =
-        pureHandler $ \_ CounterAcceptor'accept'params{counter} -> do
+instance SomeServer TestCtrAcceptor
+instance CounterAcceptor'server_ TestCtrAcceptor where
+    counterAcceptor'accept _ =
+        handleParsed $ \CounterAcceptor'accept'params{counter} -> do
             [start] <- map n <$> bumpN counter 1
             r <- bumpN counter 4
             liftIO $ r `shouldBe`
@@ -235,11 +260,11 @@
 
 newtype TestCtrFactory = TestCtrFactory { sup :: Supervisor }
 
-instance Server IO TestCtrFactory
-instance CounterFactory'server_ IO TestCtrFactory where
-    counterFactory'newCounter =
-        pureHandler $ \TestCtrFactory{sup} CounterFactory'newCounter'params{start} -> do
-            ctr <- atomically $ newTestCtr start >>= export_CallSequence sup
+instance SomeServer TestCtrFactory
+instance CounterFactory'server_ TestCtrFactory where
+    counterFactory'newCounter TestCtrFactory{sup} =
+        handleParsed $ \CounterFactory'newCounter'params{start} -> do
+            ctr <- atomically $ newTestCtr start >>= export @CallSequence sup
             pure CounterFactory'newCounter'results { counter = ctr }
 
 newTestCtr :: Word32 -> STM TestCtrServer
@@ -247,20 +272,21 @@
 
 newtype TestCtrServer = TestCtrServer (TVar Word32)
 
-instance Server IO TestCtrServer
-instance CallSequence'server_ IO TestCtrServer  where
-    callSequence'getNumber = pureHandler $ \(TestCtrServer tvar) _ -> do
-        ret <- liftIO $ atomically $ do
-            modifyTVar' tvar (+1)
-            readTVar tvar
-        pure def { n = ret }
+instance SomeServer TestCtrServer
+instance CallSequence'server_ TestCtrServer  where
+    callSequence'getNumber (TestCtrServer tvar) =
+        handleParsed $ \_ -> do
+            ret <- liftIO $ atomically $ do
+                modifyTVar' tvar (+1)
+                readTVar tvar
+            pure def { n = ret }
 
 -- a 'CallSequence' which always throws an exception.
 data ExnCtrServer = ExnCtrServer
 
-instance Server IO ExnCtrServer
-instance CallSequence'server_ IO ExnCtrServer where
-    callSequence'getNumber = pureHandler $ \_ _ ->
+instance SomeServer ExnCtrServer
+instance CallSequence'server_ ExnCtrServer where
+    callSequence'getNumber _ = handleParsed $ \_ ->
         throwM def
             { type_ = Exception'Type'failed
             , reason = "Something went sideways."
@@ -269,15 +295,15 @@
 -- a 'CallSequence' which doesn't implement its methods.
 data NoImplServer = NoImplServer
 
-instance Server IO NoImplServer
-instance CallSequence'server_ IO NoImplServer -- TODO: can we silence the warning somehow?
+instance SomeServer NoImplServer
+instance CallSequence'server_ NoImplServer -- TODO: can we silence the warning somehow?
 
 -- Server that throws some non-rpc exception.
 data NonRpcExnServer = NonRpcExnServer
 
-instance Server IO NonRpcExnServer
-instance CallSequence'server_ IO NonRpcExnServer where
-    callSequence'getNumber = pureHandler $ \_ _ -> error "OOPS"
+instance SomeServer NonRpcExnServer
+instance CallSequence'server_ NonRpcExnServer where
+    callSequence'getNumber _ = handleParsed $ \_ -> error "OOPS"
 
 -------------------------------------------------------------------------------
 -- Tests for unusual patterns of messages .
@@ -301,23 +327,24 @@
             ret <- try $ concurrently_
                 (handleConn (vatTrans defaultLimit) def { debugMode = True})
                 $ do
-                    msg <- createPure maxBound $ valueToMsg $ Message'abort exn
+                    msg <- createPure maxBound $ parsedToMsg $ Message $ Message'abort exn
                     sendMsg (probeTrans defaultLimit) msg
             ret `shouldBe` Left (ReceivedAbort exn)
-    triggerAbort (Message'unimplemented $ Message'abort def) $
+    triggerAbort (Message'unimplemented $ Message $ Message'abort def) $
         "Your vat sent an 'unimplemented' message for an abort message " <>
         "that its remote peer never sent. This is likely a bug in your " <>
         "capnproto library."
     triggerAbort
-        (Message'call def
-            { target = MessageTarget'importedCap 443
-            }
+        (Message'call (def
+            { target = MessageTarget $ MessageTarget'importedCap 443
+            } :: Parsed Call)
         )
         "No such export: 443"
     triggerAbort
-        (Message'call def
-            { target = MessageTarget'promisedAnswer def { questionId=300 }
-            }
+        (Message'call (def
+            { target = MessageTarget $
+                MessageTarget'promisedAnswer (def { questionId=300 } :: Parsed PromisedAnswer)
+            } :: Parsed Call)
         )
         "No such answer: 300"
     triggerAbort
@@ -347,8 +374,8 @@
                     msg <- lbsToMsg lbs
                     sendMsg (probeTrans defaultLimit) msg
                     msg' <- recvMsg (probeTrans defaultLimit)
-                    resp <- msgToValue msg'
-                    resp `shouldBe` Message'abort wantAbortExn
+                    resp <- evalLimitT maxBound $ msgToParsed msg'
+                    resp `shouldBe` Message (Message'abort wantAbortExn)
                 )
     it "Should respond with an abort if erroneously sent return = resultsSentElsewhere" $
 
@@ -362,16 +389,17 @@
                         handleConn (vatTrans defaultLimit) def
                             { debugMode = True
                             , withBootstrap = Just $ \_sup client ->
-                                let ctr :: CallSequence = fromClient client
-                                in void $ (callSequence'getNumber ctr ? def) >>= wait
+                                let ctr :: Client CallSequence = fromClient client
+                                in void $ (ctr & callR #getNumber def) >>= waitPipeline
                             }
                     e `shouldBe` SentAbort wantExn
                 )
                 (do
                     let send msg =
-                            evalLimitT maxBound (valueToMsg msg >>= freeze)
+                            evalLimitT maxBound (parsedToMsg msg >>= freeze)
                             >>= sendMsg (probeTrans defaultLimit)
-                        recv = recvMsg (probeTrans defaultLimit) >>= msgToValue
+                        recv = recvMsg (probeTrans defaultLimit)
+                                >>= evalLimitT maxBound . msgToParsed
                     Message'bootstrap Bootstrap{} <- recv
                     Message'call Call{questionId} <- recv
                     send $ Message'return def
@@ -386,15 +414,16 @@
         race_
             (handleConn (vatTrans defaultLimit) def { debugMode = True })
             $ do
-                msg <- createPure maxBound $ valueToMsg $ Message'join def
+                msg <- createPure maxBound $ parsedToMsg $ Message'join def
                 sendMsg (probeTrans defaultLimit) msg
-                msg' <- recvMsg (probeTrans defaultLimit) >>= msgToValue
-                msg' `shouldBe` Message'unimplemented (Message'join def)
+                msg' <- recvMsg (probeTrans defaultLimit)
+                        >>= evalLimitT maxBound . msgToParsed
+                msg' `shouldBe` Message (Message'unimplemented (Message (Message'join def)))
 
 
 -- | Verify that the given message triggers an abort with the specified 'reason'
 -- field.
-triggerAbort :: Message -> T.Text -> Spec
+triggerAbort :: Parsed (Which Message) -> T.Text -> Spec
 triggerAbort msg reason =
     it ("Should abort when sent the message " ++ show msg ++ " on startup") $ do
         let wantAbortExn = def
@@ -408,7 +437,7 @@
                     ret `shouldBe` Left (SentAbort wantAbortExn)
                 )
                 (do
-                    rawMsg <- createPure maxBound $ valueToMsg msg
+                    rawMsg <- createPure maxBound $ parsedToMsg msg
                     sendMsg (probeTrans defaultLimit) rawMsg
                     -- 4 second timeout. The remote vat's timeout before killing the
                     -- connection is one second, so if this happens we're never going
@@ -419,8 +448,8 @@
                         Nothing ->
                             error "Test timed out waiting on abort message."
                         Just rawResp -> do
-                            resp <- msgToValue rawResp
-                            resp `shouldBe` Message'abort wantAbortExn
+                            resp <- evalLimitT maxBound $ msgToParsed rawResp
+                            resp `shouldBe` Message (Message'abort wantAbortExn)
                 )
 
 -------------------------------------------------------------------------------
@@ -456,11 +485,14 @@
             }
     race_ runServer runClient
 
-expectException :: Show a => (cap -> IO (Promise a)) -> Exception -> cap -> IO ()
+expectException
+    :: (IsCap c, TypeParam a, Parse a pa, Show pa)
+    => (Client c -> IO (Pipeline a)) -> Parsed Exception -> Client c -> IO ()
 expectException callFn wantExn cap = do
-    ret <- try $ callFn cap >>= wait
+    ret <- try $ callFn cap >>= waitPipeline
     case ret of
-        Left (e :: Exception) ->
+        Left (e :: Parsed Exception) ->
             liftIO $ e `shouldBe` wantExn
-        Right val ->
-            error $ "Should have received exn, but got " ++ show val
+        Right val -> do
+            parsed <- evalLimitT defaultLimit (parse val)
+            error $ "Should have received exn, but got " ++ show parsed
diff --git a/tests/Module/Capnp/Untyped.hs b/tests/Module/Capnp/Untyped.hs
--- a/tests/Module/Capnp/Untyped.hs
+++ b/tests/Module/Capnp/Untyped.hs
@@ -1,10 +1,12 @@
 {-# LANGUAGE DataKinds             #-}
 {-# LANGUAGE DuplicateRecordFields #-}
 {-# LANGUAGE FlexibleContexts      #-}
+{-# LANGUAGE OverloadedLabels      #-}
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE QuasiQuotes           #-}
 {-# LANGUAGE RecordWildCards       #-}
 {-# LANGUAGE ScopedTypeVariables   #-}
+{-# LANGUAGE TypeApplications      #-}
 -- The tests have a number of cases where we do stuff like:
 --
 -- let 4 = ...
@@ -21,6 +23,7 @@
 import Control.Monad           (forM_, when)
 import Control.Monad.Primitive (RealWorld)
 import Data.Foldable           (traverse_)
+import Data.Function           ((&))
 import Data.Text               (Text)
 import GHC.Float               (castDoubleToWord64, castWord64ToDouble)
 import Test.QuickCheck         (property)
@@ -33,18 +36,17 @@
 import Capnp.Untyped
 import Util
 
-import Capnp                (cerialize, createPure, def, getRoot, newRoot)
+import Capnp.New
+    (createPure, def, encode, msgToParsed, newRoot, setField)
 import Capnp.TraversalLimit (LimitT, evalLimitT, execLimitT)
-import Data.Mutable         (Thaw (..))
+import Data.Mutable         (Thaw(..))
 
 import Instances ()
 
-import Capnp.Gen.Capnp.Schema.Pure (Brand, Method (..), Node'Parameter)
+import Capnp.Gen.Capnp.Schema.New
 
-import qualified Capnp.Classes as C
 import qualified Capnp.Message as M
-
-import qualified Capnp.Gen.Capnp.Schema as Schema
+import qualified Capnp.Repr    as R
 
 untypedTests :: Spec
 untypedTests = describe "low-level untyped API tests" $ do
@@ -311,13 +313,13 @@
             srcStruct <- allocStruct msg 4 4
             (1, _) <- M.newSegment msg 10
             dstStruct <- allocStruct msg 2 2
-            ptr <- C.toPtr msg dstStruct
+            let ptr = R.toPtr @('Just 'R.Struct) dstStruct
             setPtr ptr 0 srcStruct
 
 otherMessageTest :: Spec
 otherMessageTest = describe "Setting pointers in other messages" $
     it "Should copy them if needed." $
-        property $ \(name :: Text) (params :: V.Vector Node'Parameter) (brand :: Brand) ->
+        property $ \(name :: Text) (params :: V.Vector (Parsed Node'Parameter)) (brand :: Parsed Brand) ->
             propertyIO $ do
                 let expected = def
                         { name = name
@@ -330,19 +332,15 @@
                         paramsMsg <- M.newMessage Nothing
                         brandMsg <- M.newMessage Nothing
 
-                        methodCerial <- newRoot methodMsg
-                        nameCerial <- cerialize nameMsg name
-                        brandCerial <- cerialize brandMsg brand
-
-                        -- We don't implement Cerialize for Vector, so we can't just
-                        -- inject params directly. TODO: implement Cerialize for Vector.
-                        wrapper <- cerialize paramsMsg expected
-                        paramsCerial <- Schema.get_Method'implicitParameters wrapper
+                        methodCerial <- newRoot @Method () methodMsg
+                        nameCerial <- encode nameMsg name
+                        brandCerial <- encode brandMsg brand
+                        paramsCerial <- encode paramsMsg params
 
-                        Schema.set_Method'name methodCerial nameCerial
-                        Schema.set_Method'implicitParameters methodCerial paramsCerial
-                        Schema.set_Method'paramBrand methodCerial brandCerial
+                        methodCerial & setField #name nameCerial
+                        methodCerial & setField #implicitParameters paramsCerial
+                        methodCerial & setField #paramBrand brandCerial
 
                         pure methodMsg
-                actual <- evalLimitT maxBound $ getRoot msg >>= C.decerialize
+                actual <- evalLimitT maxBound $ msgToParsed msg
                 actual `shouldBe` expected
diff --git a/tests/Module/Capnp/Untyped/Pure.hs b/tests/Module/Capnp/Untyped/Pure.hs
--- a/tests/Module/Capnp/Untyped/Pure.hs
+++ b/tests/Module/Capnp/Untyped/Pure.hs
@@ -11,14 +11,11 @@
 
 import qualified Data.Vector as V
 
-import Capnp.Untyped.Pure
+import Capnp.New.Basics
 import Util
 
-import Capnp.Classes        (decerialize)
-import Capnp.TraversalLimit (LimitT, runLimitT)
-
-import qualified Capnp.Message as M
-import qualified Capnp.Untyped as U
+import Capnp.New            (msgToRaw, parse)
+import Capnp.TraversalLimit (runLimitT)
 
 -- This is analogous to Tests.Module.Capnp.Untyped.untypedTests, but
 -- using the Pure module:
@@ -37,7 +34,7 @@
                            capacity = 5173,
                            maxSpeed = 12.0
                         )))|]
-            (actual, 117) <- runLimitT 128 $ U.rootPtr msg >>= readStruct
+            (actual, 117) <- runLimitT 128 $ msgToRaw msg >>= parse
             actual `shouldBe` Struct
                 [3]
                 [ Just $ PtrStruct $ Struct
@@ -53,6 +50,3 @@
                         ]
                     ]
                 ]
-  where
-    readStruct :: U.Struct 'M.Const -> LimitT IO Struct
-    readStruct = decerialize
diff --git a/tests/PointerOOB.hs b/tests/PointerOOB.hs
--- a/tests/PointerOOB.hs
+++ b/tests/PointerOOB.hs
@@ -9,9 +9,9 @@
 import Data.Foldable          (for_)
 import Data.Function          ((&))
 
-import qualified Capnp
 import qualified Capnp.Errors  as E
 import qualified Capnp.Message as M
+import qualified Capnp.New     as Capnp
 import qualified Capnp.Pointer as P
 import qualified Capnp.Untyped as U
 
diff --git a/tests/Regression.hs b/tests/Regression.hs
--- a/tests/Regression.hs
+++ b/tests/Regression.hs
@@ -5,10 +5,10 @@
 
 import Test.Hspec
 
-import Capnp (bsToValue, def)
+import Capnp.New (bsToParsed, def, evalLimitT)
 
-import Capnp.Gen.Aircraft.Pure
-import Capnp.Gen.Capnp.Rpc.Pure
+import Capnp.Gen.Aircraft.New
+import Capnp.Gen.Capnp.Rpc.New
 
 regressionTests :: Spec
 regressionTests = describe "Regression tests" $ do
@@ -20,14 +20,14 @@
                 "\NUL\NULz\EOT\NUL\NULYour vat sent an 'unimplemented' " <>
                 "message for an abort message that its remote peer never " <>
                 "sent. This is likely a bug in your capnproto library.\NUL\NUL"
-        msg <- bsToValue bytes
-        msg `shouldBe` Message'abort def
+        msg <- evalLimitT maxBound $ bsToParsed bytes
+        msg `shouldBe` Message (Message'abort def
             { reason =
                 "Your vat sent an 'unimplemented' message for an abort " <>
                 "message that its remote peer never sent. This is likely " <>
                 "a bug in your capnproto library."
             , type_ = Exception'Type'failed
-            }
+            })
     it "Should decode negative default values correctly (issue #55)" $ do
         -- Note that this was never actually broken, but we were getting
         -- a warning about a literal overflowing the bounds of its type.
diff --git a/tests/Rpc/Unwrap.hs b/tests/Rpc/Unwrap.hs
--- a/tests/Rpc/Unwrap.hs
+++ b/tests/Rpc/Unwrap.hs
@@ -1,6 +1,7 @@
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE ScopedTypeVariables   #-}
+{-# LANGUAGE TypeApplications      #-}
 module Rpc.Unwrap (unwrapTests) where
 
 import Test.Hspec
@@ -9,26 +10,28 @@
 
 import Data.Typeable (Typeable)
 
-import qualified Capnp.Gen.Aircraft.Pure as Aircraft
-import qualified Capnp.Rpc               as Rpc
+import qualified Capnp.Gen.Aircraft.New as Aircraft
+import           Capnp.New
+    (SomeServer(..), export, methodUnimplemented)
+import qualified Capnp.Rpc              as Rpc
 import qualified Supervisors
 
 data OpaqueEcho = OpaqueEcho
     deriving(Show, Read, Eq, Ord, Enum, Bounded)
 
-instance Rpc.Server IO OpaqueEcho
+instance SomeServer OpaqueEcho
 
-instance Aircraft.Echo'server_ IO OpaqueEcho where
-    echo'echo _ = Rpc.methodUnimplemented
+instance Aircraft.Echo'server_ OpaqueEcho where
+    echo'echo _ = methodUnimplemented
 
 newtype TransparentEcho = TransparentEcho Int
     deriving(Show, Read, Eq, Ord, Bounded, Typeable)
 
-instance Rpc.Server IO TransparentEcho where
+instance SomeServer TransparentEcho where
     unwrap = Typeable.cast
 
-instance Aircraft.Echo'server_ IO TransparentEcho where
-    echo'echo _ = Rpc.methodUnimplemented
+instance Aircraft.Echo'server_ TransparentEcho where
+    echo'echo _ = methodUnimplemented
 
 
 unwrapTests :: Spec
@@ -43,7 +46,7 @@
         r <- exportAndUnwrap (TransparentEcho 4)
         r `shouldBe` Just (TransparentEcho 4)
 
-exportAndUnwrap :: (Aircraft.Echo'server_ IO a, Typeable b) => a -> IO (Maybe b)
+exportAndUnwrap :: (SomeServer a, Aircraft.Echo'server_ a, Typeable b) => a -> IO (Maybe b)
 exportAndUnwrap srv = Supervisors.withSupervisor $ \sup -> do
-    client <- Aircraft.export_Echo sup srv
+    client <- export @Aircraft.Echo sup srv
     pure $ Rpc.unwrapServer client
diff --git a/tests/SchemaQuickCheck.hs b/tests/SchemaQuickCheck.hs
--- a/tests/SchemaQuickCheck.hs
+++ b/tests/SchemaQuickCheck.hs
@@ -1,20 +1,17 @@
 {-# LANGUAGE DataKinds           #-}
 {-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications    #-}
 module SchemaQuickCheck
     (schemaCGRQuickCheck)
     where
 
 import qualified Data.ByteString as BS
 
-import Capnp.Bits           (WordCount)
-import Capnp.Classes        (fromStruct)
+import Capnp.Convert        (bsToParsed)
 import Capnp.Errors         (Error)
-import Capnp.Message        as M
-import Capnp.TraversalLimit (LimitT, runLimitT)
+import Capnp.TraversalLimit (defaultLimit, evalLimitT)
 
-import qualified Capnp.Basics           as Basics
-import qualified Capnp.Gen.Capnp.Schema as Schema
-import qualified Capnp.Untyped          as Untyped
+import qualified Capnp.Gen.Capnp.Schema.New as Schema
 
 -- Testing framework imports
 import Test.Hspec
@@ -34,17 +31,10 @@
 
 -- Functions to validate CGRs
 
-decodeCGR :: BS.ByteString -> IO (WordCount, Int)
+decodeCGR :: BS.ByteString -> IO ()
 decodeCGR bytes = do
-    let reader :: Untyped.Struct 'M.Const -> LimitT IO Int
-        reader struct = do
-            req :: Schema.CodeGeneratorRequest 'M.Const <- fromStruct struct
-            nodes <- Schema.get_CodeGeneratorRequest'nodes req
-            _ <- Schema.get_CodeGeneratorRequest'requestedFiles req
-            return (Basics.length nodes)
-    msg <- M.decode bytes
-    (numNodes, endQuota) <- runLimitT 1024 (Untyped.rootPtr msg >>= reader)
-    return (endQuota, numNodes)
+    _ <- evalLimitT defaultLimit (bsToParsed @Schema.CodeGeneratorRequest bytes)
+    pure ()
 
 -- QuickCheck properties
 
@@ -52,7 +42,7 @@
 prop_schemaValid schema = ioProperty $ do
     compiled <- generateCGR schema
     decoded <- try $ decodeCGR compiled
-    return $ case (decoded :: Either Error (WordCount, Int)) of
+    return $ case (decoded :: Either Error ()) of
         Left _  -> False
         Right _ -> True
 
diff --git a/tests/WalkSchemaCodeGenRequest.hs b/tests/WalkSchemaCodeGenRequest.hs
--- a/tests/WalkSchemaCodeGenRequest.hs
+++ b/tests/WalkSchemaCodeGenRequest.hs
@@ -1,7 +1,9 @@
 {-# LANGUAGE DataKinds           #-}
 {-# LANGUAGE FlexibleContexts    #-}
+{-# LANGUAGE OverloadedLabels    #-}
 {-# LANGUAGE OverloadedStrings   #-}
 {-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeFamilies        #-}
 -- | This module defines a test that tries to walk over the
 -- CodeGeneratorRequest in `tests/data/schema-codegenreq`,
 -- failing if any of the data is not as expected.
@@ -15,18 +17,17 @@
 
 import Control.Monad             (when)
 import Control.Monad.Trans.Class (lift)
+import Data.Function             ((&))
 
 import qualified Data.ByteString as BS
 import qualified Data.Vector     as V
 
-import Capnp.Untyped hiding (index, length)
-
-import Capnp.Basics         (index, length, textBytes)
-import Capnp.Classes        (fromStruct)
-import Capnp.TraversalLimit (LimitT, execLimitT)
+import Capnp.New
+    (Raw, bsToRaw, hasField, index, length, parseField, readField, textBytes)
+import Capnp.TraversalLimit (LimitT, evalLimitT, execLimitT)
 
-import qualified Capnp.Gen.Capnp.Schema as Schema
-import qualified Capnp.Message          as M
+import qualified Capnp.Gen.Capnp.Schema.New as Schema
+import qualified Capnp.Message              as M
 
 nodeNames :: V.Vector BS.ByteString
 nodeNames = V.fromList
@@ -51,40 +52,39 @@
             -- It would be nice if we could mark off individual checks for
             -- hspec's reporting somehow.
             bytes <- BS.readFile "tests/data/schema-codegenreq"
-            msg <- M.decode bytes
-            endQuota <- execLimitT 4096 (rootPtr msg >>= reader)
-            endQuota `shouldBe` 3372
+            root <- evalLimitT maxBound (bsToRaw bytes)
+            endQuota <- execLimitT 4096 (reader root)
+            endQuota `shouldBe` 3374
   where
-    reader :: Struct 'M.Const -> LimitT IO ()
-    reader root = do
-        req :: Schema.CodeGeneratorRequest 'M.Const <- fromStruct root
-        nodes <- Schema.get_CodeGeneratorRequest'nodes req
-        requestedFiles <- Schema.get_CodeGeneratorRequest'requestedFiles req
+    reader :: Raw 'M.Const Schema.CodeGeneratorRequest -> LimitT IO ()
+    reader req = do
+        nodes <- req & readField #nodes
+        requestedFiles <- req & readField #requestedFiles
         lift $ length nodes `shouldBe` 37
         lift $ length requestedFiles `shouldBe` 1
         mapM_ (walkNode nodes) [0,1..36]
     walkNode nodes i = do
         node <- index i nodes
         -- None of the nodes in the schema have parameters:
-        False <- Schema.has_Node'parameters node
+        False <- node & hasField #parameters
         -- And none of them are generic:
-        False <- Schema.get_Node'isGeneric node
+        False <- node & parseField #isGeneric
 
-        nameList <- Schema.get_Node'displayName node
+        nameList <- node & readField #displayName
         name <- textBytes nameList
-        prefixLen <- Schema.get_Node'displayNamePrefixLength node
+        prefixLen <- parseField #displayNamePrefixLength node
         let baseName = BS.drop (fromIntegral prefixLen) name
 
         when (i < V.length nodeNames && baseName /= (nodeNames V.! i)) $
             error "Incorrect name."
 
-        has <- Schema.has_Node'annotations node
+        has <- node & hasField #annotations
 
         -- there are two annotations in all of the nodes, at these indicies:
         case (has, i `elem` [4, 9]) of
             (False, False) -> return ()
             (True, True) -> do
-                1 <- length <$> Schema.get_Node'annotations node
+                1 <- length <$> readField #annotations node
                 return ()
             (False, True) ->
                 error $ "Node at index " ++ show i ++ " should have had" ++
