diff --git a/packages/protons-benchmark/src/implementations/protons/bench.ts b/packages/protons-benchmark/src/implementations/protons/bench.ts
index b07d9ba..5fe5130 100644
--- a/packages/protons-benchmark/src/implementations/protons/bench.ts
+++ b/packages/protons-benchmark/src/implementations/protons/bench.ts
@@ -6,12 +6,16 @@ export interface Foo {
   baz?: number
 }
 
+export interface FooInput {
+  baz?: number
+}
+
 export namespace Foo {
-  let _codec: Codec<Foo>
+  let _codec: Codec<Foo, FooInput>
 
-  export const codec = (): Codec<Foo> => {
+  export const codec = (): Codec<Foo, FooInput> => {
     if (_codec == null) {
-      _codec = message<Foo>((obj, w, opts = {}) => {
+      _codec = message<Foo, FooInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -92,7 +96,7 @@ export namespace Foo {
     value: number
   }
 
-  export function encode (obj: Partial<Foo>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: FooInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Foo.codec())
   }
 
@@ -109,12 +113,16 @@ export interface Bar {
   tmp?: Foo
 }
 
+export interface BarInput {
+  tmp?: FooInput
+}
+
 export namespace Bar {
-  let _codec: Codec<Bar>
+  let _codec: Codec<Bar, BarInput>
 
-  export const codec = (): Codec<Bar> => {
+  export const codec = (): Codec<Bar, BarInput> => {
     if (_codec == null) {
-      _codec = message<Bar>((obj, w, opts = {}) => {
+      _codec = message<Bar, BarInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -207,7 +215,7 @@ export namespace Bar {
     value: number
   }
 
-  export function encode (obj: Partial<Bar>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: BarInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Bar.codec())
   }
 
@@ -233,7 +241,7 @@ enum __FOOValues {
 }
 
 export namespace FOO {
-  export const codec = (): Codec<FOO> => {
+  export const codec = (): Codec<FOO, FOO> => {
     return enumeration<FOO>(__FOOValues)
   }
 }
@@ -242,12 +250,16 @@ export interface Yo {
   lol: FOO[]
 }
 
+export interface YoInput {
+  lol?: FOO[]
+}
+
 export namespace Yo {
-  let _codec: Codec<Yo>
+  let _codec: Codec<Yo, YoInput>
 
-  export const codec = (): Codec<Yo> => {
+  export const codec = (): Codec<Yo, YoInput> => {
     if (_codec == null) {
-      _codec = message<Yo>((obj, w, opts = {}) => {
+      _codec = message<Yo, YoInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -349,7 +361,7 @@ export namespace Yo {
     value: FOO
   }
 
-  export function encode (obj: Partial<Yo>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: YoInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Yo.codec())
   }
 
@@ -367,12 +379,17 @@ export interface Lol {
   b?: Bar
 }
 
+export interface LolInput {
+  lol?: string
+  b?: BarInput
+}
+
 export namespace Lol {
-  let _codec: Codec<Lol>
+  let _codec: Codec<Lol, LolInput>
 
-  export const codec = (): Codec<Lol> => {
+  export const codec = (): Codec<Lol, LolInput> => {
     if (_codec == null) {
-      _codec = message<Lol>((obj, w, opts = {}) => {
+      _codec = message<Lol, LolInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -496,7 +513,7 @@ export namespace Lol {
     value: number
   }
 
-  export function encode (obj: Partial<Lol>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: LolInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Lol.codec())
   }
 
@@ -516,12 +533,19 @@ export interface Test {
   payload?: Uint8Array<ArrayBuffer>
 }
 
+export interface TestInput {
+  meh?: LolInput
+  hello?: number
+  foo?: string
+  payload?: Uint8Array
+}
+
 export namespace Test {
-  let _codec: Codec<Test>
+  let _codec: Codec<Test, TestInput>
 
-  export const codec = (): Codec<Test> => {
+  export const codec = (): Codec<Test, TestInput> => {
     if (_codec == null) {
-      _codec = message<Test>((obj, w, opts = {}) => {
+      _codec = message<Test, TestInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -702,7 +726,7 @@ export namespace Test {
     value: Uint8Array<ArrayBuffer>
   }
 
-  export function encode (obj: Partial<Test>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: TestInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Test.codec())
   }
 
diff --git a/packages/protons-runtime/src/codec.ts b/packages/protons-runtime/src/codec.ts
index 83fbce3..6757322 100644
--- a/packages/protons-runtime/src/codec.ts
+++ b/packages/protons-runtime/src/codec.ts
@@ -16,7 +16,7 @@ export interface EncodeOptions {
 }
 
 export interface EncodeFunction<T> {
-  (value: Partial<T>, writer: Writer, opts?: EncodeOptions): void
+  (value: T, writer: Writer, opts?: EncodeOptions): void
 }
 
 // protobuf types that contain multiple values
@@ -63,15 +63,15 @@ export interface StreamFunction<T> {
   (reader: Reader, length: number | undefined, prefix: string, opts?: DecodeOptions<T>): Generator<any>
 }
 
-export interface Codec<T> {
+export interface Codec<D, E> {
   name: string
   type: number
-  encode: EncodeFunction<T>
-  decode: DecodeFunction<T>
-  stream: StreamFunction<T>
+  encode: EncodeFunction<E>
+  decode: DecodeFunction<D>
+  stream: StreamFunction<D>
 }
 
-export function createCodec <T> (name: string, type: number, encode: EncodeFunction<T>, decode: DecodeFunction<T>, stream: StreamFunction<T>): Codec<T> {
+export function createCodec <D, E> (name: string, type: number, encode: EncodeFunction<E>, decode: DecodeFunction<D>, stream: StreamFunction<D>): Codec<D, E> {
   return {
     name,
     type,
diff --git a/packages/protons-runtime/src/codecs/enum.ts b/packages/protons-runtime/src/codecs/enum.ts
index b85b322..4a8cf66 100644
--- a/packages/protons-runtime/src/codecs/enum.ts
+++ b/packages/protons-runtime/src/codecs/enum.ts
@@ -1,7 +1,7 @@
 import { createCodec, CODEC_TYPES } from '../codec.ts'
 import type { DecodeFunction, EncodeFunction, Codec, StreamFunction } from '../codec.ts'
 
-export function enumeration <T> (v: any): Codec<T> {
+export function enumeration <T> (v: any): Codec<T, T> {
   function findValue (val: any): number {
     // Use the reverse mapping to look up the enum key for the stored value
     // https://www.typescriptlang.org/docs/handbook/enums.html#reverse-mappings
@@ -28,5 +28,5 @@ export function enumeration <T> (v: any): Codec<T> {
     // enums are simple values that are decoded inline so this is a no-op
   }
 
-  return createCodec<T>('enum', CODEC_TYPES.VARINT, encode, decode, stream)
+  return createCodec<T, T>('enum', CODEC_TYPES.VARINT, encode, decode, stream)
 }
diff --git a/packages/protons-runtime/src/codecs/message.ts b/packages/protons-runtime/src/codecs/message.ts
index 41018c7..fb44162 100644
--- a/packages/protons-runtime/src/codecs/message.ts
+++ b/packages/protons-runtime/src/codecs/message.ts
@@ -5,6 +5,6 @@ export interface Factory<A, T> {
   new (obj: A): T
 }
 
-export function message <T> (encode: EncodeFunction<T>, decode: DecodeFunction<T>, stream: StreamFunction<T>): Codec<T> {
+export function message <D, E> (encode: EncodeFunction<E>, decode: DecodeFunction<D>, stream: StreamFunction<D>): Codec<D, E> {
   return createCodec('message', CODEC_TYPES.LENGTH_DELIMITED, encode, decode, stream)
 }
diff --git a/packages/protons-runtime/src/decode.ts b/packages/protons-runtime/src/decode.ts
index 18ef696..599f078 100644
--- a/packages/protons-runtime/src/decode.ts
+++ b/packages/protons-runtime/src/decode.ts
@@ -2,7 +2,7 @@ import { createReader } from './utils/reader.ts'
 import type { Codec, DecodeOptions } from './codec.ts'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
-export function decodeMessage <T> (buf: Uint8Array | Uint8ArrayList, codec: Pick<Codec<T>, 'decode'>, opts?: DecodeOptions<T>): T {
+export function decodeMessage <D, E> (buf: Uint8Array | Uint8ArrayList, codec: Pick<Codec<D, E>, 'decode'>, opts?: DecodeOptions<D>): D {
   const reader = createReader(buf)
 
   return codec.decode(reader, undefined, opts)
diff --git a/packages/protons-runtime/src/encode.ts b/packages/protons-runtime/src/encode.ts
index 58264a1..51c121b 100644
--- a/packages/protons-runtime/src/encode.ts
+++ b/packages/protons-runtime/src/encode.ts
@@ -1,7 +1,7 @@
 import { createWriter } from './utils/writer.ts'
 import type { Codec } from './codec.ts'
 
-export function encodeMessage <T> (message: Partial<T>, codec: Pick<Codec<T>, 'encode'>): Uint8Array<ArrayBuffer> {
+export function encodeMessage <D, E> (message: E, codec: Pick<Codec<D, E>, 'encode'>): Uint8Array<ArrayBuffer> {
   const w = createWriter()
 
   codec.encode(message, w, {
diff --git a/packages/protons-runtime/src/index.ts b/packages/protons-runtime/src/index.ts
index 97233c7..cf954fe 100644
--- a/packages/protons-runtime/src/index.ts
+++ b/packages/protons-runtime/src/index.ts
@@ -14,7 +14,7 @@ import type { Codec } from './codec.ts'
 
 export interface FieldDef {
   name: string
-  codec: Codec<any>
+  codec: Codec<any, any>
   optional?: true
   repeats?: true
   packed?: true
diff --git a/packages/protons-runtime/src/stream.ts b/packages/protons-runtime/src/stream.ts
index d01ee38..aae7e0b 100644
--- a/packages/protons-runtime/src/stream.ts
+++ b/packages/protons-runtime/src/stream.ts
@@ -2,7 +2,7 @@ import { createReader } from './utils/reader.ts'
 import type { Codec } from './codec.ts'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
-export function * streamMessage <T> (buf: Uint8Array | Uint8ArrayList, codec: Pick<Codec<T>, 'stream'>, opts?: any): Generator<any> {
+export function * streamMessage <D, E> (buf: Uint8Array | Uint8ArrayList, codec: Pick<Codec<D, E>, 'stream'>, opts?: any): Generator<any> {
   const reader = createReader(buf)
 
   yield * codec.stream(reader, undefined, '.', opts)
diff --git a/packages/protons/src/fields/array-field.ts b/packages/protons/src/fields/array-field.ts
index a79a1ca..a947dba 100644
--- a/packages/protons/src/fields/array-field.ts
+++ b/packages/protons/src/fields/array-field.ts
@@ -21,8 +21,12 @@ export class ArrayField extends Field {
     this.lengthLimit = def.options?.['(protons.options).limit']
   }
 
-  getInterfaceField (parent: Parent, indent = ''): string {
-    return `${super.getInterfaceField(parent, indent)}[]`
+  getDecoderInterfaceField (parent: Parent, indent = ''): string {
+    return `${super.getDecoderInterfaceField(parent, indent)}[]`
+  }
+
+  getEncoderInterfaceField (parent: Parent, indent = ''): string {
+    return `${indent}${this.name}?: ${this.jsTypeOverride ?? parent.findType(this.type).jsType.encode}[]`
   }
 
   getDefaultField (parent: Parent): string {
diff --git a/packages/protons/src/fields/field.ts b/packages/protons/src/fields/field.ts
index 1c55723..c122f89 100644
--- a/packages/protons/src/fields/field.ts
+++ b/packages/protons/src/fields/field.ts
@@ -82,7 +82,12 @@ export interface MessageField {
   /**
    * Return a string that can be used in a typescript interface for this field
    */
-  getInterfaceField (parent: Parent, indent?: string): string
+  getDecoderInterfaceField (parent: Parent, indent?: string): string
+
+  /**
+   * Return a string that can be used in a typescript interface for this field
+   */
+  getEncoderInterfaceField (parent: Parent, indent?: string): string
 }
 
 export class Field implements MessageField {
@@ -127,8 +132,12 @@ export class Field implements MessageField {
     }
   }
 
-  getInterfaceField (parent: Parent, indent = ''): string {
-    return `${indent}${this.name}${this.optional ? '?' : ''}: ${this.jsTypeOverride ?? parent.findType(this.type).jsType}`
+  getDecoderInterfaceField (parent: Parent, indent = ''): string {
+    return `${indent}${this.name}${this.optional ? '?' : ''}: ${this.jsTypeOverride ?? parent.findType(this.type).jsType.decode}`
+  }
+
+  getEncoderInterfaceField (parent: Parent, indent = ''): string {
+    return `${indent}${this.name}${this.proto2Required ? '' : '?'}: ${this.jsTypeOverride ?? parent.findType(this.type).jsType.encode}`
   }
 
   getDefaultField (parent: Parent): string {
@@ -188,6 +197,12 @@ export class Field implements MessageField {
       id = (this.id << 3) | codecTypes.enum
     }
 
+    if (this.proto2Required) {
+      return `
+        w.uint32(${id})
+        ${type.getEncoder(this, `obj.${this.name}`)}`
+    }
+
     return `
         if (${type.getValueTest(this, `obj.${this.name}`)}) {
           w.uint32(${id})
diff --git a/packages/protons/src/fields/map-field.ts b/packages/protons/src/fields/map-field.ts
index 5b37827..93044d2 100644
--- a/packages/protons/src/fields/map-field.ts
+++ b/packages/protons/src/fields/map-field.ts
@@ -37,16 +37,23 @@ export class MapField extends Field {
     }
   }
 
-  getInterfaceField (parent: Parent): string {
-    const keyType = this.jsKeyTypeOverride ?? parent.findType(this.keyType).jsType
-    const valueType = this.jsValueTypeOverride ?? parent.findType(this.valueType).jsType
+  getDecoderInterfaceField (parent: Parent): string {
+    const keyType = this.jsKeyTypeOverride ?? parent.findType(this.keyType).jsType.decode
+    const valueType = this.jsValueTypeOverride ?? parent.findType(this.valueType).jsType.decode
 
     return `${this.name}: Map<${keyType}, ${valueType}>`
   }
 
+  getEncoderInterfaceField (parent: Parent): string {
+    const keyType = this.jsKeyTypeOverride ?? parent.findType(this.keyType).jsType.encode
+    const valueType = this.jsValueTypeOverride ?? parent.findType(this.valueType).jsType.encode
+
+    return `${this.name}?: Map<${keyType}, ${valueType}>`
+  }
+
   getDefaultField (parent: Parent): string {
-    const keyType = this.jsKeyTypeOverride ?? parent.findType(this.keyType).jsType
-    const valueType = this.jsValueTypeOverride ?? parent.findType(this.valueType).jsType
+    const keyType = this.jsKeyTypeOverride ?? parent.findType(this.keyType).jsType.decode
+    const valueType = this.jsValueTypeOverride ?? parent.findType(this.valueType).jsType.decode
 
     return `${this.name}: new Map<${keyType}, ${valueType}>()`
   }
diff --git a/packages/protons/src/fields/message-field.ts b/packages/protons/src/fields/message-field.ts
index f496cc3..04f9e8f 100644
--- a/packages/protons/src/fields/message-field.ts
+++ b/packages/protons/src/fields/message-field.ts
@@ -3,8 +3,12 @@ import { Field } from './field.ts'
 import type { Parent, Type } from '../types/index.ts'
 
 export class MessageField extends Field {
-  getInterfaceField (parent: Parent, indent = ''): string {
-    return `${indent}${this.name}?: ${parent.findType(this.type).jsType}`
+  getDecoderInterfaceField (parent: Parent, indent = ''): string {
+    return `${indent}${this.name}?: ${parent.findType(this.type).jsType.decode}`
+  }
+
+  getEncoderInterfaceField (parent: Parent, indent = ''): string {
+    return `${indent}${this.name}?: ${parent.findType(this.type).jsType.encode}`
   }
 
   getMessage (parent: Parent): Message {
diff --git a/packages/protons/src/types/enum.ts b/packages/protons/src/types/enum.ts
index b8e3b1c..3e9c56e 100644
--- a/packages/protons/src/types/enum.ts
+++ b/packages/protons/src/types/enum.ts
@@ -1,6 +1,6 @@
 import { ParseError } from 'protons-runtime'
 import { ArrayField } from '../fields/array-field.ts'
-import type { Parent, Type } from './index.ts'
+import type { Parent, Type, TypeCodec } from './index.ts'
 import type { Field } from '../fields/field.ts'
 
 export interface EnumDef {
@@ -13,12 +13,12 @@ export function isEnumDef (obj?: any): obj is EnumDef {
 
 export class Enum implements Type {
   public pbType: string
-  public jsType: string
+  public jsType: TypeCodec
   public values: Map<string, number>
   public lowestValue: number
   public lowestValueName: string
 
-  constructor (pbType: string, jsType: string, def: EnumDef) {
+  constructor (pbType: string, jsType: TypeCodec, def: EnumDef) {
     this.pbType = pbType
     this.jsType = jsType
     this.values = new Map(Object.entries(def.values))
@@ -51,7 +51,7 @@ export class Enum implements Type {
   }
 
   getDecoder (field: Field): string {
-    return `${this.jsType}.codec().decode(reader)`
+    return `${this.jsType.decode}.codec().decode(reader)`
   }
 
   getStreamingDecoder (field: Field, prefix: string, indent: ''): string {
@@ -59,18 +59,18 @@ export class Enum implements Type {
       return `yield {
 ${indent}              field: ${prefix},
 ${indent}              index: obj.${field.name},
-${indent}              value: ${this.jsType}.codec().decode(reader)
+${indent}              value: ${this.jsType.decode}.codec().decode(reader)
 ${indent}            }`
     }
 
     return `yield {
 ${indent}              field: ${prefix},
-${indent}              value: ${this.jsType}.codec().decode(reader)
+${indent}              value: ${this.jsType.decode}.codec().decode(reader)
 ${indent}            }`
   }
 
   getEncoder (field: Field, accessor: string): string {
-    return `${this.jsType}.codec().encode(${accessor}, w)`
+    return `${this.jsType.decode}.codec().encode(${accessor}, w)`
   }
 
   getValueTest (field: Field, accessor: string): string {
@@ -115,7 +115,7 @@ enum __${this.pbType}Values {
 }
 
 export namespace ${this.pbType} {
-  export const codec = (): Codec<${this.pbType}> => {
+  export const codec = (): Codec<${this.pbType}, ${this.pbType}> => {
     return enumeration<${this.pbType}>(__${this.pbType}Values)
   }
 }
diff --git a/packages/protons/src/types/index.ts b/packages/protons/src/types/index.ts
index db02ec2..07e3fcd 100644
--- a/packages/protons/src/types/index.ts
+++ b/packages/protons/src/types/index.ts
@@ -2,8 +2,13 @@ import type { Field } from '../fields/field.ts'
 import type { Flags } from '../index.ts'
 import type { Module } from './module.ts'
 
+export interface TypeCodec {
+  encode: string
+  decode: string
+}
+
 export interface Type {
-  jsType: string
+  jsType: TypeCodec
   pbType: string
   init(module: Module): void
   getDecoder(field: Field, indent?: string): string
diff --git a/packages/protons/src/types/message.ts b/packages/protons/src/types/message.ts
index d208d2f..d948f84 100644
--- a/packages/protons/src/types/message.ts
+++ b/packages/protons/src/types/message.ts
@@ -6,7 +6,7 @@ import { MessageField } from '../fields/message-field.ts'
 import { Enum } from './enum.ts'
 import { Primitive } from './primitive.ts'
 import type { EnumDef } from './enum.ts'
-import type { Parent, Type } from './index.ts'
+import type { Parent, Type, TypeCodec } from './index.ts'
 import type { FieldDef } from '../fields/field.ts'
 import type { Flags } from '../index.ts'
 
@@ -38,14 +38,14 @@ export function isMessageDef (obj?: any): obj is MessageDef {
 
 export class Message implements Type {
   public pbType: string
-  public jsType: string
+  public jsType: TypeCodec
   public fields: Field[]
   public oneOfs: string[][]
   public nested: Record<string, Message | Enum>
   private def: MessageDef
   private parent: Parent
 
-  constructor (pbType: string, jsType: string, def: MessageDef, parent: Parent) {
+  constructor (pbType: string, jsType: TypeCodec, def: MessageDef, parent: Parent) {
     this.pbType = pbType
     this.jsType = jsType
     this.oneOfs = []
@@ -92,12 +92,16 @@ export class Message implements Type {
     }
 
     Object.entries(def.nested ?? {}).forEach(([name, def]) => {
-      const fullName = `${this.jsType}.${name}`
-
       if (isMessageDef(def)) {
-        this.nested[name] = new Message(name, fullName, def, this)
+        this.nested[name] = new Message(name, {
+          encode: `${this.jsType.decode}.${name}Input`,
+          decode: `${this.jsType.decode}.${name}`
+        }, def, this)
       } else {
-        this.nested[name] = new Enum(name, fullName, def)
+        this.nested[name] = new Enum(name, {
+          encode: `${this.jsType.decode}.${name}`,
+          decode: `${this.jsType.decode}.${name}`
+        }, def)
       }
     })
 
@@ -184,7 +188,7 @@ ${indent}                  value: opts.limits?.${field.name}$value
 ${indent}              }`
     }
 
-    return `${this.jsType}.codec().decode(reader, reader.uint32()${opts})`
+    return `${this.jsType.decode}.codec().decode(reader, reader.uint32()${opts})`
   }
 
   getStreamingDecoder (field: Field, prefix: string, indent: ''): string {
@@ -199,7 +203,7 @@ ${indent}            }`
 ${indent}              limits: opts.limits?.${field.name}$
 ${indent}            }`
 
-      return `for (const evt of ${this.jsType}.codec().stream(reader, reader.uint32(), ${prefix}${opts})) {
+      return `for (const evt of ${this.jsType.decode}.codec().stream(reader, reader.uint32(), ${prefix}${opts})) {
 ${indent}              yield {
 ${indent}                ...evt,
 ${indent}                index: obj.${field.name}
@@ -213,7 +217,7 @@ ${indent}                value: opts.limits?.${field.name}$value
 ${indent}            }`
     }
 
-    return `yield * ${this.jsType}.codec().stream(reader, reader.uint32(), ${prefix}${opts})`
+    return `yield * ${this.jsType.decode}.codec().stream(reader, reader.uint32(), ${prefix}${opts})`
   }
 
   getEncoder (field: Field, accessor: string): string {
@@ -222,10 +226,10 @@ ${indent}            }`
       // is part of a repeated field, and consists of only default values it
       // won't be written, so write a zero-length buffer if that's the case
       // writeField = (): string => `w.uint32(${id})
-      // ${type.jsType}.codec().encode(${valueVar}, w)`
+      // ${type.jsType.decode}.codec().encode(${valueVar}, w)`
     }
 
-    return `${this.jsType}.codec().encode(${accessor}, w)`
+    return `${this.jsType.decode}.codec().encode(${accessor}, w)`
   }
 
   getValueTest (field: Field): string {
@@ -254,20 +258,24 @@ ${indent}            }`
 `
     }
 
-    const interfaceFields = this.fields.map(field => field.getInterfaceField(this))
-      .join('\n  ')
-      .trim()
-
+    const decoderFields = this.fields.map(field => field.getDecoderInterfaceField(this))
+    const encoderFields = this.fields.map(field => field.getEncoderInterfaceField(this))
     let interfaceDef = ''
     let interfaceCodecDef = ''
 
-    if (interfaceFields === '') {
+    if (decoderFields.length === 0) {
       interfaceDef = `
+export interface ${this.pbType}Input {}
+
 export interface ${this.pbType} {}`
     } else {
       interfaceDef = `
 export interface ${this.pbType} {
-  ${interfaceFields}
+  ${decoderFields.join('\n  ').trim()}
+}
+
+export interface ${this.pbType}Input {
+  ${encoderFields.join('\n  ').trim()}
 }`
     }
 
@@ -286,11 +294,11 @@ export interface ${this.pbType} {
     }
 
     interfaceCodecDef = `
-  let _codec: Codec<${this.pbType}>
+  let _codec: Codec<${this.pbType}, ${this.pbType}Input>
 
-  export const codec = (): Codec<${this.pbType}> => {
+  export const codec = (): Codec<${this.pbType}, ${this.pbType}Input> => {
     if (_codec == null) {
-      _codec = message<${this.pbType}>((obj, w, opts = {}) => {
+      _codec = message<${this.pbType}, ${this.pbType}Input>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }${enforceOneOfEncoding}${this.formatFields(encodeFields)}
@@ -322,7 +330,7 @@ ${enforceOneOfDecoding === '' ? '' : `${enforceOneOfDecoding}\n`}
           yield {
             field: prefix.endsWith('.') ? prefix.substring(0, prefix.length - 1) : prefix,
             type: 'start',
-            message: '${this.jsType}'
+            message: '${this.jsType.decode}'
           }
         }
 
@@ -341,7 +349,7 @@ ${enforceOneOfDecoding === '' ? '' : `${enforceOneOfDecoding}\n`}
           yield {
             field: prefix.endsWith('.') ? prefix.substring(0, prefix.length - 1) : prefix,
             type: 'end',
-            message: '${this.jsType}'
+            message: '${this.jsType.decode}'
           }
         }
       })
@@ -350,7 +358,7 @@ ${enforceOneOfDecoding === '' ? '' : `${enforceOneOfDecoding}\n`}
     return _codec
   }${this.formatStreamEvents(streamEvents)}
 
-  export function encode (obj: Partial<${this.pbType}>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: ${this.pbType}Input): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, ${this.pbType}.codec())
   }
 
@@ -546,15 +554,15 @@ ${fields
             name: `${fieldPrefix === '.' ? this.pbType : ''}${camelize(field.name)}FieldEvent`,
             fields: [
               `field: '${fieldPrefix}${field.name}{}'`,
-              `key: ${field.jsKeyTypeOverride ?? keyType.jsType}`,
-              `value: ${field.jsValueTypeOverride ?? valueType.jsType}`
+              `key: ${field.jsKeyTypeOverride ?? keyType.jsType.decode}`,
+              `value: ${field.jsValueTypeOverride ?? valueType.jsType.decode}`
             ],
             type: 'collection-primitive-member'
           })
         } else if (valueType instanceof Message) {
           addMessageFields(field, valueType, [
-            `key: ${field.jsKeyTypeOverride ?? keyType.jsType}`,
-            `value: ${field.jsValueTypeOverride ?? valueType.jsType}`
+            `key: ${field.jsKeyTypeOverride ?? keyType.jsType.decode}`,
+            `value: ${field.jsValueTypeOverride ?? valueType.jsType.decode}`
           ])
 
           streamEvents.push({
@@ -562,7 +570,7 @@ ${fields
             type: 'sub-message',
             fields: [
               `field: '${fieldPrefix}${field.name}{}'`,
-              `key: ${field.jsKeyTypeOverride ?? keyType.jsType}`,
+              `key: ${field.jsKeyTypeOverride ?? keyType.jsType.decode}`,
               "type: 'start'",
               'message: string'
             ]
@@ -572,7 +580,7 @@ ${fields
             type: 'sub-message',
             fields: [
               `field: '${fieldPrefix}${field.name}{}'`,
-              `key: ${field.jsKeyTypeOverride ?? keyType.jsType}`,
+              `key: ${field.jsKeyTypeOverride ?? keyType.jsType.decode}`,
               "type: 'end'",
               'message: string'
             ]
@@ -587,7 +595,7 @@ ${fields
             fields: [
               `field: '${fieldPrefix}${field.name}[]'`,
               'index: number',
-              `value: ${field.jsTypeOverride ?? type.jsType}`
+              `value: ${field.jsTypeOverride ?? type.jsType.decode}`
             ],
             type: 'collection-primitive-member'
           })
@@ -626,7 +634,7 @@ ${fields
             name: `${fieldPrefix === '.' ? this.pbType : ''}${camelize(field.name)}FieldEvent`,
             fields: [
               `field: '${fieldPrefix}${field.name}'`,
-              `value: ${field.jsTypeOverride ?? type.jsType}`
+              `value: ${field.jsTypeOverride ?? type.jsType.decode}`
             ],
             type: 'field'
           })
diff --git a/packages/protons/src/types/module.ts b/packages/protons/src/types/module.ts
index f502b8e..23b16de 100644
--- a/packages/protons/src/types/module.ts
+++ b/packages/protons/src/types/module.ts
@@ -5,24 +5,69 @@ import { Primitive } from './primitive.ts'
 import type { EnumDef } from './enum.ts'
 import type { MessageDef } from './message.ts'
 import type { Flags } from '../index.ts'
-import type { Type } from './index.ts'
-
-const types: Record<string, string> = {
-  bool: 'boolean',
-  bytes: 'Uint8Array<ArrayBuffer>',
-  double: 'number',
-  fixed32: 'number',
-  fixed64: 'bigint',
-  float: 'number',
-  int32: 'number',
-  int64: 'bigint',
-  sfixed32: 'number',
-  sfixed64: 'bigint',
-  sint32: 'number',
-  sint64: 'bigint',
-  string: 'string',
-  uint32: 'number',
-  uint64: 'bigint'
+import type { Type, TypeCodec } from './index.ts'
+
+const types: Record<string, TypeCodec> = {
+  bool: {
+    encode: 'boolean',
+    decode: 'boolean'
+  },
+  bytes: {
+    encode: 'Uint8Array',
+    decode: 'Uint8Array<ArrayBuffer>'
+  },
+  double: {
+    encode: 'number',
+    decode: 'number'
+  },
+  fixed32: {
+    encode: 'number',
+    decode: 'number'
+  },
+  fixed64: {
+    encode: 'bigint',
+    decode: 'bigint'
+  },
+  float: {
+    encode: 'number',
+    decode: 'number'
+  },
+  int32: {
+    encode: 'number',
+    decode: 'number'
+  },
+  int64: {
+    encode: 'bigint',
+    decode: 'bigint'
+  },
+  sfixed32: {
+    encode: 'number',
+    decode: 'number'
+  },
+  sfixed64: {
+    encode: 'bigint',
+    decode: 'bigint'
+  },
+  sint32: {
+    encode: 'number',
+    decode: 'number'
+  },
+  sint64: {
+    encode: 'bigint',
+    decode: 'bigint'
+  },
+  string: {
+    encode: 'string',
+    decode: 'string'
+  },
+  uint32: {
+    encode: 'number',
+    decode: 'number'
+  },
+  uint64: {
+    encode: 'bigint',
+    decode: 'bigint'
+  }
 }
 
 interface Import {
@@ -63,9 +108,15 @@ export class Module {
       let type: Message | Enum
 
       if (isEnumDef(def)) {
-        type = new Enum(name, name, def)
+        type = new Enum(name, {
+          encode: name,
+          decode: name
+        }, def)
       } else {
-        type = new Message(name, name, def, this)
+        type = new Message(name, {
+          encode: `${name}Input`,
+          decode: name
+        }, def, this)
       }
 
       this.globals.push(type)
diff --git a/packages/protons/src/types/primitive.ts b/packages/protons/src/types/primitive.ts
index 17ea8a4..e174e21 100644
--- a/packages/protons/src/types/primitive.ts
+++ b/packages/protons/src/types/primitive.ts
@@ -1,5 +1,5 @@
 import { ArrayField } from '../fields/array-field.ts'
-import type { Type } from './index.ts'
+import type { Type, TypeCodec } from './index.ts'
 import type { Field } from '../fields/field.ts'
 
 const decoderGenerators: Record<string, (jsTypeOverride?: 'number' | 'string') => string> = {
@@ -166,10 +166,10 @@ const defaultValueTestGeneratorsJsTypeOverrides: Record<string, DefaultValueTest
 }
 
 export class Primitive implements Type {
-  public jsType: string
+  public jsType: TypeCodec
   public pbType: string
 
-  constructor (pbType: string, jsType: string) {
+  constructor (pbType: string, jsType: TypeCodec) {
     this.jsType = jsType
     this.pbType = pbType
   }
diff --git a/packages/protons/test/fixtures/basic.ts b/packages/protons/test/fixtures/basic.ts
index 5c54b09..cfb20d1 100644
--- a/packages/protons/test/fixtures/basic.ts
+++ b/packages/protons/test/fixtures/basic.ts
@@ -7,12 +7,17 @@ export interface Basic {
   num: number
 }
 
+export interface BasicInput {
+  foo?: string
+  num?: number
+}
+
 export namespace Basic {
-  let _codec: Codec<Basic>
+  let _codec: Codec<Basic, BasicInput>
 
-  export const codec = (): Codec<Basic> => {
+  export const codec = (): Codec<Basic, BasicInput> => {
     if (_codec == null) {
-      _codec = message<Basic>((obj, w, opts = {}) => {
+      _codec = message<Basic, BasicInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -116,7 +121,7 @@ export namespace Basic {
     value: number
   }
 
-  export function encode (obj: Partial<Basic>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: BasicInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Basic.codec())
   }
 
@@ -129,14 +134,16 @@ export namespace Basic {
   }
 }
 
+export interface EmptyInput {}
+
 export interface Empty {}
 
 export namespace Empty {
-  let _codec: Codec<Empty>
+  let _codec: Codec<Empty, EmptyInput>
 
-  export const codec = (): Codec<Empty> => {
+  export const codec = (): Codec<Empty, EmptyInput> => {
     if (_codec == null) {
-      _codec = message<Empty>((obj, w, opts = {}) => {
+      _codec = message<Empty, EmptyInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -196,7 +203,7 @@ export namespace Empty {
     return _codec
   }
 
-  export function encode (obj: Partial<Empty>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: EmptyInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Empty.codec())
   }
 
diff --git a/packages/protons/test/fixtures/bitswap.ts b/packages/protons/test/fixtures/bitswap.ts
index e0452ed..4c48eb2 100644
--- a/packages/protons/test/fixtures/bitswap.ts
+++ b/packages/protons/test/fixtures/bitswap.ts
@@ -11,12 +11,25 @@ export interface Message {
   pendingBytes: number
 }
 
+export interface MessageInput {
+  wantlist?: Message.WantlistInput
+  blocks?: Uint8Array[]
+  payload?: Message.BlockInput[]
+  blockPresences?: Message.BlockPresenceInput[]
+  pendingBytes?: number
+}
+
 export namespace Message {
   export interface Wantlist {
     entries: Message.Wantlist.Entry[]
     full: boolean
   }
 
+  export interface WantlistInput {
+    entries?: Message.Wantlist.EntryInput[]
+    full?: boolean
+  }
+
   export namespace Wantlist {
     export enum WantType {
       Block = 'Block',
@@ -29,7 +42,7 @@ export namespace Message {
     }
 
     export namespace WantType {
-      export const codec = (): Codec<WantType> => {
+      export const codec = (): Codec<WantType, WantType> => {
         return enumeration<WantType>(__WantTypeValues)
       }
     }
@@ -42,12 +55,20 @@ export namespace Message {
       sendDontHave: boolean
     }
 
+    export interface EntryInput {
+      block?: Uint8Array
+      priority?: number
+      cancel?: boolean
+      wantType?: Message.Wantlist.WantType
+      sendDontHave?: boolean
+    }
+
     export namespace Entry {
-      let _codec: Codec<Entry>
+      let _codec: Codec<Entry, EntryInput>
 
-      export const codec = (): Codec<Entry> => {
+      export const codec = (): Codec<Entry, EntryInput> => {
         if (_codec == null) {
-          _codec = message<Entry>((obj, w, opts = {}) => {
+          _codec = message<Entry, EntryInput>((obj, w, opts = {}) => {
             if (opts.lengthDelimited !== false) {
               w.fork()
             }
@@ -217,7 +238,7 @@ export namespace Message {
         value: boolean
       }
 
-      export function encode (obj: Partial<Entry>): Uint8Array<ArrayBuffer> {
+      export function encode (obj: EntryInput): Uint8Array<ArrayBuffer> {
         return encodeMessage(obj, Entry.codec())
       }
 
@@ -230,11 +251,11 @@ export namespace Message {
       }
     }
 
-    let _codec: Codec<Wantlist>
+    let _codec: Codec<Wantlist, WantlistInput>
 
-    export const codec = (): Codec<Wantlist> => {
+    export const codec = (): Codec<Wantlist, WantlistInput> => {
       if (_codec == null) {
-        _codec = message<Wantlist>((obj, w, opts = {}) => {
+        _codec = message<Wantlist, WantlistInput>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
             w.fork()
           }
@@ -401,7 +422,7 @@ export namespace Message {
       value: boolean
     }
 
-    export function encode (obj: Partial<Wantlist>): Uint8Array<ArrayBuffer> {
+    export function encode (obj: WantlistInput): Uint8Array<ArrayBuffer> {
       return encodeMessage(obj, Wantlist.codec())
     }
 
@@ -419,12 +440,17 @@ export namespace Message {
     data: Uint8Array<ArrayBuffer>
   }
 
+  export interface BlockInput {
+    prefix?: Uint8Array
+    data?: Uint8Array
+  }
+
   export namespace Block {
-    let _codec: Codec<Block>
+    let _codec: Codec<Block, BlockInput>
 
-    export const codec = (): Codec<Block> => {
+    export const codec = (): Codec<Block, BlockInput> => {
       if (_codec == null) {
-        _codec = message<Block>((obj, w, opts = {}) => {
+        _codec = message<Block, BlockInput>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
             w.fork()
           }
@@ -529,7 +555,7 @@ export namespace Message {
       value: Uint8Array<ArrayBuffer>
     }
 
-    export function encode (obj: Partial<Block>): Uint8Array<ArrayBuffer> {
+    export function encode (obj: BlockInput): Uint8Array<ArrayBuffer> {
       return encodeMessage(obj, Block.codec())
     }
 
@@ -553,7 +579,7 @@ export namespace Message {
   }
 
   export namespace BlockPresenceType {
-    export const codec = (): Codec<BlockPresenceType> => {
+    export const codec = (): Codec<BlockPresenceType, BlockPresenceType> => {
       return enumeration<BlockPresenceType>(__BlockPresenceTypeValues)
     }
   }
@@ -563,12 +589,17 @@ export namespace Message {
     type: Message.BlockPresenceType
   }
 
+  export interface BlockPresenceInput {
+    cid?: Uint8Array
+    type?: Message.BlockPresenceType
+  }
+
   export namespace BlockPresence {
-    let _codec: Codec<BlockPresence>
+    let _codec: Codec<BlockPresence, BlockPresenceInput>
 
-    export const codec = (): Codec<BlockPresence> => {
+    export const codec = (): Codec<BlockPresence, BlockPresenceInput> => {
       if (_codec == null) {
-        _codec = message<BlockPresence>((obj, w, opts = {}) => {
+        _codec = message<BlockPresence, BlockPresenceInput>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
             w.fork()
           }
@@ -673,7 +704,7 @@ export namespace Message {
       value: Message.BlockPresenceType
     }
 
-    export function encode (obj: Partial<BlockPresence>): Uint8Array<ArrayBuffer> {
+    export function encode (obj: BlockPresenceInput): Uint8Array<ArrayBuffer> {
       return encodeMessage(obj, BlockPresence.codec())
     }
 
@@ -686,11 +717,11 @@ export namespace Message {
     }
   }
 
-  let _codec: Codec<Message>
+  let _codec: Codec<Message, MessageInput>
 
-  export const codec = (): Codec<Message> => {
+  export const codec = (): Codec<Message, MessageInput> => {
     if (_codec == null) {
-      _codec = message<Message>((obj, w, opts = {}) => {
+      _codec = message<Message, MessageInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -1017,7 +1048,7 @@ export namespace Message {
     value: number
   }
 
-  export function encode (obj: Partial<Message>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: MessageInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Message.codec())
   }
 
diff --git a/packages/protons/test/fixtures/circuit.ts b/packages/protons/test/fixtures/circuit.ts
index 74fffb6..2e17872 100644
--- a/packages/protons/test/fixtures/circuit.ts
+++ b/packages/protons/test/fixtures/circuit.ts
@@ -10,6 +10,13 @@ export interface CircuitRelay {
   code?: CircuitRelay.Status
 }
 
+export interface CircuitRelayInput {
+  type?: CircuitRelay.Type
+  srcPeer?: CircuitRelay.PeerInput
+  dstPeer?: CircuitRelay.PeerInput
+  code?: CircuitRelay.Status
+}
+
 export namespace CircuitRelay {
   export enum Status {
     SUCCESS = 'SUCCESS',
@@ -50,7 +57,7 @@ export namespace CircuitRelay {
   }
 
   export namespace Status {
-    export const codec = (): Codec<Status> => {
+    export const codec = (): Codec<Status, Status> => {
       return enumeration<Status>(__StatusValues)
     }
   }
@@ -70,7 +77,7 @@ export namespace CircuitRelay {
   }
 
   export namespace Type {
-    export const codec = (): Codec<Type> => {
+    export const codec = (): Codec<Type, Type> => {
       return enumeration<Type>(__TypeValues)
     }
   }
@@ -80,12 +87,17 @@ export namespace CircuitRelay {
     addrs: Uint8Array<ArrayBuffer>[]
   }
 
+  export interface PeerInput {
+    id?: Uint8Array
+    addrs?: Uint8Array[]
+  }
+
   export namespace Peer {
-    let _codec: Codec<Peer>
+    let _codec: Codec<Peer, PeerInput>
 
-    export const codec = (): Codec<Peer> => {
+    export const codec = (): Codec<Peer, PeerInput> => {
       if (_codec == null) {
-        _codec = message<Peer>((obj, w, opts = {}) => {
+        _codec = message<Peer, PeerInput>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
             w.fork()
           }
@@ -209,7 +221,7 @@ export namespace CircuitRelay {
       value: Uint8Array<ArrayBuffer>
     }
 
-    export function encode (obj: Partial<Peer>): Uint8Array<ArrayBuffer> {
+    export function encode (obj: PeerInput): Uint8Array<ArrayBuffer> {
       return encodeMessage(obj, Peer.codec())
     }
 
@@ -222,11 +234,11 @@ export namespace CircuitRelay {
     }
   }
 
-  let _codec: Codec<CircuitRelay>
+  let _codec: Codec<CircuitRelay, CircuitRelayInput>
 
-  export const codec = (): Codec<CircuitRelay> => {
+  export const codec = (): Codec<CircuitRelay, CircuitRelayInput> => {
     if (_codec == null) {
-      _codec = message<CircuitRelay>((obj, w, opts = {}) => {
+      _codec = message<CircuitRelay, CircuitRelayInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -406,7 +418,7 @@ export namespace CircuitRelay {
     value: CircuitRelay.Status
   }
 
-  export function encode (obj: Partial<CircuitRelay>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: CircuitRelayInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, CircuitRelay.codec())
   }
 
diff --git a/packages/protons/test/fixtures/custom-option-jstype.ts b/packages/protons/test/fixtures/custom-option-jstype.ts
index 9cea0d0..39e56f1 100644
--- a/packages/protons/test/fixtures/custom-option-jstype.ts
+++ b/packages/protons/test/fixtures/custom-option-jstype.ts
@@ -13,18 +13,34 @@ export interface CustomOptionNumber {
   i64Map: Map<number, number>
 }
 
+export interface CustomOptionNumberInput {
+  num?: number
+  i64?: number
+  ui64?: number
+  si64?: number
+  f64?: number
+  sf64?: number
+  i64Array?: number[]
+  i64Map?: Map<number, number>
+}
+
 export namespace CustomOptionNumber {
   export interface CustomOptionNumber$i64MapEntry {
     key: number
     value: number
   }
 
+  export interface CustomOptionNumber$i64MapEntryInput {
+    key?: number
+    value?: number
+  }
+
   export namespace CustomOptionNumber$i64MapEntry {
-    let _codec: Codec<CustomOptionNumber$i64MapEntry>
+    let _codec: Codec<CustomOptionNumber$i64MapEntry, CustomOptionNumber$i64MapEntryInput>
 
-    export const codec = (): Codec<CustomOptionNumber$i64MapEntry> => {
+    export const codec = (): Codec<CustomOptionNumber$i64MapEntry, CustomOptionNumber$i64MapEntryInput> => {
       if (_codec == null) {
-        _codec = message<CustomOptionNumber$i64MapEntry>((obj, w, opts = {}) => {
+        _codec = message<CustomOptionNumber$i64MapEntry, CustomOptionNumber$i64MapEntryInput>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
             w.fork()
           }
@@ -129,7 +145,7 @@ export namespace CustomOptionNumber {
       value: number
     }
 
-    export function encode (obj: Partial<CustomOptionNumber$i64MapEntry>): Uint8Array<ArrayBuffer> {
+    export function encode (obj: CustomOptionNumber$i64MapEntryInput): Uint8Array<ArrayBuffer> {
       return encodeMessage(obj, CustomOptionNumber$i64MapEntry.codec())
     }
 
@@ -142,11 +158,11 @@ export namespace CustomOptionNumber {
     }
   }
 
-  let _codec: Codec<CustomOptionNumber>
+  let _codec: Codec<CustomOptionNumber, CustomOptionNumberInput>
 
-  export const codec = (): Codec<CustomOptionNumber> => {
+  export const codec = (): Codec<CustomOptionNumber, CustomOptionNumberInput> => {
     if (_codec == null) {
-      _codec = message<CustomOptionNumber>((obj, w, opts = {}) => {
+      _codec = message<CustomOptionNumber, CustomOptionNumberInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -423,7 +439,7 @@ export namespace CustomOptionNumber {
     value: number
   }
 
-  export function encode (obj: Partial<CustomOptionNumber>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: CustomOptionNumberInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, CustomOptionNumber.codec())
   }
 
@@ -447,18 +463,34 @@ export interface CustomOptionString {
   i64Map: Map<string, string>
 }
 
+export interface CustomOptionStringInput {
+  num?: number
+  i64?: string
+  ui64?: string
+  si64?: string
+  f64?: string
+  sf64?: string
+  i64Array?: string[]
+  i64Map?: Map<string, string>
+}
+
 export namespace CustomOptionString {
   export interface CustomOptionString$i64MapEntry {
     key: string
     value: string
   }
 
+  export interface CustomOptionString$i64MapEntryInput {
+    key?: string
+    value?: string
+  }
+
   export namespace CustomOptionString$i64MapEntry {
-    let _codec: Codec<CustomOptionString$i64MapEntry>
+    let _codec: Codec<CustomOptionString$i64MapEntry, CustomOptionString$i64MapEntryInput>
 
-    export const codec = (): Codec<CustomOptionString$i64MapEntry> => {
+    export const codec = (): Codec<CustomOptionString$i64MapEntry, CustomOptionString$i64MapEntryInput> => {
       if (_codec == null) {
-        _codec = message<CustomOptionString$i64MapEntry>((obj, w, opts = {}) => {
+        _codec = message<CustomOptionString$i64MapEntry, CustomOptionString$i64MapEntryInput>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
             w.fork()
           }
@@ -563,7 +595,7 @@ export namespace CustomOptionString {
       value: string
     }
 
-    export function encode (obj: Partial<CustomOptionString$i64MapEntry>): Uint8Array<ArrayBuffer> {
+    export function encode (obj: CustomOptionString$i64MapEntryInput): Uint8Array<ArrayBuffer> {
       return encodeMessage(obj, CustomOptionString$i64MapEntry.codec())
     }
 
@@ -576,11 +608,11 @@ export namespace CustomOptionString {
     }
   }
 
-  let _codec: Codec<CustomOptionString>
+  let _codec: Codec<CustomOptionString, CustomOptionStringInput>
 
-  export const codec = (): Codec<CustomOptionString> => {
+  export const codec = (): Codec<CustomOptionString, CustomOptionStringInput> => {
     if (_codec == null) {
-      _codec = message<CustomOptionString>((obj, w, opts = {}) => {
+      _codec = message<CustomOptionString, CustomOptionStringInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -857,7 +889,7 @@ export namespace CustomOptionString {
     value: string
   }
 
-  export function encode (obj: Partial<CustomOptionString>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: CustomOptionStringInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, CustomOptionString.codec())
   }
 
diff --git a/packages/protons/test/fixtures/daemon.ts b/packages/protons/test/fixtures/daemon.ts
index 1a0ec8a..fa42eec 100644
--- a/packages/protons/test/fixtures/daemon.ts
+++ b/packages/protons/test/fixtures/daemon.ts
@@ -15,6 +15,18 @@ export interface Request {
   peerStore?: PeerstoreRequest
 }
 
+export interface RequestInput {
+  type?: Request.Type
+  connect?: ConnectRequestInput
+  streamOpen?: StreamOpenRequestInput
+  streamHandler?: StreamHandlerRequestInput
+  dht?: DHTRequestInput
+  connManager?: ConnManagerRequestInput
+  disconnect?: DisconnectRequestInput
+  pubsub?: PSRequestInput
+  peerStore?: PeerstoreRequestInput
+}
+
 export namespace Request {
   export enum Type {
     IDENTIFY = 'IDENTIFY',
@@ -43,16 +55,16 @@ export namespace Request {
   }
 
   export namespace Type {
-    export const codec = (): Codec<Type> => {
+    export const codec = (): Codec<Type, Type> => {
       return enumeration<Type>(__TypeValues)
     }
   }
 
-  let _codec: Codec<Request>
+  let _codec: Codec<Request, RequestInput>
 
-  export const codec = (): Codec<Request> => {
+  export const codec = (): Codec<Request, RequestInput> => {
     if (_codec == null) {
-      _codec = message<Request>((obj, w, opts = {}) => {
+      _codec = message<Request, RequestInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -493,7 +505,7 @@ export namespace Request {
     value: string
   }
 
-  export function encode (obj: Partial<Request>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: RequestInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Request.codec())
   }
 
@@ -517,6 +529,17 @@ export interface Response {
   peerStore?: PeerstoreResponse
 }
 
+export interface ResponseInput {
+  type?: Response.Type
+  error?: ErrorResponseInput
+  streamInfo?: StreamInfoInput
+  identify?: IdentifyResponseInput
+  dht?: DHTResponseInput
+  peers?: PeerInfoInput[]
+  pubsub?: PSResponseInput
+  peerStore?: PeerstoreResponseInput
+}
+
 export namespace Response {
   export enum Type {
     OK = 'OK',
@@ -529,16 +552,16 @@ export namespace Response {
   }
 
   export namespace Type {
-    export const codec = (): Codec<Type> => {
+    export const codec = (): Codec<Type, Type> => {
       return enumeration<Type>(__TypeValues)
     }
   }
 
-  let _codec: Codec<Response>
+  let _codec: Codec<Response, ResponseInput>
 
-  export const codec = (): Codec<Response> => {
+  export const codec = (): Codec<Response, ResponseInput> => {
     if (_codec == null) {
-      _codec = message<Response>((obj, w, opts = {}) => {
+      _codec = message<Response, ResponseInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -956,7 +979,7 @@ export namespace Response {
     value: string
   }
 
-  export function encode (obj: Partial<Response>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: ResponseInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Response.codec())
   }
 
@@ -974,12 +997,17 @@ export interface IdentifyResponse {
   addrs: Uint8Array<ArrayBuffer>[]
 }
 
+export interface IdentifyResponseInput {
+  id?: Uint8Array
+  addrs?: Uint8Array[]
+}
+
 export namespace IdentifyResponse {
-  let _codec: Codec<IdentifyResponse>
+  let _codec: Codec<IdentifyResponse, IdentifyResponseInput>
 
-  export const codec = (): Codec<IdentifyResponse> => {
+  export const codec = (): Codec<IdentifyResponse, IdentifyResponseInput> => {
     if (_codec == null) {
-      _codec = message<IdentifyResponse>((obj, w, opts = {}) => {
+      _codec = message<IdentifyResponse, IdentifyResponseInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -1103,7 +1131,7 @@ export namespace IdentifyResponse {
     value: Uint8Array<ArrayBuffer>
   }
 
-  export function encode (obj: Partial<IdentifyResponse>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: IdentifyResponseInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, IdentifyResponse.codec())
   }
 
@@ -1122,12 +1150,18 @@ export interface ConnectRequest {
   timeout?: bigint
 }
 
+export interface ConnectRequestInput {
+  peer?: Uint8Array
+  addrs?: Uint8Array[]
+  timeout?: bigint
+}
+
 export namespace ConnectRequest {
-  let _codec: Codec<ConnectRequest>
+  let _codec: Codec<ConnectRequest, ConnectRequestInput>
 
-  export const codec = (): Codec<ConnectRequest> => {
+  export const codec = (): Codec<ConnectRequest, ConnectRequestInput> => {
     if (_codec == null) {
-      _codec = message<ConnectRequest>((obj, w, opts = {}) => {
+      _codec = message<ConnectRequest, ConnectRequestInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -1272,7 +1306,7 @@ export namespace ConnectRequest {
     value: bigint
   }
 
-  export function encode (obj: Partial<ConnectRequest>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: ConnectRequestInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, ConnectRequest.codec())
   }
 
@@ -1291,12 +1325,18 @@ export interface StreamOpenRequest {
   timeout?: bigint
 }
 
+export interface StreamOpenRequestInput {
+  peer?: Uint8Array
+  proto?: string[]
+  timeout?: bigint
+}
+
 export namespace StreamOpenRequest {
-  let _codec: Codec<StreamOpenRequest>
+  let _codec: Codec<StreamOpenRequest, StreamOpenRequestInput>
 
-  export const codec = (): Codec<StreamOpenRequest> => {
+  export const codec = (): Codec<StreamOpenRequest, StreamOpenRequestInput> => {
     if (_codec == null) {
-      _codec = message<StreamOpenRequest>((obj, w, opts = {}) => {
+      _codec = message<StreamOpenRequest, StreamOpenRequestInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -1441,7 +1481,7 @@ export namespace StreamOpenRequest {
     value: bigint
   }
 
-  export function encode (obj: Partial<StreamOpenRequest>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: StreamOpenRequestInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, StreamOpenRequest.codec())
   }
 
@@ -1459,12 +1499,17 @@ export interface StreamHandlerRequest {
   proto: string[]
 }
 
+export interface StreamHandlerRequestInput {
+  addr?: Uint8Array
+  proto?: string[]
+}
+
 export namespace StreamHandlerRequest {
-  let _codec: Codec<StreamHandlerRequest>
+  let _codec: Codec<StreamHandlerRequest, StreamHandlerRequestInput>
 
-  export const codec = (): Codec<StreamHandlerRequest> => {
+  export const codec = (): Codec<StreamHandlerRequest, StreamHandlerRequestInput> => {
     if (_codec == null) {
-      _codec = message<StreamHandlerRequest>((obj, w, opts = {}) => {
+      _codec = message<StreamHandlerRequest, StreamHandlerRequestInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -1588,7 +1633,7 @@ export namespace StreamHandlerRequest {
     value: string
   }
 
-  export function encode (obj: Partial<StreamHandlerRequest>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: StreamHandlerRequestInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, StreamHandlerRequest.codec())
   }
 
@@ -1605,12 +1650,16 @@ export interface ErrorResponse {
   msg: string
 }
 
+export interface ErrorResponseInput {
+  msg?: string
+}
+
 export namespace ErrorResponse {
-  let _codec: Codec<ErrorResponse>
+  let _codec: Codec<ErrorResponse, ErrorResponseInput>
 
-  export const codec = (): Codec<ErrorResponse> => {
+  export const codec = (): Codec<ErrorResponse, ErrorResponseInput> => {
     if (_codec == null) {
-      _codec = message<ErrorResponse>((obj, w, opts = {}) => {
+      _codec = message<ErrorResponse, ErrorResponseInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -1693,7 +1742,7 @@ export namespace ErrorResponse {
     value: string
   }
 
-  export function encode (obj: Partial<ErrorResponse>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: ErrorResponseInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, ErrorResponse.codec())
   }
 
@@ -1712,12 +1761,18 @@ export interface StreamInfo {
   proto: string
 }
 
+export interface StreamInfoInput {
+  peer?: Uint8Array
+  addr?: Uint8Array
+  proto?: string
+}
+
 export namespace StreamInfo {
-  let _codec: Codec<StreamInfo>
+  let _codec: Codec<StreamInfo, StreamInfoInput>
 
-  export const codec = (): Codec<StreamInfo> => {
+  export const codec = (): Codec<StreamInfo, StreamInfoInput> => {
     if (_codec == null) {
-      _codec = message<StreamInfo>((obj, w, opts = {}) => {
+      _codec = message<StreamInfo, StreamInfoInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -1844,7 +1899,7 @@ export namespace StreamInfo {
     value: string
   }
 
-  export function encode (obj: Partial<StreamInfo>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: StreamInfoInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, StreamInfo.codec())
   }
 
@@ -1867,6 +1922,16 @@ export interface DHTRequest {
   timeout?: bigint
 }
 
+export interface DHTRequestInput {
+  type?: DHTRequest.Type
+  peer?: Uint8Array
+  cid?: Uint8Array
+  key?: Uint8Array
+  value?: Uint8Array
+  count?: number
+  timeout?: bigint
+}
+
 export namespace DHTRequest {
   export enum Type {
     FIND_PEER = 'FIND_PEER',
@@ -1893,16 +1958,16 @@ export namespace DHTRequest {
   }
 
   export namespace Type {
-    export const codec = (): Codec<Type> => {
+    export const codec = (): Codec<Type, Type> => {
       return enumeration<Type>(__TypeValues)
     }
   }
 
-  let _codec: Codec<DHTRequest>
+  let _codec: Codec<DHTRequest, DHTRequestInput>
 
-  export const codec = (): Codec<DHTRequest> => {
+  export const codec = (): Codec<DHTRequest, DHTRequestInput> => {
     if (_codec == null) {
-      _codec = message<DHTRequest>((obj, w, opts = {}) => {
+      _codec = message<DHTRequest, DHTRequestInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -2111,7 +2176,7 @@ export namespace DHTRequest {
     value: bigint
   }
 
-  export function encode (obj: Partial<DHTRequest>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: DHTRequestInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, DHTRequest.codec())
   }
 
@@ -2130,6 +2195,12 @@ export interface DHTResponse {
   value?: Uint8Array<ArrayBuffer>
 }
 
+export interface DHTResponseInput {
+  type?: DHTResponse.Type
+  peer?: PeerInfoInput
+  value?: Uint8Array
+}
+
 export namespace DHTResponse {
   export enum Type {
     BEGIN = 'BEGIN',
@@ -2144,16 +2215,16 @@ export namespace DHTResponse {
   }
 
   export namespace Type {
-    export const codec = (): Codec<Type> => {
+    export const codec = (): Codec<Type, Type> => {
       return enumeration<Type>(__TypeValues)
     }
   }
 
-  let _codec: Codec<DHTResponse>
+  let _codec: Codec<DHTResponse, DHTResponseInput>
 
-  export const codec = (): Codec<DHTResponse> => {
+  export const codec = (): Codec<DHTResponse, DHTResponseInput> => {
     if (_codec == null) {
-      _codec = message<DHTResponse>((obj, w, opts = {}) => {
+      _codec = message<DHTResponse, DHTResponseInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -2296,7 +2367,7 @@ export namespace DHTResponse {
     value: Uint8Array<ArrayBuffer>
   }
 
-  export function encode (obj: Partial<DHTResponse>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: DHTResponseInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, DHTResponse.codec())
   }
 
@@ -2314,12 +2385,17 @@ export interface PeerInfo {
   addrs: Uint8Array<ArrayBuffer>[]
 }
 
+export interface PeerInfoInput {
+  id?: Uint8Array
+  addrs?: Uint8Array[]
+}
+
 export namespace PeerInfo {
-  let _codec: Codec<PeerInfo>
+  let _codec: Codec<PeerInfo, PeerInfoInput>
 
-  export const codec = (): Codec<PeerInfo> => {
+  export const codec = (): Codec<PeerInfo, PeerInfoInput> => {
     if (_codec == null) {
-      _codec = message<PeerInfo>((obj, w, opts = {}) => {
+      _codec = message<PeerInfo, PeerInfoInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -2443,7 +2519,7 @@ export namespace PeerInfo {
     value: Uint8Array<ArrayBuffer>
   }
 
-  export function encode (obj: Partial<PeerInfo>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: PeerInfoInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, PeerInfo.codec())
   }
 
@@ -2463,6 +2539,13 @@ export interface ConnManagerRequest {
   weight?: bigint
 }
 
+export interface ConnManagerRequestInput {
+  type?: ConnManagerRequest.Type
+  peer?: Uint8Array
+  tag?: string
+  weight?: bigint
+}
+
 export namespace ConnManagerRequest {
   export enum Type {
     TAG_PEER = 'TAG_PEER',
@@ -2477,16 +2560,16 @@ export namespace ConnManagerRequest {
   }
 
   export namespace Type {
-    export const codec = (): Codec<Type> => {
+    export const codec = (): Codec<Type, Type> => {
       return enumeration<Type>(__TypeValues)
     }
   }
 
-  let _codec: Codec<ConnManagerRequest>
+  let _codec: Codec<ConnManagerRequest, ConnManagerRequestInput>
 
-  export const codec = (): Codec<ConnManagerRequest> => {
+  export const codec = (): Codec<ConnManagerRequest, ConnManagerRequestInput> => {
     if (_codec == null) {
-      _codec = message<ConnManagerRequest>((obj, w, opts = {}) => {
+      _codec = message<ConnManagerRequest, ConnManagerRequestInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -2632,7 +2715,7 @@ export namespace ConnManagerRequest {
     value: bigint
   }
 
-  export function encode (obj: Partial<ConnManagerRequest>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: ConnManagerRequestInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, ConnManagerRequest.codec())
   }
 
@@ -2649,12 +2732,16 @@ export interface DisconnectRequest {
   peer: Uint8Array<ArrayBuffer>
 }
 
+export interface DisconnectRequestInput {
+  peer?: Uint8Array
+}
+
 export namespace DisconnectRequest {
-  let _codec: Codec<DisconnectRequest>
+  let _codec: Codec<DisconnectRequest, DisconnectRequestInput>
 
-  export const codec = (): Codec<DisconnectRequest> => {
+  export const codec = (): Codec<DisconnectRequest, DisconnectRequestInput> => {
     if (_codec == null) {
-      _codec = message<DisconnectRequest>((obj, w, opts = {}) => {
+      _codec = message<DisconnectRequest, DisconnectRequestInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -2737,7 +2824,7 @@ export namespace DisconnectRequest {
     value: Uint8Array<ArrayBuffer>
   }
 
-  export function encode (obj: Partial<DisconnectRequest>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: DisconnectRequestInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, DisconnectRequest.codec())
   }
 
@@ -2756,6 +2843,12 @@ export interface PSRequest {
   data?: Uint8Array<ArrayBuffer>
 }
 
+export interface PSRequestInput {
+  type?: PSRequest.Type
+  topic?: string
+  data?: Uint8Array
+}
+
 export namespace PSRequest {
   export enum Type {
     GET_TOPICS = 'GET_TOPICS',
@@ -2772,16 +2865,16 @@ export namespace PSRequest {
   }
 
   export namespace Type {
-    export const codec = (): Codec<Type> => {
+    export const codec = (): Codec<Type, Type> => {
       return enumeration<Type>(__TypeValues)
     }
   }
 
-  let _codec: Codec<PSRequest>
+  let _codec: Codec<PSRequest, PSRequestInput>
 
-  export const codec = (): Codec<PSRequest> => {
+  export const codec = (): Codec<PSRequest, PSRequestInput> => {
     if (_codec == null) {
-      _codec = message<PSRequest>((obj, w, opts = {}) => {
+      _codec = message<PSRequest, PSRequestInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -2906,7 +2999,7 @@ export namespace PSRequest {
     value: Uint8Array<ArrayBuffer>
   }
 
-  export function encode (obj: Partial<PSRequest>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: PSRequestInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, PSRequest.codec())
   }
 
@@ -2928,12 +3021,21 @@ export interface PSMessage {
   key?: Uint8Array<ArrayBuffer>
 }
 
+export interface PSMessageInput {
+  from?: Uint8Array
+  data?: Uint8Array
+  seqno?: Uint8Array
+  topicIDs?: string[]
+  signature?: Uint8Array
+  key?: Uint8Array
+}
+
 export namespace PSMessage {
-  let _codec: Codec<PSMessage>
+  let _codec: Codec<PSMessage, PSMessageInput>
 
-  export const codec = (): Codec<PSMessage> => {
+  export const codec = (): Codec<PSMessage, PSMessageInput> => {
     if (_codec == null) {
-      _codec = message<PSMessage>((obj, w, opts = {}) => {
+      _codec = message<PSMessage, PSMessageInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -3140,7 +3242,7 @@ export namespace PSMessage {
     value: Uint8Array<ArrayBuffer>
   }
 
-  export function encode (obj: Partial<PSMessage>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: PSMessageInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, PSMessage.codec())
   }
 
@@ -3158,12 +3260,17 @@ export interface PSResponse {
   peerIDs: Uint8Array<ArrayBuffer>[]
 }
 
+export interface PSResponseInput {
+  topics?: string[]
+  peerIDs?: Uint8Array[]
+}
+
 export namespace PSResponse {
-  let _codec: Codec<PSResponse>
+  let _codec: Codec<PSResponse, PSResponseInput>
 
-  export const codec = (): Codec<PSResponse> => {
+  export const codec = (): Codec<PSResponse, PSResponseInput> => {
     if (_codec == null) {
-      _codec = message<PSResponse>((obj, w, opts = {}) => {
+      _codec = message<PSResponse, PSResponseInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -3303,7 +3410,7 @@ export namespace PSResponse {
     value: Uint8Array<ArrayBuffer>
   }
 
-  export function encode (obj: Partial<PSResponse>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: PSResponseInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, PSResponse.codec())
   }
 
@@ -3322,6 +3429,12 @@ export interface PeerstoreRequest {
   protos: string[]
 }
 
+export interface PeerstoreRequestInput {
+  type?: PeerstoreRequest.Type
+  id?: Uint8Array
+  protos?: string[]
+}
+
 export namespace PeerstoreRequest {
   export enum Type {
     INVALID = 'INVALID',
@@ -3336,16 +3449,16 @@ export namespace PeerstoreRequest {
   }
 
   export namespace Type {
-    export const codec = (): Codec<Type> => {
+    export const codec = (): Codec<Type, Type> => {
       return enumeration<Type>(__TypeValues)
     }
   }
 
-  let _codec: Codec<PeerstoreRequest>
+  let _codec: Codec<PeerstoreRequest, PeerstoreRequestInput>
 
-  export const codec = (): Codec<PeerstoreRequest> => {
+  export const codec = (): Codec<PeerstoreRequest, PeerstoreRequestInput> => {
     if (_codec == null) {
-      _codec = message<PeerstoreRequest>((obj, w, opts = {}) => {
+      _codec = message<PeerstoreRequest, PeerstoreRequestInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -3490,7 +3603,7 @@ export namespace PeerstoreRequest {
     value: string
   }
 
-  export function encode (obj: Partial<PeerstoreRequest>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: PeerstoreRequestInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, PeerstoreRequest.codec())
   }
 
@@ -3508,12 +3621,17 @@ export interface PeerstoreResponse {
   protos: string[]
 }
 
+export interface PeerstoreResponseInput {
+  peer?: PeerInfoInput
+  protos?: string[]
+}
+
 export namespace PeerstoreResponse {
-  let _codec: Codec<PeerstoreResponse>
+  let _codec: Codec<PeerstoreResponse, PeerstoreResponseInput>
 
-  export const codec = (): Codec<PeerstoreResponse> => {
+  export const codec = (): Codec<PeerstoreResponse, PeerstoreResponseInput> => {
     if (_codec == null) {
-      _codec = message<PeerstoreResponse>((obj, w, opts = {}) => {
+      _codec = message<PeerstoreResponse, PeerstoreResponseInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -3654,7 +3772,7 @@ export namespace PeerstoreResponse {
     value: string
   }
 
-  export function encode (obj: Partial<PeerstoreResponse>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: PeerstoreResponseInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, PeerstoreResponse.codec())
   }
 
diff --git a/packages/protons/test/fixtures/dht.ts b/packages/protons/test/fixtures/dht.ts
index a7626f8..be998ac 100644
--- a/packages/protons/test/fixtures/dht.ts
+++ b/packages/protons/test/fixtures/dht.ts
@@ -10,12 +10,20 @@ export interface Record {
   timeReceived?: string
 }
 
+export interface RecordInput {
+  key?: Uint8Array
+  value?: Uint8Array
+  author?: Uint8Array
+  signature?: Uint8Array
+  timeReceived?: string
+}
+
 export namespace Record {
-  let _codec: Codec<Record>
+  let _codec: Codec<Record, RecordInput>
 
-  export const codec = (): Codec<Record> => {
+  export const codec = (): Codec<Record, RecordInput> => {
     if (_codec == null) {
-      _codec = message<Record>((obj, w, opts = {}) => {
+      _codec = message<Record, RecordInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -180,7 +188,7 @@ export namespace Record {
     value: string
   }
 
-  export function encode (obj: Partial<Record>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: RecordInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Record.codec())
   }
 
@@ -202,6 +210,15 @@ export interface Message {
   providerPeers: Message.Peer[]
 }
 
+export interface MessageInput {
+  type?: Message.MessageType
+  clusterLevelRaw?: number
+  key?: Uint8Array
+  record?: Uint8Array
+  closerPeers?: Message.PeerInput[]
+  providerPeers?: Message.PeerInput[]
+}
+
 export namespace Message {
   export enum MessageType {
     PUT_VALUE = 'PUT_VALUE',
@@ -222,7 +239,7 @@ export namespace Message {
   }
 
   export namespace MessageType {
-    export const codec = (): Codec<MessageType> => {
+    export const codec = (): Codec<MessageType, MessageType> => {
       return enumeration<MessageType>(__MessageTypeValues)
     }
   }
@@ -242,7 +259,7 @@ export namespace Message {
   }
 
   export namespace ConnectionType {
-    export const codec = (): Codec<ConnectionType> => {
+    export const codec = (): Codec<ConnectionType, ConnectionType> => {
       return enumeration<ConnectionType>(__ConnectionTypeValues)
     }
   }
@@ -253,12 +270,18 @@ export namespace Message {
     connection?: Message.ConnectionType
   }
 
+  export interface PeerInput {
+    id?: Uint8Array
+    addrs?: Uint8Array[]
+    connection?: Message.ConnectionType
+  }
+
   export namespace Peer {
-    let _codec: Codec<Peer>
+    let _codec: Codec<Peer, PeerInput>
 
-    export const codec = (): Codec<Peer> => {
+    export const codec = (): Codec<Peer, PeerInput> => {
       if (_codec == null) {
-        _codec = message<Peer>((obj, w, opts = {}) => {
+        _codec = message<Peer, PeerInput>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
             w.fork()
           }
@@ -402,7 +425,7 @@ export namespace Message {
       value: Message.ConnectionType
     }
 
-    export function encode (obj: Partial<Peer>): Uint8Array<ArrayBuffer> {
+    export function encode (obj: PeerInput): Uint8Array<ArrayBuffer> {
       return encodeMessage(obj, Peer.codec())
     }
 
@@ -415,11 +438,11 @@ export namespace Message {
     }
   }
 
-  let _codec: Codec<Message>
+  let _codec: Codec<Message, MessageInput>
 
-  export const codec = (): Codec<Message> => {
+  export const codec = (): Codec<Message, MessageInput> => {
     if (_codec == null) {
-      _codec = message<Message>((obj, w, opts = {}) => {
+      _codec = message<Message, MessageInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -705,7 +728,7 @@ export namespace Message {
     message: string
   }
 
-  export function encode (obj: Partial<Message>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: MessageInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Message.codec())
   }
 
diff --git a/packages/protons/test/fixtures/maps.ts b/packages/protons/test/fixtures/maps.ts
index f939e48..81506d6 100644
--- a/packages/protons/test/fixtures/maps.ts
+++ b/packages/protons/test/fixtures/maps.ts
@@ -15,7 +15,7 @@ enum __EnumValueValues {
 }
 
 export namespace EnumValue {
-  export const codec = (): Codec<EnumValue> => {
+  export const codec = (): Codec<EnumValue, EnumValue> => {
     return enumeration<EnumValue>(__EnumValueValues)
   }
 }
@@ -25,12 +25,17 @@ export interface SubMessage {
   bar: number[]
 }
 
+export interface SubMessageInput {
+  foo?: string
+  bar?: number[]
+}
+
 export namespace SubMessage {
-  let _codec: Codec<SubMessage>
+  let _codec: Codec<SubMessage, SubMessageInput>
 
-  export const codec = (): Codec<SubMessage> => {
+  export const codec = (): Codec<SubMessage, SubMessageInput> => {
     if (_codec == null) {
-      _codec = message<SubMessage>((obj, w, opts = {}) => {
+      _codec = message<SubMessage, SubMessageInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -154,7 +159,7 @@ export namespace SubMessage {
     value: number
   }
 
-  export function encode (obj: Partial<SubMessage>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: SubMessageInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, SubMessage.codec())
   }
 
@@ -175,18 +180,31 @@ export interface MapTypes {
   enumMap: Map<string, EnumValue>
 }
 
+export interface MapTypesInput {
+  stringMap?: Map<string, string>
+  intMap?: Map<number, number>
+  boolMap?: Map<boolean, boolean>
+  messageMap?: Map<string, SubMessageInput>
+  enumMap?: Map<string, EnumValue>
+}
+
 export namespace MapTypes {
   export interface MapTypes$stringMapEntry {
     key: string
     value: string
   }
 
+  export interface MapTypes$stringMapEntryInput {
+    key?: string
+    value?: string
+  }
+
   export namespace MapTypes$stringMapEntry {
-    let _codec: Codec<MapTypes$stringMapEntry>
+    let _codec: Codec<MapTypes$stringMapEntry, MapTypes$stringMapEntryInput>
 
-    export const codec = (): Codec<MapTypes$stringMapEntry> => {
+    export const codec = (): Codec<MapTypes$stringMapEntry, MapTypes$stringMapEntryInput> => {
       if (_codec == null) {
-        _codec = message<MapTypes$stringMapEntry>((obj, w, opts = {}) => {
+        _codec = message<MapTypes$stringMapEntry, MapTypes$stringMapEntryInput>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
             w.fork()
           }
@@ -291,7 +309,7 @@ export namespace MapTypes {
       value: string
     }
 
-    export function encode (obj: Partial<MapTypes$stringMapEntry>): Uint8Array<ArrayBuffer> {
+    export function encode (obj: MapTypes$stringMapEntryInput): Uint8Array<ArrayBuffer> {
       return encodeMessage(obj, MapTypes$stringMapEntry.codec())
     }
 
@@ -309,12 +327,17 @@ export namespace MapTypes {
     value: number
   }
 
+  export interface MapTypes$intMapEntryInput {
+    key?: number
+    value?: number
+  }
+
   export namespace MapTypes$intMapEntry {
-    let _codec: Codec<MapTypes$intMapEntry>
+    let _codec: Codec<MapTypes$intMapEntry, MapTypes$intMapEntryInput>
 
-    export const codec = (): Codec<MapTypes$intMapEntry> => {
+    export const codec = (): Codec<MapTypes$intMapEntry, MapTypes$intMapEntryInput> => {
       if (_codec == null) {
-        _codec = message<MapTypes$intMapEntry>((obj, w, opts = {}) => {
+        _codec = message<MapTypes$intMapEntry, MapTypes$intMapEntryInput>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
             w.fork()
           }
@@ -419,7 +442,7 @@ export namespace MapTypes {
       value: number
     }
 
-    export function encode (obj: Partial<MapTypes$intMapEntry>): Uint8Array<ArrayBuffer> {
+    export function encode (obj: MapTypes$intMapEntryInput): Uint8Array<ArrayBuffer> {
       return encodeMessage(obj, MapTypes$intMapEntry.codec())
     }
 
@@ -437,12 +460,17 @@ export namespace MapTypes {
     value: boolean
   }
 
+  export interface MapTypes$boolMapEntryInput {
+    key?: boolean
+    value?: boolean
+  }
+
   export namespace MapTypes$boolMapEntry {
-    let _codec: Codec<MapTypes$boolMapEntry>
+    let _codec: Codec<MapTypes$boolMapEntry, MapTypes$boolMapEntryInput>
 
-    export const codec = (): Codec<MapTypes$boolMapEntry> => {
+    export const codec = (): Codec<MapTypes$boolMapEntry, MapTypes$boolMapEntryInput> => {
       if (_codec == null) {
-        _codec = message<MapTypes$boolMapEntry>((obj, w, opts = {}) => {
+        _codec = message<MapTypes$boolMapEntry, MapTypes$boolMapEntryInput>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
             w.fork()
           }
@@ -547,7 +575,7 @@ export namespace MapTypes {
       value: boolean
     }
 
-    export function encode (obj: Partial<MapTypes$boolMapEntry>): Uint8Array<ArrayBuffer> {
+    export function encode (obj: MapTypes$boolMapEntryInput): Uint8Array<ArrayBuffer> {
       return encodeMessage(obj, MapTypes$boolMapEntry.codec())
     }
 
@@ -565,12 +593,17 @@ export namespace MapTypes {
     value?: SubMessage
   }
 
+  export interface MapTypes$messageMapEntryInput {
+    key?: string
+    value?: SubMessageInput
+  }
+
   export namespace MapTypes$messageMapEntry {
-    let _codec: Codec<MapTypes$messageMapEntry>
+    let _codec: Codec<MapTypes$messageMapEntry, MapTypes$messageMapEntryInput>
 
-    export const codec = (): Codec<MapTypes$messageMapEntry> => {
+    export const codec = (): Codec<MapTypes$messageMapEntry, MapTypes$messageMapEntryInput> => {
       if (_codec == null) {
-        _codec = message<MapTypes$messageMapEntry>((obj, w, opts = {}) => {
+        _codec = message<MapTypes$messageMapEntry, MapTypes$messageMapEntryInput>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
             w.fork()
           }
@@ -692,7 +725,7 @@ export namespace MapTypes {
       value: number
     }
 
-    export function encode (obj: Partial<MapTypes$messageMapEntry>): Uint8Array<ArrayBuffer> {
+    export function encode (obj: MapTypes$messageMapEntryInput): Uint8Array<ArrayBuffer> {
       return encodeMessage(obj, MapTypes$messageMapEntry.codec())
     }
 
@@ -710,12 +743,17 @@ export namespace MapTypes {
     value: EnumValue
   }
 
+  export interface MapTypes$enumMapEntryInput {
+    key?: string
+    value?: EnumValue
+  }
+
   export namespace MapTypes$enumMapEntry {
-    let _codec: Codec<MapTypes$enumMapEntry>
+    let _codec: Codec<MapTypes$enumMapEntry, MapTypes$enumMapEntryInput>
 
-    export const codec = (): Codec<MapTypes$enumMapEntry> => {
+    export const codec = (): Codec<MapTypes$enumMapEntry, MapTypes$enumMapEntryInput> => {
       if (_codec == null) {
-        _codec = message<MapTypes$enumMapEntry>((obj, w, opts = {}) => {
+        _codec = message<MapTypes$enumMapEntry, MapTypes$enumMapEntryInput>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
             w.fork()
           }
@@ -820,7 +858,7 @@ export namespace MapTypes {
       value: EnumValue
     }
 
-    export function encode (obj: Partial<MapTypes$enumMapEntry>): Uint8Array<ArrayBuffer> {
+    export function encode (obj: MapTypes$enumMapEntryInput): Uint8Array<ArrayBuffer> {
       return encodeMessage(obj, MapTypes$enumMapEntry.codec())
     }
 
@@ -833,11 +871,11 @@ export namespace MapTypes {
     }
   }
 
-  let _codec: Codec<MapTypes>
+  let _codec: Codec<MapTypes, MapTypesInput>
 
-  export const codec = (): Codec<MapTypes> => {
+  export const codec = (): Codec<MapTypes, MapTypesInput> => {
     if (_codec == null) {
-      _codec = message<MapTypes>((obj, w, opts = {}) => {
+      _codec = message<MapTypes, MapTypesInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -1137,7 +1175,7 @@ export namespace MapTypes {
     value: EnumValue
   }
 
-  export function encode (obj: Partial<MapTypes>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: MapTypesInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, MapTypes.codec())
   }
 
diff --git a/packages/protons/test/fixtures/noise.ts b/packages/protons/test/fixtures/noise.ts
index 9b25a48..13a7ed8 100644
--- a/packages/protons/test/fixtures/noise.ts
+++ b/packages/protons/test/fixtures/noise.ts
@@ -3,6 +3,8 @@ import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc'
 import type { Codec, DecodeOptions } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
+export interface pbInput {}
+
 export interface pb {}
 
 export namespace pb {
@@ -12,12 +14,18 @@ export namespace pb {
     data: Uint8Array<ArrayBuffer>
   }
 
+  export interface NoiseHandshakePayloadInput {
+    identityKey?: Uint8Array
+    identitySig?: Uint8Array
+    data?: Uint8Array
+  }
+
   export namespace NoiseHandshakePayload {
-    let _codec: Codec<NoiseHandshakePayload>
+    let _codec: Codec<NoiseHandshakePayload, NoiseHandshakePayloadInput>
 
-    export const codec = (): Codec<NoiseHandshakePayload> => {
+    export const codec = (): Codec<NoiseHandshakePayload, NoiseHandshakePayloadInput> => {
       if (_codec == null) {
-        _codec = message<NoiseHandshakePayload>((obj, w, opts = {}) => {
+        _codec = message<NoiseHandshakePayload, NoiseHandshakePayloadInput>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
             w.fork()
           }
@@ -144,7 +152,7 @@ export namespace pb {
       value: Uint8Array<ArrayBuffer>
     }
 
-    export function encode (obj: Partial<NoiseHandshakePayload>): Uint8Array<ArrayBuffer> {
+    export function encode (obj: NoiseHandshakePayloadInput): Uint8Array<ArrayBuffer> {
       return encodeMessage(obj, NoiseHandshakePayload.codec())
     }
 
@@ -157,11 +165,11 @@ export namespace pb {
     }
   }
 
-  let _codec: Codec<pb>
+  let _codec: Codec<pb, pbInput>
 
-  export const codec = (): Codec<pb> => {
+  export const codec = (): Codec<pb, pbInput> => {
     if (_codec == null) {
-      _codec = message<pb>((obj, w, opts = {}) => {
+      _codec = message<pb, pbInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -221,7 +229,7 @@ export namespace pb {
     return _codec
   }
 
-  export function encode (obj: Partial<pb>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: pbInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, pb.codec())
   }
 
diff --git a/packages/protons/test/fixtures/oneof.ts b/packages/protons/test/fixtures/oneof.ts
index 0a01cd1..29f7488 100644
--- a/packages/protons/test/fixtures/oneof.ts
+++ b/packages/protons/test/fixtures/oneof.ts
@@ -13,7 +13,7 @@ enum __EnumTypeValues {
 }
 
 export namespace EnumType {
-  export const codec = (): Codec<EnumType> => {
+  export const codec = (): Codec<EnumType, EnumType> => {
     return enumeration<EnumType>(__EnumTypeValues)
   }
 }
@@ -26,12 +26,20 @@ export interface OneOfMessage {
   fieldFive: string
 }
 
+export interface OneOfMessageInput {
+  fieldOne?: string
+  fieldTwo?: string
+  fieldThree?: EnumType
+  fieldFour?: EnumType
+  fieldFive?: string
+}
+
 export namespace OneOfMessage {
-  let _codec: Codec<OneOfMessage>
+  let _codec: Codec<OneOfMessage, OneOfMessageInput>
 
-  export const codec = (): Codec<OneOfMessage> => {
+  export const codec = (): Codec<OneOfMessage, OneOfMessageInput> => {
     if (_codec == null) {
-      _codec = message<OneOfMessage>((obj, w, opts = {}) => {
+      _codec = message<OneOfMessage, OneOfMessageInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -232,7 +240,7 @@ export namespace OneOfMessage {
     value: string
   }
 
-  export function encode (obj: Partial<OneOfMessage>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: OneOfMessageInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, OneOfMessage.codec())
   }
 
@@ -253,12 +261,20 @@ export interface MessageWithoutOneOfs {
   fieldFive: string
 }
 
+export interface MessageWithoutOneOfsInput {
+  fieldOne?: string
+  fieldTwo?: string
+  fieldThree?: EnumType
+  fieldFour?: EnumType
+  fieldFive?: string
+}
+
 export namespace MessageWithoutOneOfs {
-  let _codec: Codec<MessageWithoutOneOfs>
+  let _codec: Codec<MessageWithoutOneOfs, MessageWithoutOneOfsInput>
 
-  export const codec = (): Codec<MessageWithoutOneOfs> => {
+  export const codec = (): Codec<MessageWithoutOneOfs, MessageWithoutOneOfsInput> => {
     if (_codec == null) {
-      _codec = message<MessageWithoutOneOfs>((obj, w, opts = {}) => {
+      _codec = message<MessageWithoutOneOfs, MessageWithoutOneOfsInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -429,7 +445,7 @@ export namespace MessageWithoutOneOfs {
     value: string
   }
 
-  export function encode (obj: Partial<MessageWithoutOneOfs>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: MessageWithoutOneOfsInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, MessageWithoutOneOfs.codec())
   }
 
diff --git a/packages/protons/test/fixtures/optional.ts b/packages/protons/test/fixtures/optional.ts
index 6e407a1..70bb5b5 100644
--- a/packages/protons/test/fixtures/optional.ts
+++ b/packages/protons/test/fixtures/optional.ts
@@ -15,7 +15,7 @@ enum __OptionalEnumValues {
 }
 
 export namespace OptionalEnum {
-  export const codec = (): Codec<OptionalEnum> => {
+  export const codec = (): Codec<OptionalEnum, OptionalEnum> => {
     return enumeration<OptionalEnum>(__OptionalEnumValues)
   }
 }
@@ -25,12 +25,17 @@ export interface OptionalSubMessage {
   bar?: number
 }
 
+export interface OptionalSubMessageInput {
+  foo?: string
+  bar?: number
+}
+
 export namespace OptionalSubMessage {
-  let _codec: Codec<OptionalSubMessage>
+  let _codec: Codec<OptionalSubMessage, OptionalSubMessageInput>
 
-  export const codec = (): Codec<OptionalSubMessage> => {
+  export const codec = (): Codec<OptionalSubMessage, OptionalSubMessageInput> => {
     if (_codec == null) {
-      _codec = message<OptionalSubMessage>((obj, w, opts = {}) => {
+      _codec = message<OptionalSubMessage, OptionalSubMessageInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -132,7 +137,7 @@ export namespace OptionalSubMessage {
     value: number
   }
 
-  export function encode (obj: Partial<OptionalSubMessage>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: OptionalSubMessageInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, OptionalSubMessage.codec())
   }
 
@@ -165,12 +170,32 @@ export interface Optional {
   subMessage?: OptionalSubMessage
 }
 
+export interface OptionalInput {
+  double?: number
+  float?: number
+  int32?: number
+  int64?: bigint
+  uint32?: number
+  uint64?: bigint
+  sint32?: number
+  sint64?: bigint
+  fixed32?: number
+  fixed64?: bigint
+  sfixed32?: number
+  sfixed64?: bigint
+  bool?: boolean
+  string?: string
+  bytes?: Uint8Array
+  enum?: OptionalEnum
+  subMessage?: OptionalSubMessageInput
+}
+
 export namespace Optional {
-  let _codec: Codec<Optional>
+  let _codec: Codec<Optional, OptionalInput>
 
-  export const codec = (): Codec<Optional> => {
+  export const codec = (): Codec<Optional, OptionalInput> => {
     if (_codec == null) {
-      _codec = message<Optional>((obj, w, opts = {}) => {
+      _codec = message<Optional, OptionalInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -604,7 +629,7 @@ export namespace Optional {
     value: number
   }
 
-  export function encode (obj: Partial<Optional>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: OptionalInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Optional.codec())
   }
 
diff --git a/packages/protons/test/fixtures/peer.ts b/packages/protons/test/fixtures/peer.ts
index afcda87..f2f43e9 100644
--- a/packages/protons/test/fixtures/peer.ts
+++ b/packages/protons/test/fixtures/peer.ts
@@ -11,12 +11,20 @@ export interface Peer {
   peerRecordEnvelope?: Uint8Array<ArrayBuffer>
 }
 
+export interface PeerInput {
+  addresses?: AddressInput[]
+  protocols?: string[]
+  metadata?: MetadataInput[]
+  pubKey?: Uint8Array
+  peerRecordEnvelope?: Uint8Array
+}
+
 export namespace Peer {
-  let _codec: Codec<Peer>
+  let _codec: Codec<Peer, PeerInput>
 
-  export const codec = (): Codec<Peer> => {
+  export const codec = (): Codec<Peer, PeerInput> => {
     if (_codec == null) {
-      _codec = message<Peer>((obj, w, opts = {}) => {
+      _codec = message<Peer, PeerInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -286,7 +294,7 @@ export namespace Peer {
     value: Uint8Array<ArrayBuffer>
   }
 
-  export function encode (obj: Partial<Peer>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: PeerInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Peer.codec())
   }
 
@@ -304,12 +312,17 @@ export interface Address {
   isCertified?: boolean
 }
 
+export interface AddressInput {
+  multiaddr?: Uint8Array
+  isCertified?: boolean
+}
+
 export namespace Address {
-  let _codec: Codec<Address>
+  let _codec: Codec<Address, AddressInput>
 
-  export const codec = (): Codec<Address> => {
+  export const codec = (): Codec<Address, AddressInput> => {
     if (_codec == null) {
-      _codec = message<Address>((obj, w, opts = {}) => {
+      _codec = message<Address, AddressInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -413,7 +426,7 @@ export namespace Address {
     value: boolean
   }
 
-  export function encode (obj: Partial<Address>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: AddressInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Address.codec())
   }
 
@@ -431,12 +444,17 @@ export interface Metadata {
   value: Uint8Array<ArrayBuffer>
 }
 
+export interface MetadataInput {
+  key?: string
+  value?: Uint8Array
+}
+
 export namespace Metadata {
-  let _codec: Codec<Metadata>
+  let _codec: Codec<Metadata, MetadataInput>
 
-  export const codec = (): Codec<Metadata> => {
+  export const codec = (): Codec<Metadata, MetadataInput> => {
     if (_codec == null) {
-      _codec = message<Metadata>((obj, w, opts = {}) => {
+      _codec = message<Metadata, MetadataInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -541,7 +559,7 @@ export namespace Metadata {
     value: Uint8Array<ArrayBuffer>
   }
 
-  export function encode (obj: Partial<Metadata>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: MetadataInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Metadata.codec())
   }
 
diff --git a/packages/protons/test/fixtures/proto2.ts b/packages/protons/test/fixtures/proto2.ts
index 78580f2..014113d 100644
--- a/packages/protons/test/fixtures/proto2.ts
+++ b/packages/protons/test/fixtures/proto2.ts
@@ -6,20 +6,22 @@ export interface MessageWithRequired {
   scalarField: number
 }
 
+export interface MessageWithRequiredInput {
+  scalarField: number
+}
+
 export namespace MessageWithRequired {
-  let _codec: Codec<MessageWithRequired>
+  let _codec: Codec<MessageWithRequired, MessageWithRequiredInput>
 
-  export const codec = (): Codec<MessageWithRequired> => {
+  export const codec = (): Codec<MessageWithRequired, MessageWithRequiredInput> => {
     if (_codec == null) {
-      _codec = message<MessageWithRequired>((obj, w, opts = {}) => {
+      _codec = message<MessageWithRequired, MessageWithRequiredInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
 
-        if (obj.scalarField != null) {
-          w.uint32(8)
-          w.int32(obj.scalarField)
-        }
+        w.uint32(8)
+        w.int32(obj.scalarField)
 
         if (opts.lengthDelimited !== false) {
           w.ldelim()
@@ -94,7 +96,7 @@ export namespace MessageWithRequired {
     value: number
   }
 
-  export function encode (obj: Partial<MessageWithRequired>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: MessageWithRequiredInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, MessageWithRequired.codec())
   }
 
diff --git a/packages/protons/test/fixtures/protons-options.ts b/packages/protons/test/fixtures/protons-options.ts
index 462fc4b..c6c79d8 100644
--- a/packages/protons/test/fixtures/protons-options.ts
+++ b/packages/protons/test/fixtures/protons-options.ts
@@ -6,12 +6,16 @@ export interface MessageWithSizeLimitedRepeatedField {
   repeatedField: string[]
 }
 
+export interface MessageWithSizeLimitedRepeatedFieldInput {
+  repeatedField?: string[]
+}
+
 export namespace MessageWithSizeLimitedRepeatedField {
-  let _codec: Codec<MessageWithSizeLimitedRepeatedField>
+  let _codec: Codec<MessageWithSizeLimitedRepeatedField, MessageWithSizeLimitedRepeatedFieldInput>
 
-  export const codec = (): Codec<MessageWithSizeLimitedRepeatedField> => {
+  export const codec = (): Codec<MessageWithSizeLimitedRepeatedField, MessageWithSizeLimitedRepeatedFieldInput> => {
     if (_codec == null) {
-      _codec = message<MessageWithSizeLimitedRepeatedField>((obj, w, opts = {}) => {
+      _codec = message<MessageWithSizeLimitedRepeatedField, MessageWithSizeLimitedRepeatedFieldInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -121,7 +125,7 @@ export namespace MessageWithSizeLimitedRepeatedField {
     value: string
   }
 
-  export function encode (obj: Partial<MessageWithSizeLimitedRepeatedField>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: MessageWithSizeLimitedRepeatedFieldInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, MessageWithSizeLimitedRepeatedField.codec())
   }
 
@@ -138,18 +142,27 @@ export interface MessageWithSizeLimitedMap {
   mapField: Map<string, string>
 }
 
+export interface MessageWithSizeLimitedMapInput {
+  mapField?: Map<string, string>
+}
+
 export namespace MessageWithSizeLimitedMap {
   export interface MessageWithSizeLimitedMap$mapFieldEntry {
     key: string
     value: string
   }
 
+  export interface MessageWithSizeLimitedMap$mapFieldEntryInput {
+    key?: string
+    value?: string
+  }
+
   export namespace MessageWithSizeLimitedMap$mapFieldEntry {
-    let _codec: Codec<MessageWithSizeLimitedMap$mapFieldEntry>
+    let _codec: Codec<MessageWithSizeLimitedMap$mapFieldEntry, MessageWithSizeLimitedMap$mapFieldEntryInput>
 
-    export const codec = (): Codec<MessageWithSizeLimitedMap$mapFieldEntry> => {
+    export const codec = (): Codec<MessageWithSizeLimitedMap$mapFieldEntry, MessageWithSizeLimitedMap$mapFieldEntryInput> => {
       if (_codec == null) {
-        _codec = message<MessageWithSizeLimitedMap$mapFieldEntry>((obj, w, opts = {}) => {
+        _codec = message<MessageWithSizeLimitedMap$mapFieldEntry, MessageWithSizeLimitedMap$mapFieldEntryInput>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
             w.fork()
           }
@@ -254,7 +267,7 @@ export namespace MessageWithSizeLimitedMap {
       value: string
     }
 
-    export function encode (obj: Partial<MessageWithSizeLimitedMap$mapFieldEntry>): Uint8Array<ArrayBuffer> {
+    export function encode (obj: MessageWithSizeLimitedMap$mapFieldEntryInput): Uint8Array<ArrayBuffer> {
       return encodeMessage(obj, MessageWithSizeLimitedMap$mapFieldEntry.codec())
     }
 
@@ -267,11 +280,11 @@ export namespace MessageWithSizeLimitedMap {
     }
   }
 
-  let _codec: Codec<MessageWithSizeLimitedMap>
+  let _codec: Codec<MessageWithSizeLimitedMap, MessageWithSizeLimitedMapInput>
 
-  export const codec = (): Codec<MessageWithSizeLimitedMap> => {
+  export const codec = (): Codec<MessageWithSizeLimitedMap, MessageWithSizeLimitedMapInput> => {
     if (_codec == null) {
-      _codec = message<MessageWithSizeLimitedMap>((obj, w, opts = {}) => {
+      _codec = message<MessageWithSizeLimitedMap, MessageWithSizeLimitedMapInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -386,7 +399,7 @@ export namespace MessageWithSizeLimitedMap {
     value: string
   }
 
-  export function encode (obj: Partial<MessageWithSizeLimitedMap>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: MessageWithSizeLimitedMapInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, MessageWithSizeLimitedMap.codec())
   }
 
diff --git a/packages/protons/test/fixtures/repeated.ts b/packages/protons/test/fixtures/repeated.ts
index 3fca755..de8b711 100644
--- a/packages/protons/test/fixtures/repeated.ts
+++ b/packages/protons/test/fixtures/repeated.ts
@@ -7,12 +7,17 @@ export interface SubSubMessage {
   nonRepeating?: number
 }
 
+export interface SubSubMessageInput {
+  foo?: string[]
+  nonRepeating?: number
+}
+
 export namespace SubSubMessage {
-  let _codec: Codec<SubSubMessage>
+  let _codec: Codec<SubSubMessage, SubSubMessageInput>
 
-  export const codec = (): Codec<SubSubMessage> => {
+  export const codec = (): Codec<SubSubMessage, SubSubMessageInput> => {
     if (_codec == null) {
-      _codec = message<SubSubMessage>((obj, w, opts = {}) => {
+      _codec = message<SubSubMessage, SubSubMessageInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -135,7 +140,7 @@ export namespace SubSubMessage {
     value: number
   }
 
-  export function encode (obj: Partial<SubSubMessage>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: SubSubMessageInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, SubSubMessage.codec())
   }
 
@@ -155,12 +160,19 @@ export interface SubMessage {
   messages: SubSubMessage[]
 }
 
+export interface SubMessageInput {
+  foo?: string[]
+  nonRepeating?: number
+  message?: SubSubMessageInput
+  messages?: SubSubMessageInput[]
+}
+
 export namespace SubMessage {
-  let _codec: Codec<SubMessage>
+  let _codec: Codec<SubMessage, SubMessageInput>
 
-  export const codec = (): Codec<SubMessage> => {
+  export const codec = (): Codec<SubMessage, SubMessageInput> => {
     if (_codec == null) {
-      _codec = message<SubMessage>((obj, w, opts = {}) => {
+      _codec = message<SubMessage, SubMessageInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -385,7 +397,7 @@ export namespace SubMessage {
     message: string
   }
 
-  export function encode (obj: Partial<SubMessage>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: SubMessageInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, SubMessage.codec())
   }
 
@@ -406,12 +418,20 @@ export interface RepeatedTypes {
   nonRepeating?: number
 }
 
+export interface RepeatedTypesInput {
+  number?: number[]
+  limitedNumber?: number[]
+  messages?: SubMessageInput[]
+  message?: SubMessageInput
+  nonRepeating?: number
+}
+
 export namespace RepeatedTypes {
-  let _codec: Codec<RepeatedTypes>
+  let _codec: Codec<RepeatedTypes, RepeatedTypesInput>
 
-  export const codec = (): Codec<RepeatedTypes> => {
+  export const codec = (): Codec<RepeatedTypes, RepeatedTypesInput> => {
     if (_codec == null) {
-      _codec = message<RepeatedTypes>((obj, w, opts = {}) => {
+      _codec = message<RepeatedTypes, RepeatedTypesInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -779,7 +799,7 @@ export namespace RepeatedTypes {
     value: number
   }
 
-  export function encode (obj: Partial<RepeatedTypes>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: RepeatedTypesInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, RepeatedTypes.codec())
   }
 
diff --git a/packages/protons/test/fixtures/singular.ts b/packages/protons/test/fixtures/singular.ts
index d9f5c8c..1f931a3 100644
--- a/packages/protons/test/fixtures/singular.ts
+++ b/packages/protons/test/fixtures/singular.ts
@@ -16,7 +16,7 @@ enum __SingularEnumValues {
 }
 
 export namespace SingularEnum {
-  export const codec = (): Codec<SingularEnum> => {
+  export const codec = (): Codec<SingularEnum, SingularEnum> => {
     return enumeration<SingularEnum>(__SingularEnumValues)
   }
 }
@@ -26,12 +26,17 @@ export interface SingularSubMessage {
   bar: number
 }
 
+export interface SingularSubMessageInput {
+  foo?: string
+  bar?: number
+}
+
 export namespace SingularSubMessage {
-  let _codec: Codec<SingularSubMessage>
+  let _codec: Codec<SingularSubMessage, SingularSubMessageInput>
 
-  export const codec = (): Codec<SingularSubMessage> => {
+  export const codec = (): Codec<SingularSubMessage, SingularSubMessageInput> => {
     if (_codec == null) {
-      _codec = message<SingularSubMessage>((obj, w, opts = {}) => {
+      _codec = message<SingularSubMessage, SingularSubMessageInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -136,7 +141,7 @@ export namespace SingularSubMessage {
     value: number
   }
 
-  export function encode (obj: Partial<SingularSubMessage>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: SingularSubMessageInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, SingularSubMessage.codec())
   }
 
@@ -169,12 +174,32 @@ export interface Singular {
   subMessage?: SingularSubMessage
 }
 
+export interface SingularInput {
+  double?: number
+  float?: number
+  int32?: number
+  int64?: bigint
+  uint32?: number
+  uint64?: bigint
+  sint32?: number
+  sint64?: bigint
+  fixed32?: number
+  fixed64?: bigint
+  sfixed32?: number
+  sfixed64?: bigint
+  bool?: boolean
+  string?: string
+  bytes?: Uint8Array
+  enum?: SingularEnum
+  subMessage?: SingularSubMessageInput
+}
+
 export namespace Singular {
-  let _codec: Codec<Singular>
+  let _codec: Codec<Singular, SingularInput>
 
-  export const codec = (): Codec<Singular> => {
+  export const codec = (): Codec<Singular, SingularInput> => {
     if (_codec == null) {
-      _codec = message<Singular>((obj, w, opts = {}) => {
+      _codec = message<Singular, SingularInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -625,7 +650,7 @@ export namespace Singular {
     value: number
   }
 
-  export function encode (obj: Partial<Singular>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: SingularInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Singular.codec())
   }
 
diff --git a/packages/protons/test/fixtures/streaming.ts b/packages/protons/test/fixtures/streaming.ts
index 8e8f960..e07c504 100644
--- a/packages/protons/test/fixtures/streaming.ts
+++ b/packages/protons/test/fixtures/streaming.ts
@@ -8,12 +8,18 @@ export interface MessageWithArrayField {
   arr: string[]
 }
 
+export interface MessageWithArrayFieldInput {
+  field1?: boolean
+  field2?: number
+  arr?: string[]
+}
+
 export namespace MessageWithArrayField {
-  let _codec: Codec<MessageWithArrayField>
+  let _codec: Codec<MessageWithArrayField, MessageWithArrayFieldInput>
 
-  export const codec = (): Codec<MessageWithArrayField> => {
+  export const codec = (): Codec<MessageWithArrayField, MessageWithArrayFieldInput> => {
     if (_codec == null) {
-      _codec = message<MessageWithArrayField>((obj, w, opts = {}) => {
+      _codec = message<MessageWithArrayField, MessageWithArrayFieldInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -157,7 +163,7 @@ export namespace MessageWithArrayField {
     value: string
   }
 
-  export function encode (obj: Partial<MessageWithArrayField>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: MessageWithArrayFieldInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, MessageWithArrayField.codec())
   }
 
@@ -174,12 +180,16 @@ export interface NestedMessage {
   nestedValue: string
 }
 
+export interface NestedMessageInput {
+  nestedValue?: string
+}
+
 export namespace NestedMessage {
-  let _codec: Codec<NestedMessage>
+  let _codec: Codec<NestedMessage, NestedMessageInput>
 
-  export const codec = (): Codec<NestedMessage> => {
+  export const codec = (): Codec<NestedMessage, NestedMessageInput> => {
     if (_codec == null) {
-      _codec = message<NestedMessage>((obj, w, opts = {}) => {
+      _codec = message<NestedMessage, NestedMessageInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -262,7 +272,7 @@ export namespace NestedMessage {
     value: string
   }
 
-  export function encode (obj: Partial<NestedMessage>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: NestedMessageInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, NestedMessage.codec())
   }
 
@@ -280,12 +290,17 @@ export interface MessageWithNestedMessage {
   nestedMessage?: NestedMessage
 }
 
+export interface MessageWithNestedMessageInput {
+  field1?: boolean
+  nestedMessage?: NestedMessageInput
+}
+
 export namespace MessageWithNestedMessage {
-  let _codec: Codec<MessageWithNestedMessage>
+  let _codec: Codec<MessageWithNestedMessage, MessageWithNestedMessageInput>
 
-  export const codec = (): Codec<MessageWithNestedMessage> => {
+  export const codec = (): Codec<MessageWithNestedMessage, MessageWithNestedMessageInput> => {
     if (_codec == null) {
-      _codec = message<MessageWithNestedMessage>((obj, w, opts = {}) => {
+      _codec = message<MessageWithNestedMessage, MessageWithNestedMessageInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -401,7 +416,7 @@ export namespace MessageWithNestedMessage {
     value: string
   }
 
-  export function encode (obj: Partial<MessageWithNestedMessage>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: MessageWithNestedMessageInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, MessageWithNestedMessage.codec())
   }
 
@@ -419,12 +434,17 @@ export interface MessageWithDeeplyNestedMessage {
   nestedMessage?: MessageWithNestedMessage
 }
 
+export interface MessageWithDeeplyNestedMessageInput {
+  field1?: boolean
+  nestedMessage?: MessageWithNestedMessageInput
+}
+
 export namespace MessageWithDeeplyNestedMessage {
-  let _codec: Codec<MessageWithDeeplyNestedMessage>
+  let _codec: Codec<MessageWithDeeplyNestedMessage, MessageWithDeeplyNestedMessageInput>
 
-  export const codec = (): Codec<MessageWithDeeplyNestedMessage> => {
+  export const codec = (): Codec<MessageWithDeeplyNestedMessage, MessageWithDeeplyNestedMessageInput> => {
     if (_codec == null) {
-      _codec = message<MessageWithDeeplyNestedMessage>((obj, w, opts = {}) => {
+      _codec = message<MessageWithDeeplyNestedMessage, MessageWithDeeplyNestedMessageInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -555,7 +575,7 @@ export namespace MessageWithDeeplyNestedMessage {
     value: string
   }
 
-  export function encode (obj: Partial<MessageWithDeeplyNestedMessage>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: MessageWithDeeplyNestedMessageInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, MessageWithDeeplyNestedMessage.codec())
   }
 
@@ -573,12 +593,17 @@ export interface MessageWithRepeatedMessage {
   nestedMessages: NestedMessage[]
 }
 
+export interface MessageWithRepeatedMessageInput {
+  field1?: boolean
+  nestedMessages?: NestedMessageInput[]
+}
+
 export namespace MessageWithRepeatedMessage {
-  let _codec: Codec<MessageWithRepeatedMessage>
+  let _codec: Codec<MessageWithRepeatedMessage, MessageWithRepeatedMessageInput>
 
-  export const codec = (): Codec<MessageWithRepeatedMessage> => {
+  export const codec = (): Codec<MessageWithRepeatedMessage, MessageWithRepeatedMessageInput> => {
     if (_codec == null) {
-      _codec = message<MessageWithRepeatedMessage>((obj, w, opts = {}) => {
+      _codec = message<MessageWithRepeatedMessage, MessageWithRepeatedMessageInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -721,7 +746,7 @@ export namespace MessageWithRepeatedMessage {
     message: string
   }
 
-  export function encode (obj: Partial<MessageWithRepeatedMessage>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: MessageWithRepeatedMessageInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, MessageWithRepeatedMessage.codec())
   }
 
@@ -739,18 +764,28 @@ export interface MessageWithMapMessage {
   nestedMessages: Map<string, NestedMessage>
 }
 
+export interface MessageWithMapMessageInput {
+  field1?: boolean
+  nestedMessages?: Map<string, NestedMessageInput>
+}
+
 export namespace MessageWithMapMessage {
   export interface MessageWithMapMessage$nestedMessagesEntry {
     key: string
     value?: NestedMessage
   }
 
+  export interface MessageWithMapMessage$nestedMessagesEntryInput {
+    key?: string
+    value?: NestedMessageInput
+  }
+
   export namespace MessageWithMapMessage$nestedMessagesEntry {
-    let _codec: Codec<MessageWithMapMessage$nestedMessagesEntry>
+    let _codec: Codec<MessageWithMapMessage$nestedMessagesEntry, MessageWithMapMessage$nestedMessagesEntryInput>
 
-    export const codec = (): Codec<MessageWithMapMessage$nestedMessagesEntry> => {
+    export const codec = (): Codec<MessageWithMapMessage$nestedMessagesEntry, MessageWithMapMessage$nestedMessagesEntryInput> => {
       if (_codec == null) {
-        _codec = message<MessageWithMapMessage$nestedMessagesEntry>((obj, w, opts = {}) => {
+        _codec = message<MessageWithMapMessage$nestedMessagesEntry, MessageWithMapMessage$nestedMessagesEntryInput>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
             w.fork()
           }
@@ -866,7 +901,7 @@ export namespace MessageWithMapMessage {
       value: string
     }
 
-    export function encode (obj: Partial<MessageWithMapMessage$nestedMessagesEntry>): Uint8Array<ArrayBuffer> {
+    export function encode (obj: MessageWithMapMessage$nestedMessagesEntryInput): Uint8Array<ArrayBuffer> {
       return encodeMessage(obj, MessageWithMapMessage$nestedMessagesEntry.codec())
     }
 
@@ -879,11 +914,11 @@ export namespace MessageWithMapMessage {
     }
   }
 
-  let _codec: Codec<MessageWithMapMessage>
+  let _codec: Codec<MessageWithMapMessage, MessageWithMapMessageInput>
 
-  export const codec = (): Codec<MessageWithMapMessage> => {
+  export const codec = (): Codec<MessageWithMapMessage, MessageWithMapMessageInput> => {
     if (_codec == null) {
-      _codec = message<MessageWithMapMessage>((obj, w, opts = {}) => {
+      _codec = message<MessageWithMapMessage, MessageWithMapMessageInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -1026,7 +1061,7 @@ export namespace MessageWithMapMessage {
     message: string
   }
 
-  export function encode (obj: Partial<MessageWithMapMessage>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: MessageWithMapMessageInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, MessageWithMapMessage.codec())
   }
 
@@ -1044,18 +1079,28 @@ export interface MessageWithPrimitiveMap {
   nestedStrings: Map<string, string>
 }
 
+export interface MessageWithPrimitiveMapInput {
+  field1?: boolean
+  nestedStrings?: Map<string, string>
+}
+
 export namespace MessageWithPrimitiveMap {
   export interface MessageWithPrimitiveMap$nestedStringsEntry {
     key: string
     value: string
   }
 
+  export interface MessageWithPrimitiveMap$nestedStringsEntryInput {
+    key?: string
+    value?: string
+  }
+
   export namespace MessageWithPrimitiveMap$nestedStringsEntry {
-    let _codec: Codec<MessageWithPrimitiveMap$nestedStringsEntry>
+    let _codec: Codec<MessageWithPrimitiveMap$nestedStringsEntry, MessageWithPrimitiveMap$nestedStringsEntryInput>
 
-    export const codec = (): Codec<MessageWithPrimitiveMap$nestedStringsEntry> => {
+    export const codec = (): Codec<MessageWithPrimitiveMap$nestedStringsEntry, MessageWithPrimitiveMap$nestedStringsEntryInput> => {
       if (_codec == null) {
-        _codec = message<MessageWithPrimitiveMap$nestedStringsEntry>((obj, w, opts = {}) => {
+        _codec = message<MessageWithPrimitiveMap$nestedStringsEntry, MessageWithPrimitiveMap$nestedStringsEntryInput>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
             w.fork()
           }
@@ -1160,7 +1205,7 @@ export namespace MessageWithPrimitiveMap {
       value: string
     }
 
-    export function encode (obj: Partial<MessageWithPrimitiveMap$nestedStringsEntry>): Uint8Array<ArrayBuffer> {
+    export function encode (obj: MessageWithPrimitiveMap$nestedStringsEntryInput): Uint8Array<ArrayBuffer> {
       return encodeMessage(obj, MessageWithPrimitiveMap$nestedStringsEntry.codec())
     }
 
@@ -1173,11 +1218,11 @@ export namespace MessageWithPrimitiveMap {
     }
   }
 
-  let _codec: Codec<MessageWithPrimitiveMap>
+  let _codec: Codec<MessageWithPrimitiveMap, MessageWithPrimitiveMapInput>
 
-  export const codec = (): Codec<MessageWithPrimitiveMap> => {
+  export const codec = (): Codec<MessageWithPrimitiveMap, MessageWithPrimitiveMapInput> => {
     if (_codec == null) {
-      _codec = message<MessageWithPrimitiveMap>((obj, w, opts = {}) => {
+      _codec = message<MessageWithPrimitiveMap, MessageWithPrimitiveMapInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -1306,7 +1351,7 @@ export namespace MessageWithPrimitiveMap {
     value: string
   }
 
-  export function encode (obj: Partial<MessageWithPrimitiveMap>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: MessageWithPrimitiveMapInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, MessageWithPrimitiveMap.codec())
   }
 
@@ -1332,7 +1377,7 @@ enum __ENUMValues {
 }
 
 export namespace ENUM {
-  export const codec = (): Codec<ENUM> => {
+  export const codec = (): Codec<ENUM, ENUM> => {
     return enumeration<ENUM>(__ENUMValues)
   }
 }
@@ -1342,12 +1387,17 @@ export interface MessageWithRepeatedEnums {
   enums: ENUM[]
 }
 
+export interface MessageWithRepeatedEnumsInput {
+  field1?: boolean
+  enums?: ENUM[]
+}
+
 export namespace MessageWithRepeatedEnums {
-  let _codec: Codec<MessageWithRepeatedEnums>
+  let _codec: Codec<MessageWithRepeatedEnums, MessageWithRepeatedEnumsInput>
 
-  export const codec = (): Codec<MessageWithRepeatedEnums> => {
+  export const codec = (): Codec<MessageWithRepeatedEnums, MessageWithRepeatedEnumsInput> => {
     if (_codec == null) {
-      _codec = message<MessageWithRepeatedEnums>((obj, w, opts = {}) => {
+      _codec = message<MessageWithRepeatedEnums, MessageWithRepeatedEnumsInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -1471,7 +1521,7 @@ export namespace MessageWithRepeatedEnums {
     value: ENUM
   }
 
-  export function encode (obj: Partial<MessageWithRepeatedEnums>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: MessageWithRepeatedEnumsInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, MessageWithRepeatedEnums.codec())
   }
 
diff --git a/packages/protons/test/fixtures/test.ts b/packages/protons/test/fixtures/test.ts
index 6f9be94..d726b53 100644
--- a/packages/protons/test/fixtures/test.ts
+++ b/packages/protons/test/fixtures/test.ts
@@ -13,7 +13,7 @@ enum __AnEnumValues {
 }
 
 export namespace AnEnum {
-  export const codec = (): Codec<AnEnum> => {
+  export const codec = (): Codec<AnEnum, AnEnum> => {
     return enumeration<AnEnum>(__AnEnumValues)
   }
 }
@@ -22,12 +22,16 @@ export interface SubMessage {
   foo: string
 }
 
+export interface SubMessageInput {
+  foo?: string
+}
+
 export namespace SubMessage {
-  let _codec: Codec<SubMessage>
+  let _codec: Codec<SubMessage, SubMessageInput>
 
-  export const codec = (): Codec<SubMessage> => {
+  export const codec = (): Codec<SubMessage, SubMessageInput> => {
     if (_codec == null) {
-      _codec = message<SubMessage>((obj, w, opts = {}) => {
+      _codec = message<SubMessage, SubMessageInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -110,7 +114,7 @@ export namespace SubMessage {
     value: string
   }
 
-  export function encode (obj: Partial<SubMessage>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: SubMessageInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, SubMessage.codec())
   }
 
@@ -144,12 +148,33 @@ export interface AllTheTypes {
   field18?: bigint
 }
 
+export interface AllTheTypesInput {
+  field1?: boolean
+  field2?: number
+  field3?: bigint
+  field4?: number
+  field5?: bigint
+  field6?: number
+  field7?: bigint
+  field8?: number
+  field9?: number
+  field10?: string
+  field11?: Uint8Array
+  field12?: AnEnum
+  field13?: SubMessageInput
+  field14?: string[]
+  field15?: number
+  field16?: bigint
+  field17?: number
+  field18?: bigint
+}
+
 export namespace AllTheTypes {
-  let _codec: Codec<AllTheTypes>
+  let _codec: Codec<AllTheTypes, AllTheTypesInput>
 
-  export const codec = (): Codec<AllTheTypes> => {
+  export const codec = (): Codec<AllTheTypes, AllTheTypesInput> => {
     if (_codec == null) {
-      _codec = message<AllTheTypes>((obj, w, opts = {}) => {
+      _codec = message<AllTheTypes, AllTheTypesInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -620,7 +645,7 @@ export namespace AllTheTypes {
     value: bigint
   }
 
-  export function encode (obj: Partial<AllTheTypes>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: AllTheTypesInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, AllTheTypes.codec())
   }