diff --git a/hack/packetgen/protocol.yaml b/hack/packetgen/protocol.yaml
index 63d13816644a9d74d4b90c81b37c9ea1552d7faf..85ccc00cec583acfbe6cc213fed2bb7f0560d142 100644
--- a/hack/packetgen/protocol.yaml
+++ b/hack/packetgen/protocol.yaml
@@ -1,12 +1,53 @@
 Packets:
-  StartupMessage:
+  Startup:
     Struct:
       Name: Payload
       Fields:
-        - Name: MajorVersion
-          Basic: uint16
-        - Name: MinorVersion
-          Basic: uint16
+        - Name: Mode
+          Map:
+            Name: Mode
+            Prefix:
+              Basic: int16
+            Items:
+              Version3:
+                Type: 3
+                Struct:
+                  Name: Payload
+                  Fields:
+                    - Name: MinorVersion
+                      Basic: int16
+                    - Name: Parameters
+                      ZeroTerminatedSlice:
+                        Name: Parameter
+                        Fields:
+                          - Name: Key
+                            Basic: string
+                          - Name: Value
+                            Basic: string
+              Control:
+                Type: 1234
+                Struct:
+                  Name: Payload
+                  Fields:
+                    - Name: Mode
+                      Map:
+                        Name: Mode
+                        Prefix:
+                          Basic: int16
+                        Items:
+                          Cancel:
+                            Type: 5678
+                            Struct:
+                              Name: Key
+                              Fields:
+                                - Name: ProcessID
+                                  Basic: int32
+                                - Name: SecretKey
+                                  Basic: int32
+                          SSL:
+                            Type: 5679
+                          GSSAPI:
+                            Type: 5680
   Authentication:
     Type: 'R'
     Struct:
@@ -40,7 +81,10 @@ Packets:
               SASL:
                 Type: 10
                 ZeroTerminatedSlice:
-                  Basic: string
+                  Name: Method
+                  Fields:
+                    - Name: Method
+                      Basic: string
               SASLContinue:
                 Type: 11
                 Remaining:
@@ -191,10 +235,11 @@ Packets:
     Type: 'I'
   ErrorResponse:
     Type: 'E'
-    ZeroByteTerminatedSlice:
+    ZeroTerminatedSlice:
       Name: Field
-      KeyName: Code
       Fields:
+        - Name: Code
+          Basic: uint8
         - Name: Value
           Basic: string
   Execute:
@@ -252,10 +297,11 @@ Packets:
     Type: 'n'
   NoticeResponse:
     Type: 'N'
-    ZeroByteTerminatedSlice:
+    ZeroTerminatedSlice:
       Name: Field
-      KeyName: Code
       Fields:
+        - Name: Code
+          Basic: uint8
         - Name: Value
           Basic: string
   NotificationResponse:
diff --git a/hack/packetgen/templates/decode.tmpl b/hack/packetgen/templates/decode.tmpl
index 2a0b2cd336208abe1164aecb0579ade1702d24b6..90b1e9292d02681d0c7ff0d0599633d537608029 100644
--- a/hack/packetgen/templates/decode.tmpl
+++ b/hack/packetgen/templates/decode.tmpl
@@ -16,6 +16,9 @@
 		case {{$item.Type}}:
 			{{$pointer}} = new({{$itemName}})
 	{{end -}}
+		default:
+			err = ErrInvalidFormat
+			return
 	}
 
 	err = {{$pointer}}.ReadFrom(decoder)
@@ -93,46 +96,27 @@
 		}
 	}
 
-{{else if some $value.ZeroByteTerminatedSlice -}}
-    {{$structName := printf "%s%s" $name $value.ZeroByteTerminatedSlice.Name -}}
+{{else if some $value.ZeroTerminatedSlice -}}
+    {{$structName := printf "%s%s" $name $value.ZeroTerminatedSlice.Name -}}
 
-    {{$pointer}} = {{$pointer}}[:0]
+	{{$pointer}} = {{$pointer}}[:0]
 
 	for {
-	    {{$pointer}} = slices.Resize({{$pointer}}, len({{$pointer}})+1)
+		{{$pointer}} = slices.Resize({{$pointer}}, len({{$pointer}})+1)
 
 		{{$targetPointer := printf "%s[len(%s)-1]" $pointer $pointer -}}
 
-		{{$keyPointer := printf "%s.%s" $targetPointer $value.ZeroByteTerminatedSlice.KeyName -}}
-
-		{{$keyPointer}}, err = decoder.Uint8()
-		if err != nil {
-			return
-		}
-		if {{$keyPointer}} == 0 {
-			{{$pointer}} = {{$pointer}}[:len({{$pointer}})-1]
-			break
-		}
-
-		{{range $field := $value.ZeroByteTerminatedSlice.Fields -}}
+		{{range $i, $field := $value.ZeroTerminatedSlice.Fields -}}
 			{{$fieldPointer := printf "%s.%s" $targetPointer $field.Name -}}
 
 			{{template "decode" (list $structName $fieldPointer $field) -}}
-		{{end -}}
-	}
-{{else if some $value.ZeroTerminatedSlice -}}
-	{{$pointer}} = {{$pointer}}[:0]
-
-	for {
-		{{$pointer}} = slices.Resize({{$pointer}}, len({{$pointer}})+1)
 
-		{{$targetPointer := printf "%s[len(%s)-1]" $pointer $pointer -}}
-
-		{{template "decode" (list $name $targetPointer $value.ZeroTerminatedSlice)}}
-
-		if {{$targetPointer}} == *new({{template "type" (list $name $value.ZeroTerminatedSlice)}}) {
-    		{{$pointer}} = {{$pointer}}[:len({{$pointer}})-1]
-			break
-		}
+			{{if eq $i 0 -}}
+				if {{$fieldPointer}} == *new({{template "type" (list $structName $field)}}) {
+                	{{$pointer}} = {{$pointer}}[:len({{$pointer}})-1]
+					break
+				}
+			{{end -}}
+		{{end -}}
 	}
 {{end -}}
diff --git a/hack/packetgen/templates/encode.tmpl b/hack/packetgen/templates/encode.tmpl
index e49e2e2facf9519116019b4041c844ad4d0696c7..9d6532f2583e5cf2a0267a9561156b2d4265bffc 100644
--- a/hack/packetgen/templates/encode.tmpl
+++ b/hack/packetgen/templates/encode.tmpl
@@ -66,40 +66,22 @@
 	for _, {{$itemPointer}} := range {{$pointer}} {
     	{{template "encode" (list $name $itemPointer $value.NullableLengthPrefixedSlice)}}
 	}
-{{else if some $value.ZeroByteTerminatedSlice -}}
-    {{$structName := printf "%s%s" $name $value.ZeroByteTerminatedSlice.Name -}}
+{{else if some $value.ZeroTerminatedSlice -}}
+    {{$structName := printf "%s%s" $name $value.ZeroTerminatedSlice.Name -}}
 
-    {{$itemPointer := temp -}}
+	{{$itemPointer := temp -}}
 
 	for _, {{$itemPointer}} := range {{$pointer}} {
-		{{$keyPointer := printf "%s.%s" $itemPointer $value.ZeroByteTerminatedSlice.KeyName -}}
-
-		err = encoder.Uint8({{$keyPointer}})
-		if err != nil {
-			return
-		}
-
-		{{range $field := $value.ZeroByteTerminatedSlice.Fields -}}
+		{{range $field := $value.ZeroTerminatedSlice.Fields -}}
 			{{$fieldPointer := printf "%s.%s" $itemPointer $field.Name -}}
 
 			{{template "encode" (list $structName $fieldPointer $field)}}
 		{{end -}}
 	}
 
-	err = encoder.Uint8(0)
-	if err != nil {
-		return
-	}
-{{else if some $value.ZeroTerminatedSlice -}}
-	{{$itemPointer := temp -}}
-
-	for _, {{$itemPointer}} := range {{$pointer}} {
-    	{{template "encode" (list $name $itemPointer $value.ZeroTerminatedSlice)}}
-	}
-
 	{{$donePointer := temp -}}
 
-	var {{$donePointer}} {{template "type" (list $name $value.ZeroTerminatedSlice)}}
+	var {{$donePointer}} {{template "type" (list $structName (index $value.ZeroTerminatedSlice.Fields 0))}}
 
-	{{template "encode" (list $name $donePointer $value.ZeroTerminatedSlice)}}
+	{{template "encode" (list $structName $donePointer (index $value.ZeroTerminatedSlice.Fields 0))}}
 {{end -}}
diff --git a/hack/packetgen/templates/length.tmpl b/hack/packetgen/templates/length.tmpl
index 28dfc0a814c4ffc84d3e9dae91609bf61c94207f..49bdf45401d17f50f4d731cd102a1f546c9151f0 100644
--- a/hack/packetgen/templates/length.tmpl
+++ b/hack/packetgen/templates/length.tmpl
@@ -11,11 +11,45 @@
 
 	length += {{$pointer}}.Length()
 {{else if some $value.Remaining -}}
+    {{$itemPointer := temp -}}
 
-{{else if some $value.Basic -}}
+    for _, {{$itemPointer}} := range {{$pointer}} {
+        _ = {{$itemPointer}}
 
+        {{template "length" (list $name $itemPointer $value.Remaining)}}
+    }
+{{else if some $value.Basic -}}
+    {{if eq $value.Basic "uint8" -}}
+        length += 1
+    {{else if eq $value.Basic "uint16" -}}
+        length += 2
+    {{else if eq $value.Basic "uint32" -}}
+        length += 4
+    {{else if eq $value.Basic "uint64" -}}
+        length += 8
+    {{else if eq $value.Basic "int8" -}}
+        length += 1
+    {{else if eq $value.Basic "int16" -}}
+        length += 2
+    {{else if eq $value.Basic "int32" -}}
+        length += 4
+    {{else if eq $value.Basic "int64" -}}
+        length += 8
+    {{else if eq $value.Basic "float32" -}}
+        length += 4
+    {{else if eq $value.Basic "float64" -}}
+        length += 8
+    {{else if eq $value.Basic "string" -}}
+        length += len({{$pointer}}) + 1
+    {{end -}}
 {{else if some $value.Array -}}
+    {{$itemPointer := temp -}}
 
+    for _, {{$itemPointer}} := range {{$pointer}} {
+        _ = {{$itemPointer}}
+
+        {{template "length" (list $name $itemPointer $value.Array)}}
+    }
 {{else if some $value.Struct -}}
     {{$structName := printf "%s%s" $name $value.Struct.Name -}}
 
@@ -25,11 +59,54 @@
         {{template "length" (list $structName $fieldPointer $field)}}
     {{end -}}
 {{else if some $value.LengthPrefixedSlice -}}
+    {{$lengthPointer := temp -}}
+
+    {{$lengthPointer}} := {{template "type" (list $name $value.LengthPrefixedSlice.Prefix)}}(len({{$pointer}}))
+    _ = {{$lengthPointer}}
 
+    {{template "length" (list $name $lengthPointer $value.LengthPrefixedSlice.Prefix)}}
+
+    {{$itemPointer := temp -}}
+
+    for _, {{$itemPointer}} := range {{$pointer}} {
+        _ = {{$itemPointer}}
+
+        {{template "length" (list $name $itemPointer $value.LengthPrefixedSlice)}}
+    }
 {{else if some $value.NullableLengthPrefixedSlice -}}
+    {{$lengthPointer := temp -}}
+
+    {{$lengthPointer}} := {{template "type" (list $name $value.NullableLengthPrefixedSlice.Prefix)}}(len({{$pointer}}))
+    _ = {{$lengthPointer}}
 
-{{else if some $value.ZeroByteTerminatedSlice -}}
+    {{template "length" (list $name $lengthPointer $value.NullableLengthPrefixedSlice.Prefix)}}
 
+    {{$itemPointer := temp -}}
+
+    for _, {{$itemPointer}} := range {{$pointer}} {
+        _ = {{$itemPointer}}
+
+        {{template "length" (list $name $itemPointer $value.NullableLengthPrefixedSlice)}}
+    }
 {{else if some $value.ZeroTerminatedSlice -}}
+    {{$structName := printf "%s%s" $name $value.ZeroTerminatedSlice.Name -}}
+
+    {{$itemPointer := temp -}}
+
+    for _, {{$itemPointer}} := range {{$pointer}} {
+        _ = {{$itemPointer}}
+
+        {{range $field := $value.ZeroTerminatedSlice.Fields -}}
+            {{$fieldPointer := printf "%s.%s" $itemPointer $field.Name -}}
+
+            {{template "length" (list $structName $fieldPointer $field)}}
+        {{end -}}
+    }
+
+    {{$donePointer := temp -}}
+
+    var {{$donePointer}} {{template "type" (list $structName (index $value.ZeroTerminatedSlice.Fields 0))}}
+    _ = {{$donePointer}}
 
+    {{template "length" (list $name $donePointer (index $value.ZeroTerminatedSlice.Fields 0))}}
 {{end -}}
diff --git a/hack/packetgen/templates/packets.tmpl b/hack/packetgen/templates/packets.tmpl
index 3d7a962dbb68a0e0bd9699688231185f54a81737..3b095d6fdd37cd543c6f5223f23462b43c8a9d88 100644
--- a/hack/packetgen/templates/packets.tmpl
+++ b/hack/packetgen/templates/packets.tmpl
@@ -9,12 +9,13 @@ import (
 
 var (
 	ErrUnexpectedPacket = errors.New("unexpected packet")
+	ErrInvalidFormat = errors.New("invalid packet format")
 )
 
 const (
 	{{range $name, $packet := .Packets -}}
 		{{if some $packet.Type -}}
-			{{$name}}Type = '{{$packet.Type}}'
+			Type{{$name}} = '{{$packet.Type}}'
 		{{end -}}
 	{{end -}}
 )
@@ -24,6 +25,14 @@ const (
 
 	type {{$name}} {{template "type" (list $name $packet)}}
 
+	func (T *{{$name}}) Type() fed.Type {
+		{{if some $packet.Type -}}
+			return Type{{$name}}
+		{{else -}}
+			return 0
+		{{end -}}
+	}
+
 	func (T *{{$name}}) Length() (length int) {
 		{{template "length" (list $name "(*T)" $packet)}}
 
@@ -31,15 +40,9 @@ const (
 	}
 
 	func (T *{{$name}}) ReadFrom(decoder *fed.Decoder) (err error) {
-		{{if some $packet.Type -}}
-			if decoder.Type() != {{$name}}Type {
-				return ErrUnexpectedPacket
-			}
-		{{else -}}
-			if decoder.Type() != 0 {
-				return ErrUnexpectedPacket
-			}
-		{{end -}}
+		if decoder.Type() != T.Type() {
+			return ErrUnexpectedPacket
+		}
 
 		{{template "decode" (list $name "(*T)" $packet)}}
 
@@ -52,4 +55,6 @@ const (
 		return
 	}
 
+	var _ fed.Packet = (*{{$name}})(nil)
+
 {{end}}
diff --git a/hack/packetgen/templates/preType.tmpl b/hack/packetgen/templates/preType.tmpl
index 8d50f4c6fa325aaaa2c02ce80fcbe5306ab872d2..5bd8ba06118c6d4c0079f1621b593b849e859464 100644
--- a/hack/packetgen/templates/preType.tmpl
+++ b/hack/packetgen/templates/preType.tmpl
@@ -59,18 +59,16 @@
 	{{template "preType" (list $name $value.LengthPrefixedSlice) -}}
 {{else if some $value.NullableLengthPrefixedSlice -}}
     {{template "preType" (list $name $value.NullableLengthPrefixedSlice) -}}
-{{else if some $value.ZeroByteTerminatedSlice -}}
-	{{$structName := printf "%s%s" $name $value.ZeroByteTerminatedSlice.Name -}}
+{{else if some $value.ZeroTerminatedSlice -}}
+	{{$structName := printf "%s%s" $name $value.ZeroTerminatedSlice.Name -}}
 
-	{{range $field := $value.ZeroByteTerminatedSlice.Fields -}}
+	{{range $field := $value.ZeroTerminatedSlice.Fields -}}
 		{{template "preType" (list $structName $field) -}}
 	{{end -}}
 
 	type {{$structName}} struct{
-		{{$value.ZeroByteTerminatedSlice.KeyName}} byte
-
-		{{range $field := $value.ZeroByteTerminatedSlice.Fields -}}
-			{{$field.Name}} {{template "type" (list $structName $field) -}}
+		{{range $field := $value.ZeroTerminatedSlice.Fields -}}
+			{{$field.Name}} {{template "type" (list $structName $field)}}
 		{{end -}}
 	}
 
diff --git a/hack/packetgen/templates/type.tmpl b/hack/packetgen/templates/type.tmpl
index 99cf1163d0a3d7174621a26f6b475cc303507bbf..22f154a085e5cbf67941e419f72fc495ecea1d5d 100644
--- a/hack/packetgen/templates/type.tmpl
+++ b/hack/packetgen/templates/type.tmpl
@@ -15,10 +15,8 @@
 	[]{{template "type" (list $name $value.LengthPrefixedSlice)}}
 {{- else if some $value.NullableLengthPrefixedSlice -}}
 	[]{{template "type" (list $name $value.NullableLengthPrefixedSlice)}}
-{{- else if some $value.ZeroByteTerminatedSlice -}}
-	[]{{printf "%s%s" $name $value.ZeroByteTerminatedSlice.Name}}
 {{- else if some $value.ZeroTerminatedSlice -}}
-	[]{{template "type" (list $name $value.ZeroTerminatedSlice)}}
+	[]{{printf "%s%s" $name $value.ZeroTerminatedSlice.Name}}
 {{- else -}}
 	struct{}
 {{- end -}}
\ No newline at end of file
diff --git a/lib/bouncer/backends/v0/context.go b/lib/bouncer/backends/v0/context.go
index 01945b65e47630a4bdfa299abf446d1bbdc7f05c..4f4d73b30608359668d502c2a8f83fa832cb6c2a 100644
--- a/lib/bouncer/backends/v0/context.go
+++ b/lib/bouncer/backends/v0/context.go
@@ -20,7 +20,7 @@ type context struct {
 
 func (T *context) ServerRead() error {
 	var err error
-	T.Packet, err = T.Server.ReadPacket(true, T.Packet)
+	T.Packet, err = T.Server.ReadPacket(true)
 	return err
 }
 
@@ -51,7 +51,7 @@ func (T *context) PeerRead() bool {
 		return false
 	}
 	var err error
-	T.Packet, err = T.Peer.ReadPacket(true, T.Packet)
+	T.Packet, err = T.Peer.ReadPacket(true)
 	if err != nil {
 		T.PeerFail(err)
 		return false
diff --git a/lib/bouncer/backends/v0/query.go b/lib/bouncer/backends/v0/query.go
index 89a8bd3f82d758a7f924f14d7944e0285e4376ef..eda26189a3a9a9dbcb28c69223e61b8d0453e7e0 100644
--- a/lib/bouncer/backends/v0/query.go
+++ b/lib/bouncer/backends/v0/query.go
@@ -13,10 +13,8 @@ func copyIn(ctx *context) error {
 
 	for {
 		if !ctx.PeerRead() {
-			copyFail := packets.CopyFail{
-				Reason: "peer failed",
-			}
-			ctx.Packet = copyFail.IntoPacket(ctx.Packet)
+			copyFail := packets.CopyFail("peer failed")
+			ctx.Packet = &copyFail
 			return ctx.ServerWrite()
 		}
 
@@ -87,11 +85,13 @@ func query(ctx *context) error {
 				return err
 			}
 		case packets.TypeReadyForQuery:
-			var txState packets.ReadyForQuery
-			if !txState.ReadFromPacket(ctx.Packet) {
-				return ErrBadFormat
+			var p *packets.ReadyForQuery
+			p, err = fed.ToConcrete[*packets.ReadyForQuery](ctx.Packet)
+			if err != nil {
+				return err
 			}
-			ctx.TxState = byte(txState)
+			ctx.Packet = p
+			ctx.TxState = byte(*p)
 			ctx.PeerWrite()
 			return nil
 		default:
@@ -102,27 +102,24 @@ func query(ctx *context) error {
 
 func queryString(ctx *context, q string) error {
 	qq := packets.Query(q)
-	ctx.Packet = qq.IntoPacket(ctx.Packet)
+	ctx.Packet = &qq
 	return query(ctx)
 }
 
-func QueryString(server, peer *fed.Conn, buffer fed.Packet, query string) (err, peerError error, packet fed.Packet) {
+func QueryString(server, peer *fed.Conn, query string) (err, peerError error) {
 	ctx := context{
 		Server: server,
 		Peer:   peer,
-		Packet: buffer,
 	}
 	err = queryString(&ctx, query)
 	peerError = ctx.PeerError
-	packet = ctx.Packet
 	return
 }
 
-func SetParameter(server, peer *fed.Conn, buffer fed.Packet, name strutil.CIString, value string) (err, peerError error, packet fed.Packet) {
+func SetParameter(server, peer *fed.Conn, name strutil.CIString, value string) (err, peerError error) {
 	return QueryString(
 		server,
 		peer,
-		buffer,
 		fmt.Sprintf(`SET "%s" = '%s'`, strutil.Escape(name.String(), '"'), strutil.Escape(value, '\'')),
 	)
 }
@@ -146,11 +143,13 @@ func functionCall(ctx *context) error {
 			packets.TypeNotificationResponse:
 			ctx.PeerWrite()
 		case packets.TypeReadyForQuery:
-			var txState packets.ReadyForQuery
-			if !txState.ReadFromPacket(ctx.Packet) {
-				return ErrBadFormat
+			var p *packets.ReadyForQuery
+			p, err = fed.ToConcrete[*packets.ReadyForQuery](ctx.Packet)
+			if err != nil {
+				return err
 			}
-			ctx.TxState = byte(txState)
+			ctx.Packet = p
+			ctx.TxState = byte(*p)
 			ctx.PeerWrite()
 			return nil
 		default:
@@ -160,7 +159,6 @@ func functionCall(ctx *context) error {
 }
 
 func sync(ctx *context) (bool, error) {
-	ctx.Packet = ctx.Packet.Reset(packets.TypeSync)
 	if err := ctx.ServerWrite(); err != nil {
 		return false, err
 	}
@@ -200,11 +198,13 @@ func sync(ctx *context) (bool, error) {
 				return false, err
 			}
 		case packets.TypeReadyForQuery:
-			var txState packets.ReadyForQuery
-			if !txState.ReadFromPacket(ctx.Packet) {
-				return false, ErrBadFormat
+			var p *packets.ReadyForQuery
+			p, err = fed.ToConcrete[*packets.ReadyForQuery](ctx.Packet)
+			if err != nil {
+				return false, err
 			}
-			ctx.TxState = byte(txState)
+			ctx.Packet = p
+			ctx.TxState = byte(*p)
 			ctx.PeerWrite()
 			return true, nil
 		default:
@@ -213,15 +213,14 @@ func sync(ctx *context) (bool, error) {
 	}
 }
 
-func Sync(server, peer *fed.Conn, buffer fed.Packet) (err, peerErr error, packet fed.Packet) {
+func Sync(server, peer *fed.Conn) (err, peerErr error) {
 	ctx := context{
 		Server: server,
 		Peer:   peer,
-		Packet: buffer,
+		Packet: &packets.Sync{},
 	}
 	_, err = sync(&ctx)
 	peerErr = ctx.PeerError
-	packet = ctx.Packet
 	return
 }
 
@@ -233,6 +232,7 @@ func eqp(ctx *context) error {
 	for {
 		if !ctx.PeerRead() {
 			for {
+				ctx.Packet = &packets.Sync{}
 				ok, err := sync(ctx)
 				if err != nil {
 					return err
@@ -276,7 +276,7 @@ func transaction(ctx *context) error {
 		case packets.TypeSync:
 			// phony sync call, we can just reply with a fake ReadyForQuery(TxState)
 			rfq := packets.ReadyForQuery(ctx.TxState)
-			ctx.Packet = rfq.IntoPacket(ctx.Packet)
+			ctx.Packet = &rfq
 			ctx.PeerWrite()
 		case packets.TypeParse, packets.TypeBind, packets.TypeClose, packets.TypeDescribe, packets.TypeExecute, packets.TypeFlush:
 			if err := eqp(ctx); err != nil {
@@ -305,7 +305,7 @@ func transaction(ctx *context) error {
 	}
 }
 
-func Transaction(server, peer *fed.Conn, initialPacket fed.Packet) (err, peerError error, packet fed.Packet) {
+func Transaction(server, peer *fed.Conn, initialPacket fed.Packet) (err, peerError error) {
 	ctx := context{
 		Server: server,
 		Peer:   peer,
@@ -313,6 +313,5 @@ func Transaction(server, peer *fed.Conn, initialPacket fed.Packet) (err, peerErr
 	}
 	err = transaction(&ctx)
 	peerError = ctx.PeerError
-	packet = ctx.Packet
 	return
 }
diff --git a/lib/bouncer/bouncers/v2/bouncer.go b/lib/bouncer/bouncers/v2/bouncer.go
index 573b8cc28a3ac92de6dcf1c5a03cfa5ace827877..946c66b29e11f4739a51a662743d28f37a1c1228 100644
--- a/lib/bouncer/bouncers/v2/bouncer.go
+++ b/lib/bouncer/bouncers/v2/bouncer.go
@@ -3,27 +3,22 @@ package bouncers
 import (
 	"gfx.cafe/gfx/pggat/lib/bouncer/backends/v0"
 	"gfx.cafe/gfx/pggat/lib/fed"
-	packets "gfx.cafe/gfx/pggat/lib/fed/packets/v3.0"
 	"gfx.cafe/gfx/pggat/lib/perror"
 )
 
-func clientFail(packet fed.Packet, client *fed.Conn, err perror.Error) fed.Packet {
+func clientFail(client *fed.Conn, err perror.Error) {
 	// send fatal error to client
-	resp := packets.ErrorResponse{
-		Error: err,
-	}
-	packet = resp.IntoPacket(packet)
-	_ = client.WritePacket(packet)
-	return packet
+	resp := perror.ToPacket(err)
+	_ = client.WritePacket(resp)
 }
 
-func Bounce(client, server *fed.Conn, initialPacket fed.Packet) (packet fed.Packet, clientError error, serverError error) {
-	serverError, clientError, packet = backends.Transaction(server, client, initialPacket)
+func Bounce(client, server *fed.Conn, initialPacket fed.Packet) (clientError error, serverError error) {
+	serverError, clientError = backends.Transaction(server, client, initialPacket)
 
 	if clientError != nil {
-		packet = clientFail(packet, client, perror.Wrap(clientError))
+		clientFail(client, perror.Wrap(clientError))
 	} else if serverError != nil {
-		packet = clientFail(packet, client, perror.Wrap(serverError))
+		clientFail(client, perror.Wrap(serverError))
 	}
 
 	return
diff --git a/lib/fed/conn.go b/lib/fed/conn.go
index c0b8e990d29292906f42356c127a0b1e7cce87db..e8534bfed14c3aa1b3246064d4fb8a4b26e7ca39 100644
--- a/lib/fed/conn.go
+++ b/lib/fed/conn.go
@@ -1,6 +1,8 @@
 package fed
 
 import (
+	"io"
+
 	"gfx.cafe/gfx/pggat/lib/util/decorator"
 	"gfx.cafe/gfx/pggat/lib/util/strutil"
 )
@@ -8,7 +10,9 @@ import (
 type Conn struct {
 	noCopy decorator.NoCopy
 
-	ReadWriteCloser
+	ReadWriter io.ReadWriteCloser
+	Encoder    Encoder
+	Decoder    Decoder
 
 	Middleware []Middleware
 
@@ -19,43 +23,75 @@ type Conn struct {
 	BackendKey        [8]byte
 }
 
-func NewConn(rw ReadWriteCloser) *Conn {
-	return &Conn{
-		ReadWriteCloser: rw,
+func NewConn(rw io.ReadWriteCloser) *Conn {
+	c := &Conn{
+		ReadWriter: rw,
 	}
+	c.Encoder.Writer.Reset(rw)
+	c.Decoder.Reader.Reset(rw)
+	return c
+}
+
+func (T *Conn) Flush() error {
+	return T.Encoder.Flush()
 }
 
-func (T *Conn) ReadPacket(typed bool, buffer Packet) (packet Packet, err error) {
-	packet = buffer
+func (T *Conn) ReadPacket(typed bool) (Packet, error) {
+	if err := T.Flush(); err != nil {
+		return nil, err
+	}
+
 	for {
-		packet, err = T.ReadWriteCloser.ReadPacket(typed, buffer)
-		if err != nil {
-			return
+		if err := T.Decoder.Next(typed); err != nil {
+			return nil, err
+		}
+		var packet Packet
+		packet = PendingPacket{
+			Decoder: &T.Decoder,
 		}
 		for _, middleware := range T.Middleware {
+			var err error
 			packet, err = middleware.ReadPacket(packet)
 			if err != nil {
-				return
+				return nil, err
 			}
-			if len(packet) == 0 {
+			if packet == nil {
 				break
 			}
 		}
-		if len(packet) != 0 {
-			return
+		if packet != nil {
+			return packet, nil
 		}
 	}
 }
 
-func (T *Conn) WritePacket(packet Packet) (err error) {
+func (T *Conn) WritePacket(packet Packet) error {
 	for _, middleware := range T.Middleware {
+		var err error
 		packet, err = middleware.WritePacket(packet)
-		if err != nil || len(packet) == 0 {
-			return
+		if err != nil {
+			return err
 		}
+		if packet == nil {
+			break
+		}
+	}
+	if packet == nil {
+		return nil
+	}
+
+	err := T.Encoder.Next(packet.Type(), packet.Length())
+	if err != nil {
+		return err
 	}
-	err = T.ReadWriteCloser.WritePacket(packet)
-	return
+
+	return packet.WriteTo(&T.Encoder)
 }
 
-var _ ReadWriteCloser = (*Conn)(nil)
+func (T *Conn) Close() error {
+	if err := T.Encoder.Flush(); err != nil {
+		return err
+	}
+
+	return T.ReadWriter.Close()
+}
diff --git a/lib/fed/encoder.go b/lib/fed/encoder.go
index c957265f21c49267562283fcb66c6f84434b394a..69145d92dedaa606a8d98869cdf32fe8828352e0 100644
--- a/lib/fed/encoder.go
+++ b/lib/fed/encoder.go
@@ -27,6 +27,10 @@ func NewEncoder(w io.Writer) *Encoder {
 	return e
 }
 
+func (T *Encoder) Flush() error {
+	return T.Writer.Flush()
+}
+
 func (T *Encoder) Next(typ Type, length int) error {
 	if typ != 0 {
 		if err := T.Writer.WriteByte(typ); err != nil {
diff --git a/lib/fed/middlewares/eqp/client.go b/lib/fed/middlewares/eqp/client.go
index 47417442094ac0b94e8304be45c5fb1af67a8cbd..aeaab9e81db6b8ff2815286c581ab4177de5d103 100644
--- a/lib/fed/middlewares/eqp/client.go
+++ b/lib/fed/middlewares/eqp/client.go
@@ -13,13 +13,11 @@ func NewClient() *Client {
 }
 
 func (T *Client) ReadPacket(packet fed.Packet) (fed.Packet, error) {
-	T.state.C2S(packet)
-	return packet, nil
+	return T.state.C2S(packet)
 }
 
 func (T *Client) WritePacket(packet fed.Packet) (fed.Packet, error) {
-	T.state.S2C(packet)
-	return packet, nil
+	return T.state.S2C(packet)
 }
 
 var _ fed.Middleware = (*Client)(nil)
diff --git a/lib/fed/middlewares/eqp/server.go b/lib/fed/middlewares/eqp/server.go
index f1b9e7889ac2b5bf3fae74e07edf4e4c73080bcc..9b070d971dde21c1292e36e2788d64cf02d4087c 100644
--- a/lib/fed/middlewares/eqp/server.go
+++ b/lib/fed/middlewares/eqp/server.go
@@ -13,13 +13,11 @@ func NewServer() *Server {
 }
 
 func (T *Server) ReadPacket(packet fed.Packet) (fed.Packet, error) {
-	T.state.S2C(packet)
-	return packet, nil
+	return T.state.S2C(packet)
 }
 
 func (T *Server) WritePacket(packet fed.Packet) (fed.Packet, error) {
-	T.state.C2S(packet)
-	return packet, nil
+	return T.state.C2S(packet)
 }
 
 var _ fed.Middleware = (*Server)(nil)
diff --git a/lib/fed/middlewares/eqp/state.go b/lib/fed/middlewares/eqp/state.go
index a8e7507c655cce83282dc4d8f44eb75b3c989d87..34aca2a8d592fdafa4e7afefc05e8321788f2f58 100644
--- a/lib/fed/middlewares/eqp/state.go
+++ b/lib/fed/middlewares/eqp/state.go
@@ -1,53 +1,12 @@
 package eqp
 
 import (
-	"bytes"
-	"hash/maphash"
-
 	"gfx.cafe/gfx/pggat/lib/fed"
 	packets "gfx.cafe/gfx/pggat/lib/fed/packets/v3.0"
 	"gfx.cafe/gfx/pggat/lib/util/maps"
 	"gfx.cafe/gfx/pggat/lib/util/ring"
 )
 
-var seed = maphash.MakeSeed()
-
-type PreparedStatement struct {
-	Packet fed.Packet
-	Target string
-	Hash   uint64
-}
-
-func MakePreparedStatement(packet fed.Packet) PreparedStatement {
-	if packet.Type() != packets.TypeParse {
-		panic("unreachable")
-	}
-
-	var res PreparedStatement
-	packet.ReadString(&res.Target)
-	res.Packet = bytes.Clone(packet)
-	res.Hash = maphash.Bytes(seed, packet.Payload())
-
-	return res
-}
-
-type Portal struct {
-	Packet fed.Packet
-	Target string
-}
-
-func MakePortal(packet fed.Packet) Portal {
-	if packet.Type() != packets.TypeBind {
-		panic("unreachable")
-	}
-
-	var res Portal
-	packet.ReadString(&res.Target)
-	res.Packet = bytes.Clone(packet)
-
-	return res
-}
-
 type CloseVariant int
 
 const (
@@ -61,65 +20,75 @@ type Close struct {
 }
 
 type State struct {
-	preparedStatements map[string]PreparedStatement
-	portals            map[string]Portal
+	preparedStatements map[string]*packets.Parse
+	portals            map[string]*packets.Bind
 
-	pendingPreparedStatements ring.Ring[PreparedStatement]
-	pendingPortals            ring.Ring[Portal]
+	pendingPreparedStatements ring.Ring[*packets.Parse]
+	pendingPortals            ring.Ring[*packets.Bind]
 	pendingCloses             ring.Ring[Close]
 }
 
 // C2S is client to server packets
-func (T *State) C2S(packet fed.Packet) {
+func (T *State) C2S(packet fed.Packet) (fed.Packet, error) {
 	switch packet.Type() {
 	case packets.TypeClose:
-		T.Close(packet)
+		return T.Close(packet)
 	case packets.TypeParse:
-		T.Parse(packet)
+		return T.Parse(packet)
 	case packets.TypeBind:
-		T.Bind(packet)
+		return T.Bind(packet)
 	case packets.TypeQuery:
 		T.Query()
+		return packet, nil
+	default:
+		return packet, nil
 	}
 }
 
 // S2C is server to client packets
-func (T *State) S2C(packet fed.Packet) {
+func (T *State) S2C(packet fed.Packet) (fed.Packet, error) {
 	switch packet.Type() {
 	case packets.TypeCloseComplete:
 		T.CloseComplete()
+		return packet, nil
 	case packets.TypeParseComplete:
 		T.ParseComplete()
+		return packet, nil
 	case packets.TypeBindComplete:
 		T.BindComplete()
+		return packet, nil
 	case packets.TypeCommandComplete:
-		T.CommandComplete(packet)
+		return T.CommandComplete(packet)
 	case packets.TypeReadyForQuery:
-		T.ReadyForQuery(packet)
+		return T.ReadyForQuery(packet)
+	default:
+		return packet, nil
 	}
 }
 
 // Close is a pending close. Execute on Close C->S
-func (T *State) Close(packet fed.Packet) {
-	var which byte
-	p := packet.ReadUint8(&which)
-	var target string
-	p.ReadString(&target)
+func (T *State) Close(packet fed.Packet) (fed.Packet, error) {
+	p, err := fed.ToConcrete[*packets.Close](packet)
+	if err != nil {
+		return nil, err
+	}
 
 	var variant CloseVariant
-	switch which {
+	switch p.Which {
 	case 'S':
 		variant = CloseVariantPreparedStatement
 	case 'P':
 		variant = CloseVariantPortal
 	default:
-		return
+		return nil, packets.ErrInvalidFormat
 	}
 
 	T.pendingCloses.PushBack(Close{
 		Variant: variant,
-		Target:  target,
+		Target:  p.Name,
 	})
+
+	return p, nil
 }
 
 // CloseComplete notifies that a close was successful. Execute on CloseComplete S->C
@@ -140,9 +109,13 @@ func (T *State) CloseComplete() {
 }
 
 // Parse is a pending prepared statement. Execute on Parse C->S
-func (T *State) Parse(packet fed.Packet) {
-	preparedStatement := MakePreparedStatement(packet)
-	T.pendingPreparedStatements.PushBack(preparedStatement)
+func (T *State) Parse(packet fed.Packet) (fed.Packet, error) {
+	p, err := fed.ToConcrete[*packets.Parse](packet)
+	if err != nil {
+		return nil, err
+	}
+	T.pendingPreparedStatements.PushBack(p)
+	return p, nil
 }
 
 // ParseComplete notifies that a parse was successful. Execute on ParseComplete S->C
@@ -153,15 +126,19 @@ func (T *State) ParseComplete() {
 	}
 
 	if T.preparedStatements == nil {
-		T.preparedStatements = make(map[string]PreparedStatement)
+		T.preparedStatements = make(map[string]*packets.Parse)
 	}
-	T.preparedStatements[preparedStatement.Target] = preparedStatement
+	T.preparedStatements[preparedStatement.Destination] = preparedStatement
 }
 
 // Bind is a pending portal. Execute on Bind C->S
-func (T *State) Bind(packet fed.Packet) {
-	portal := MakePortal(packet)
-	T.pendingPortals.PushBack(portal)
+func (T *State) Bind(packet fed.Packet) (fed.Packet, error) {
+	p, err := fed.ToConcrete[*packets.Bind](packet)
+	if err != nil {
+		return nil, err
+	}
+	T.pendingPortals.PushBack(p)
+	return p, nil
 }
 
 // BindComplete notifies that a bind was successful. Execute on BindComplete S->C
@@ -172,9 +149,9 @@ func (T *State) BindComplete() {
 	}
 
 	if T.portals == nil {
-		T.portals = make(map[string]Portal)
+		T.portals = make(map[string]*packets.Bind)
 	}
-	T.portals[portal.Target] = portal
+	T.portals[portal.Destination] = portal
 }
 
 // Query clobbers the unnamed portal and unnamed prepared statement. Execute on Query C->S
@@ -184,27 +161,31 @@ func (T *State) Query() {
 }
 
 // CommandComplete clobbers everything if DISCARD ALL | DEALLOCATE | CLOSE
-func (T *State) CommandComplete(packet fed.Packet) {
-	var commandComplete packets.CommandComplete
-	if !commandComplete.ReadFromPacket(packet) {
-		return
+func (T *State) CommandComplete(packet fed.Packet) (fed.Packet, error) {
+	p, err := fed.ToConcrete[*packets.CommandComplete](packet)
+	if err != nil {
+		return nil, err
 	}
 
-	if commandComplete == "DISCARD ALL" {
+	if *p == "DISCARD ALL" {
 		maps.Clear(T.preparedStatements)
 		maps.Clear(T.portals)
 		T.pendingPreparedStatements.Clear()
 		T.pendingPortals.Clear()
 		T.pendingCloses.Clear()
 	}
+
+	return p, nil
 }
 
 // ReadyForQuery clobbers portals if state == 'I' and pending. Execute on ReadyForQuery S->C
-func (T *State) ReadyForQuery(packet fed.Packet) {
-	var state byte
-	packet.ReadUint8(&state)
+func (T *State) ReadyForQuery(packet fed.Packet) (fed.Packet, error) {
+	p, err := fed.ToConcrete[*packets.ReadyForQuery](packet)
+	if err != nil {
+		return nil, err
+	}
 
-	if state == 'I' {
+	if *p == 'I' {
 		// clobber all portals
 		for name := range T.portals {
 			delete(T.portals, name)
@@ -215,4 +196,6 @@ func (T *State) ReadyForQuery(packet fed.Packet) {
 	T.pendingPreparedStatements.Clear()
 	T.pendingPortals.Clear()
 	T.pendingCloses.Clear()
+
+	return p, nil
 }
diff --git a/lib/fed/middlewares/eqp/sync.go b/lib/fed/middlewares/eqp/sync.go
index 150d8e0d9ef2824a7cbbdc4f9029dc92d29abf7d..8a0e0cf34c588751bc1214442b3a3a9d79729ba4 100644
--- a/lib/fed/middlewares/eqp/sync.go
+++ b/lib/fed/middlewares/eqp/sync.go
@@ -16,15 +16,12 @@ func Sync(c *Client, server *fed.Conn, s *Server) error {
 		needsBackendSync = true
 	}
 
-	var packet fed.Packet
-
 	for name := range s.state.portals {
 		p := packets.Close{
-			Which:  'P',
-			Target: name,
+			Which: 'P',
+			Name:  name,
 		}
-		packet = p.IntoPacket(packet)
-		if err := server.WritePacket(packet); err != nil {
+		if err := server.WritePacket(&p); err != nil {
 			return err
 		}
 	}
@@ -32,10 +29,9 @@ func Sync(c *Client, server *fed.Conn, s *Server) error {
 	// close all prepared statements that don't match client
 	for name, preparedStatement := range s.state.preparedStatements {
 		if clientPreparedStatement, ok := c.state.preparedStatements[name]; ok {
-			if preparedStatement.Hash == clientPreparedStatement.Hash {
-				// the same
-				continue
-			}
+			// TODO(garet) do not overwrite prepared statements that match
+			_ = preparedStatement
+			_ = clientPreparedStatement
 
 			if name == "" {
 				// will be overwritten
@@ -44,11 +40,10 @@ func Sync(c *Client, server *fed.Conn, s *Server) error {
 		}
 
 		p := packets.Close{
-			Which:  'S',
-			Target: name,
+			Which: 'S',
+			Name:  name,
 		}
-		packet = p.IntoPacket(packet)
-		if err := server.WritePacket(packet); err != nil {
+		if err := server.WritePacket(&p); err != nil {
 			return err
 		}
 
@@ -58,13 +53,12 @@ func Sync(c *Client, server *fed.Conn, s *Server) error {
 	// parse all prepared statements that aren't on server
 	for name, preparedStatement := range c.state.preparedStatements {
 		if serverPreparedStatement, ok := s.state.preparedStatements[name]; ok {
-			if preparedStatement.Hash == serverPreparedStatement.Hash {
-				// the same
-				continue
-			}
+			// TODO(garet) do not overwrite prepared statements that match
+			_ = preparedStatement
+			_ = serverPreparedStatement
 		}
 
-		if err := server.WritePacket(preparedStatement.Packet); err != nil {
+		if err := server.WritePacket(preparedStatement); err != nil {
 			return err
 		}
 
@@ -77,14 +71,14 @@ func Sync(c *Client, server *fed.Conn, s *Server) error {
 	}
 
 	for _, portal := range c.state.portals {
-		if err := server.WritePacket(portal.Packet); err != nil {
+		if err := server.WritePacket(portal); err != nil {
 			return err
 		}
 	}
 
 	if needsBackendSync {
 		var err error
-		err, _, packet = backends.Sync(server, nil, packet)
+		err, _ = backends.Sync(server, nil)
 		return err
 	}
 
diff --git a/lib/fed/middlewares/ps/client.go b/lib/fed/middlewares/ps/client.go
index ecb819f992b19c47dbf313604db87df7e0f7b2d9..f093ad3d74987dd24652f5f851bdb77d99cbf91f 100644
--- a/lib/fed/middlewares/ps/client.go
+++ b/lib/fed/middlewares/ps/client.go
@@ -1,8 +1,6 @@
 package ps
 
 import (
-	"errors"
-
 	"gfx.cafe/gfx/pggat/lib/fed"
 	packets "gfx.cafe/gfx/pggat/lib/fed/packets/v3.0"
 	"gfx.cafe/gfx/pggat/lib/util/strutil"
@@ -26,21 +24,23 @@ func (T *Client) ReadPacket(packet fed.Packet) (fed.Packet, error) {
 func (T *Client) WritePacket(packet fed.Packet) (fed.Packet, error) {
 	switch packet.Type() {
 	case packets.TypeParameterStatus:
-		var ps packets.ParameterStatus
-		if !ps.ReadFromPacket(packet) {
-			return packet, errors.New("bad packet format i")
+		p, err := fed.ToConcrete[*packets.ParameterStatus](packet)
+		if err != nil {
+			return nil, err
 		}
-		ikey := strutil.MakeCIString(ps.Key)
-		if T.synced && T.parameters[ikey] == ps.Value {
+		ikey := strutil.MakeCIString(p.Key)
+		if T.synced && T.parameters[ikey] == p.Value {
 			// already set
-			return packet[:0], nil
+			return nil, nil
 		}
 		if T.parameters == nil {
 			T.parameters = make(map[strutil.CIString]string)
 		}
-		T.parameters[ikey] = ps.Value
+		T.parameters[ikey] = p.Value
+		return p, nil
+	default:
+		return packet, nil
 	}
-	return packet, nil
 }
 
 var _ fed.Middleware = (*Client)(nil)
diff --git a/lib/fed/middlewares/ps/server.go b/lib/fed/middlewares/ps/server.go
index f74f4f0c8c2c15414a34524984b83d313cc53159..ffa537fec5a03bd38ca6b5390b1f5fefe0b19303 100644
--- a/lib/fed/middlewares/ps/server.go
+++ b/lib/fed/middlewares/ps/server.go
@@ -1,8 +1,6 @@
 package ps
 
 import (
-	"errors"
-
 	"gfx.cafe/gfx/pggat/lib/fed"
 	packets "gfx.cafe/gfx/pggat/lib/fed/packets/v3.0"
 	"gfx.cafe/gfx/pggat/lib/util/strutil"
@@ -21,17 +19,19 @@ func NewServer(parameters map[strutil.CIString]string) *Server {
 func (T *Server) ReadPacket(packet fed.Packet) (fed.Packet, error) {
 	switch packet.Type() {
 	case packets.TypeParameterStatus:
-		var ps packets.ParameterStatus
-		if !ps.ReadFromPacket(packet) {
-			return packet, errors.New("bad packet format j")
+		p, err := fed.ToConcrete[*packets.ParameterStatus](packet)
+		if err != nil {
+			return nil, err
 		}
-		ikey := strutil.MakeCIString(ps.Key)
+		ikey := strutil.MakeCIString(p.Key)
 		if T.parameters == nil {
 			T.parameters = make(map[strutil.CIString]string)
 		}
-		T.parameters[ikey] = ps.Value
+		T.parameters[ikey] = p.Value
+		return p, nil
+	default:
+		return packet, nil
 	}
-	return packet, nil
 }
 
 func (T *Server) WritePacket(packet fed.Packet) (fed.Packet, error) {
diff --git a/lib/fed/netconn.go b/lib/fed/netconn.go
deleted file mode 100644
index 480edb12b2c66cca2eea13888daac31ca226c404..0000000000000000000000000000000000000000
--- a/lib/fed/netconn.go
+++ /dev/null
@@ -1,144 +0,0 @@
-package fed
-
-import (
-	"bufio"
-	"crypto/tls"
-	"encoding/binary"
-	"errors"
-	"io"
-	"net"
-
-	"gfx.cafe/gfx/pggat/lib/util/slices"
-)
-
-type NetConn struct {
-	conn       net.Conn
-	writer     bufio.Writer
-	reader     bufio.Reader
-	sslEnabled bool
-
-	headerBuf [5]byte
-}
-
-func NewNetConn(conn net.Conn) *NetConn {
-	c := &NetConn{
-		conn: conn,
-	}
-	c.writer.Reset(conn)
-	c.reader.Reset(conn)
-	return c
-}
-
-func (T *NetConn) LocalAddr() net.Addr {
-	return T.conn.LocalAddr()
-}
-
-func (T *NetConn) RemoteAddr() net.Addr {
-	return T.conn.RemoteAddr()
-}
-
-// SSL
-
-var errSSLAlreadyEnabled = errors.New("ssl is already enabled")
-
-func (T *NetConn) SSL() bool {
-	return T.sslEnabled
-}
-
-func (T *NetConn) EnableSSLClient(config *tls.Config) error {
-	if T.sslEnabled {
-		return errSSLAlreadyEnabled
-	}
-	T.sslEnabled = true
-
-	if err := T.writer.Flush(); err != nil {
-		return err
-	}
-	if T.reader.Buffered() > 0 {
-		return errors.New("expected empty read buffer")
-	}
-	sslConn := tls.Client(T.conn, config)
-	T.writer.Reset(sslConn)
-	T.reader.Reset(sslConn)
-	T.conn = sslConn
-	return sslConn.Handshake()
-}
-
-func (T *NetConn) EnableSSLServer(config *tls.Config) error {
-	if T.sslEnabled {
-		return errSSLAlreadyEnabled
-	}
-	T.sslEnabled = true
-
-	if err := T.writer.Flush(); err != nil {
-		return err
-	}
-	if T.reader.Buffered() > 0 {
-		return errors.New("expected empty read buffer")
-	}
-	sslConn := tls.Server(T.conn, config)
-	T.writer.Reset(sslConn)
-	T.reader.Reset(sslConn)
-	T.conn = sslConn
-	return sslConn.Handshake()
-}
-
-func (T *NetConn) ReadByte() (byte, error) {
-	if err := T.writer.Flush(); err != nil {
-		return 0, err
-	}
-	return T.reader.ReadByte()
-}
-
-func (T *NetConn) ReadPacket(typed bool, buffer Packet) (packet Packet, err error) {
-	packet = buffer
-
-	if err = T.writer.Flush(); err != nil {
-		return
-	}
-
-	if typed {
-		_, err = io.ReadFull(&T.reader, T.headerBuf[:])
-		if err != nil {
-			return
-		}
-	} else {
-		_, err = io.ReadFull(&T.reader, T.headerBuf[1:])
-		if err != nil {
-			return
-		}
-	}
-
-	length := binary.BigEndian.Uint32(T.headerBuf[1:])
-
-	packet = slices.Resize(buffer, int(length)+1)
-	copy(packet, T.headerBuf[:])
-
-	_, err = io.ReadFull(&T.reader, packet.Payload())
-	if err != nil {
-		return
-	}
-	return
-}
-
-func (T *NetConn) WriteByte(b byte) error {
-	return T.writer.WriteByte(b)
-}
-
-func (T *NetConn) WritePacket(packet Packet) error {
-	_, err := T.writer.Write(packet.Bytes())
-	return err
-}
-
-func (T *NetConn) Close() error {
-	if err := T.writer.Flush(); err != nil {
-		return err
-	}
-	return T.conn.Close()
-}
-
-var _ ReadWriteCloser = (*NetConn)(nil)
-var _ SSLServer = (*NetConn)(nil)
-var _ SSLClient = (*NetConn)(nil)
-var _ io.ByteReader = (*NetConn)(nil)
-var _ io.ByteWriter = (*NetConn)(nil)
diff --git a/lib/fed/packet.go b/lib/fed/packet.go
new file mode 100644
index 0000000000000000000000000000000000000000..950eac63177fb082b7499d3936a3a864ac684338
--- /dev/null
+++ b/lib/fed/packet.go
@@ -0,0 +1,50 @@
+package fed
+
+type Packet interface {
+	Type() Type
+	Length() int
+
+	WriteTo(encoder *Encoder) error
+}
+
+type ReadablePacket interface {
+	Packet
+
+	ReadFrom(decoder *Decoder) error
+}
+
+type PendingPacket struct {
+	Decoder *Decoder
+}
+
+func (T PendingPacket) Type() Type {
+	return T.Decoder.Type()
+}
+
+func (T PendingPacket) Length() int {
+	return T.Decoder.Length()
+}
+
+func (T PendingPacket) WriteTo(encoder *Encoder) error {
+	// TODO(garet) this should be better
+	b, err := T.Decoder.Remaining()
+	if err != nil {
+		return err
+	}
+	return encoder.Bytes(b)
+}
+
+var _ Packet = PendingPacket{}
+
+func ToConcrete[T ReadablePacket](packet Packet) (T, error) {
+	switch p := packet.(type) {
+	case T:
+		return p, nil
+	case PendingPacket:
+		var res T
+		err := res.ReadFrom(p.Decoder)
+		return res, err
+	default:
+		panic("incompatible packet types")
+	}
+}
diff --git a/lib/fed/packets/v3.0/authenticationcleartext.go b/lib/fed/packets/v3.0/authenticationcleartext.go
deleted file mode 100644
index 4542e3f8cbb20467eb51777b71b82e519dea433b..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/authenticationcleartext.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package packets
-
-import "gfx.cafe/gfx/pggat/lib/fed"
-
-type AuthenticationCleartext struct{}
-
-func (T *AuthenticationCleartext) ReadFrom(decoder *fed.Decoder) error {
-	if decoder.Type() != TypeAuthentication {
-		return ErrUnexpectedPacket
-	}
-
-	method, err := decoder.Int32()
-	if err != nil {
-		return err
-	}
-
-	if method != 3 {
-		return ErrBadFormat
-	}
-	return nil
-}
-
-func (T *AuthenticationCleartext) WriteTo(encoder *fed.Encoder) error {
-	if err := encoder.Next(TypeAuthentication, 4); err != nil {
-		return err
-	}
-	return encoder.Uint32(3)
-}
diff --git a/lib/fed/packets/v3.0/authenticationmd5.go b/lib/fed/packets/v3.0/authenticationmd5.go
deleted file mode 100644
index 5e2e941a178775f5d37cda1af12827762248e2bf..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/authenticationmd5.go
+++ /dev/null
@@ -1,34 +0,0 @@
-package packets
-
-import "gfx.cafe/gfx/pggat/lib/fed"
-
-type AuthenticationMD5 struct {
-	Salt [4]byte
-}
-
-func (T *AuthenticationMD5) ReadFrom(packet fed.PacketDecoder) error {
-	if packet.Type != TypeAuthentication {
-		return ErrUnexpectedPacket
-	}
-
-	var method int32
-	err := packet.
-		Int32(&method).
-		Bytes(T.Salt[:]).
-		Error
-	if err != nil {
-		return err
-	}
-
-	if method != 5 {
-		return ErrBadFormat
-	}
-	return nil
-}
-
-func (T *AuthenticationMD5) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = packet.Reset(TypeAuthentication, 8)
-	packet = packet.AppendUint32(5)
-	packet = packet.AppendBytes(T.Salt[:])
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/authenticationok.go b/lib/fed/packets/v3.0/authenticationok.go
deleted file mode 100644
index 93d911aa31e6f62e07e8a0154c7c8c43995ce8e6..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/authenticationok.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package packets
-
-import "gfx.cafe/gfx/pggat/lib/fed"
-
-type AuthenticationOk struct{}
-
-func (T *AuthenticationOk) ReadFrom(packet fed.PacketDecoder) error {
-	if packet.Type != TypeAuthentication {
-		return ErrUnexpectedPacket
-	}
-
-	var method int32
-	err := packet.Int32(&method).Error
-	if err != nil {
-		return err
-	}
-
-	if method != 0 {
-		return ErrBadFormat
-	}
-	return nil
-}
-
-func (T *AuthenticationOk) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = packet.Reset(TypeAuthentication, 4)
-	packet = packet.AppendUint32(0)
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/authenticationresponse.go b/lib/fed/packets/v3.0/authenticationresponse.go
deleted file mode 100644
index 80ea08f8c27a16b304ad3133210f944502261a59..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/authenticationresponse.go
+++ /dev/null
@@ -1,21 +0,0 @@
-package packets
-
-import (
-	"gfx.cafe/gfx/pggat/lib/fed"
-)
-
-type AuthenticationResponse []byte
-
-func (T *AuthenticationResponse) ReadFrom(packet fed.PacketDecoder) error {
-	if packet.Type != TypeAuthenticationResponse {
-		return ErrUnexpectedPacket
-	}
-
-	return packet.Remaining((*[]byte)(T)).Error
-}
-
-func (T *AuthenticationResponse) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = fed.NewPacket(TypeAuthenticationResponse, len(*T))
-	packet = packet.AppendBytes(*T)
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/authenticationsasl.go b/lib/fed/packets/v3.0/authenticationsasl.go
deleted file mode 100644
index 90d9a3dfc9dda2926c9c72221532188cc39821bd..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/authenticationsasl.go
+++ /dev/null
@@ -1,45 +0,0 @@
-package packets
-
-import "gfx.cafe/gfx/pggat/lib/fed"
-
-type AuthenticationSASL struct {
-	Mechanisms []string
-}
-
-func (T *AuthenticationSASL) ReadFrom(packet fed.PacketDecoder) error {
-	if packet.Type != TypeAuthentication {
-		return ErrUnexpectedPacket
-	}
-
-	var method int32
-	p := packet.Int32(&method)
-	if method != 10 {
-		return ErrBadFormat
-	}
-	T.Mechanisms = T.Mechanisms[:0]
-	for {
-		var mechanism string
-		p = p.String(&mechanism)
-		if mechanism == "" {
-			break
-		}
-		T.Mechanisms = append(T.Mechanisms, mechanism)
-	}
-	return p.Error
-}
-
-func (T *AuthenticationSASL) IntoPacket(packet fed.Packet) fed.Packet {
-	size := 5
-	for _, mechanism := range T.Mechanisms {
-		size += len(mechanism) + 1
-	}
-
-	packet = packet.Reset(TypeAuthentication, size)
-
-	packet = packet.AppendInt32(10)
-	for _, mechanism := range T.Mechanisms {
-		packet = packet.AppendString(mechanism)
-	}
-	packet = packet.AppendUint8(0)
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/authenticationsaslcontinue.go b/lib/fed/packets/v3.0/authenticationsaslcontinue.go
deleted file mode 100644
index 135d87ab8dc020e453b879dc689d520b436aeca8..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/authenticationsaslcontinue.go
+++ /dev/null
@@ -1,29 +0,0 @@
-package packets
-
-import (
-	"gfx.cafe/gfx/pggat/lib/fed"
-	"gfx.cafe/gfx/pggat/lib/util/slices"
-)
-
-type AuthenticationSASLContinue []byte
-
-func (T *AuthenticationSASLContinue) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeAuthentication {
-		return false
-	}
-	var method int32
-	p := packet.ReadInt32(&method)
-	if method != 11 {
-		return false
-	}
-	*T = slices.Resize(*T, len(p))
-	p.ReadBytes(*T)
-	return true
-}
-
-func (T *AuthenticationSASLContinue) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = packet.Reset(TypeAuthentication, 4+len(*T))
-	packet = packet.AppendUint32(11)
-	packet = packet.AppendBytes(*T)
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/authenticationsaslfinal.go b/lib/fed/packets/v3.0/authenticationsaslfinal.go
deleted file mode 100644
index b5a191cafe8cfd3f9a39dcc763fecfea084d8d5f..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/authenticationsaslfinal.go
+++ /dev/null
@@ -1,29 +0,0 @@
-package packets
-
-import (
-	"gfx.cafe/gfx/pggat/lib/fed"
-	"gfx.cafe/gfx/pggat/lib/util/slices"
-)
-
-type AuthenticationSASLFinal []byte
-
-func (T *AuthenticationSASLFinal) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeAuthentication {
-		return false
-	}
-	var method int32
-	p := packet.ReadInt32(&method)
-	if method != 12 {
-		return false
-	}
-	*T = slices.Resize(*T, len(p))
-	p.ReadBytes(*T)
-	return true
-}
-
-func (T *AuthenticationSASLFinal) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = packet.Reset(TypeAuthentication, 4+len(*T))
-	packet = packet.AppendUint32(12)
-	packet = packet.AppendBytes(*T)
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/backendkeydata.go b/lib/fed/packets/v3.0/backendkeydata.go
deleted file mode 100644
index e144b3ad19e42c814dc661ad3542d544ac875c86..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/backendkeydata.go
+++ /dev/null
@@ -1,21 +0,0 @@
-package packets
-
-import "gfx.cafe/gfx/pggat/lib/fed"
-
-type BackendKeyData struct {
-	CancellationKey [8]byte
-}
-
-func (T *BackendKeyData) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeBackendKeyData {
-		return false
-	}
-	packet.ReadBytes(T.CancellationKey[:])
-	return true
-}
-
-func (T *BackendKeyData) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = fed.NewPacket(TypeBackendKeyData, 8)
-	packet = packet.AppendBytes(T.CancellationKey[:])
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/bind.go b/lib/fed/packets/v3.0/bind.go
deleted file mode 100644
index de1755e519369e5e57c2d3936007387be134f8df..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/bind.go
+++ /dev/null
@@ -1,88 +0,0 @@
-package packets
-
-import (
-	"gfx.cafe/gfx/pggat/lib/fed"
-	"gfx.cafe/gfx/pggat/lib/util/slices"
-)
-
-type Bind struct {
-	Destination          string
-	Source               string
-	ParameterFormatCodes []int16
-	ParameterValues      [][]byte
-	ResultFormatCodes    []int16
-}
-
-func (T *Bind) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeBind {
-		return false
-	}
-	p := packet.ReadString(&T.Destination)
-	p = p.ReadString(&T.Source)
-
-	var parameterFormatCodesLength uint16
-	p = p.ReadUint16(&parameterFormatCodesLength)
-	T.ParameterFormatCodes = slices.Resize(T.ParameterFormatCodes, int(parameterFormatCodesLength))
-	for i := 0; i < int(parameterFormatCodesLength); i++ {
-		p = p.ReadInt16(&T.ParameterFormatCodes[i])
-	}
-
-	var parameterValuesLength uint16
-	p = p.ReadUint16(&parameterValuesLength)
-	T.ParameterValues = slices.Resize(T.ParameterValues, int(parameterValuesLength))
-	for i := 0; i < int(parameterValuesLength); i++ {
-		var parameterValueLength int32
-		p = p.ReadInt32(&parameterValueLength)
-		if parameterValueLength == -1 {
-			T.ParameterValues[i] = nil
-			continue
-		}
-		T.ParameterValues[i] = slices.Resize(T.ParameterValues[i], int(parameterValueLength))
-		p = p.ReadBytes(T.ParameterValues[i])
-	}
-
-	var resultFormatCodesLength uint16
-	p = p.ReadUint16(&resultFormatCodesLength)
-	T.ResultFormatCodes = slices.Resize(T.ResultFormatCodes, int(resultFormatCodesLength))
-	for i := 0; i < int(resultFormatCodesLength); i++ {
-		p = p.ReadInt16(&T.ResultFormatCodes[i])
-	}
-
-	return true
-}
-
-func (T *Bind) IntoPacket(packet fed.Packet) fed.Packet {
-	size := 0
-	size += len(T.Destination) + 1
-	size += len(T.Source) + 1
-	size += 2
-	size += len(T.ParameterFormatCodes) * 2
-	size += 2
-	for _, v := range T.ParameterValues {
-		size += 4 + len(v)
-	}
-	size += 2
-	size += len(T.ResultFormatCodes) * 2
-
-	packet = packet.Reset(TypeBind, size)
-	packet = packet.AppendString(T.Destination)
-	packet = packet.AppendString(T.Source)
-	packet = packet.AppendUint16(uint16(len(T.ParameterFormatCodes)))
-	for _, v := range T.ParameterFormatCodes {
-		packet = packet.AppendInt16(v)
-	}
-	packet = packet.AppendUint16(uint16(len(T.ParameterValues)))
-	for _, v := range T.ParameterValues {
-		if v == nil {
-			packet = packet.AppendInt32(-1)
-			continue
-		}
-		packet = packet.AppendInt32(int32(len(v)))
-		packet = packet.AppendBytes(v)
-	}
-	packet = packet.AppendUint16(uint16(len(T.ResultFormatCodes)))
-	for _, v := range T.ResultFormatCodes {
-		packet = packet.AppendInt16(v)
-	}
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/close.go b/lib/fed/packets/v3.0/close.go
deleted file mode 100644
index 89221f91217347809832b29ce2760b0fc5a0711c..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/close.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package packets
-
-import "gfx.cafe/gfx/pggat/lib/fed"
-
-type Close struct {
-	Which  byte
-	Target string
-}
-
-func (T *Close) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeClose {
-		return false
-	}
-	p := packet.ReadUint8(&T.Which)
-	p = p.ReadString(&T.Target)
-	return true
-}
-
-func (T *Close) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = packet.Reset(TypeClose, 2+len(T.Target))
-	packet = packet.AppendUint8(T.Which)
-	packet = packet.AppendString(T.Target)
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/commandcomplete.go b/lib/fed/packets/v3.0/commandcomplete.go
deleted file mode 100644
index 647804d4ff54d755e6bee2fef6fc0ba65856b15a..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/commandcomplete.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package packets
-
-import "gfx.cafe/gfx/pggat/lib/fed"
-
-type CommandComplete string
-
-func (T *CommandComplete) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeCommandComplete {
-		return false
-	}
-	packet.ReadString((*string)(T))
-	return true
-}
-
-func (T *CommandComplete) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = packet.Reset(TypeCommandComplete, len(*T)+1)
-	packet = packet.AppendString(string(*T))
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/copydata.go b/lib/fed/packets/v3.0/copydata.go
deleted file mode 100644
index 3043745bcbe0c5fdece8514e44dc242d5e8dae8e..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/copydata.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package packets
-
-import (
-	"gfx.cafe/gfx/pggat/lib/fed"
-	"gfx.cafe/gfx/pggat/lib/util/slices"
-)
-
-type CopyData []byte
-
-func (T *CopyData) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeCopyData {
-		return false
-	}
-
-	*T = slices.Resize(*T, len(packet.Payload()))
-	packet.ReadBytes(*T)
-	return true
-}
-
-func (T *CopyData) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = fed.NewPacket(TypeCopyData, len(*T))
-	packet = packet.AppendBytes(*T)
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/copyfail.go b/lib/fed/packets/v3.0/copyfail.go
deleted file mode 100644
index 6f42d09721b867f64281b0158fc25d7543048494..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/copyfail.go
+++ /dev/null
@@ -1,21 +0,0 @@
-package packets
-
-import "gfx.cafe/gfx/pggat/lib/fed"
-
-type CopyFail struct {
-	Reason string
-}
-
-func (T *CopyFail) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeCopyFail {
-		return false
-	}
-	packet.ReadString(&T.Reason)
-	return true
-}
-
-func (T *CopyFail) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = packet.Reset(TypeCopyFail, len(T.Reason)+1)
-	packet = packet.AppendString(T.Reason)
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/datarow.go b/lib/fed/packets/v3.0/datarow.go
deleted file mode 100644
index 31e2662266010779626a68835db14a6ae93dc43a..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/datarow.go
+++ /dev/null
@@ -1,52 +0,0 @@
-package packets
-
-import (
-	"gfx.cafe/gfx/pggat/lib/fed"
-	"gfx.cafe/gfx/pggat/lib/util/slices"
-)
-
-type DataRow struct {
-	Columns [][]byte
-}
-
-func (T *DataRow) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeDataRow {
-		return false
-	}
-
-	var columnCount uint16
-	p := packet.ReadUint16(&columnCount)
-	T.Columns = slices.Resize(T.Columns, int(columnCount))
-	for i := 0; i < int(columnCount); i++ {
-		var valueLength int32
-		p = p.ReadInt32(&valueLength)
-		if valueLength == -1 {
-			continue
-		}
-		T.Columns[i] = slices.Resize(T.Columns[i], int(valueLength))
-		p = p.ReadBytes(T.Columns[i])
-	}
-
-	return true
-}
-
-func (T *DataRow) IntoPacket(packet fed.Packet) fed.Packet {
-	size := 2
-	for _, v := range T.Columns {
-		size += len(v) + 4
-	}
-
-	packet = packet.Reset(TypeDataRow, size)
-	packet = packet.AppendUint16(uint16(len(T.Columns)))
-	for _, v := range T.Columns {
-		if v == nil {
-			packet = packet.AppendInt32(-1)
-			continue
-		}
-
-		packet = packet.AppendInt32(int32(len(v)))
-		packet = packet.AppendBytes(v)
-	}
-
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/describe.go b/lib/fed/packets/v3.0/describe.go
deleted file mode 100644
index e6510ffe49a5db52e503cfc7d6b781e6844f090c..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/describe.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package packets
-
-import "gfx.cafe/gfx/pggat/lib/fed"
-
-type Describe struct {
-	Which  byte
-	Target string
-}
-
-func (T *Describe) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeDescribe {
-		return false
-	}
-	p := packet.ReadUint8(&T.Which)
-	p = p.ReadString(&T.Target)
-	return true
-}
-
-func (T *Describe) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = packet.Reset(TypeDescribe, len(T.Target)+2)
-	packet = packet.AppendUint8(T.Which)
-	packet = packet.AppendString(T.Target)
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/errorresponse.go b/lib/fed/packets/v3.0/errorresponse.go
deleted file mode 100644
index a97f46058cac2f83ab2d77d4aa5f475937a3f58e..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/errorresponse.go
+++ /dev/null
@@ -1,86 +0,0 @@
-package packets
-
-import (
-	"gfx.cafe/gfx/pggat/lib/fed"
-	"gfx.cafe/gfx/pggat/lib/perror"
-)
-
-type ErrorResponse struct {
-	Error perror.Error
-}
-
-func (T *ErrorResponse) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeErrorResponse {
-		return false
-	}
-
-	var severity perror.Severity
-	var code perror.Code
-	var message string
-	var extra []perror.ExtraField
-
-	p := packet.Payload()
-
-	for {
-		var typ uint8
-		p = p.ReadUint8(&typ)
-
-		if typ == 0 {
-			break
-		}
-
-		var value string
-		p = p.ReadString(&value)
-
-		switch typ {
-		case 'S':
-			severity = perror.Severity(value)
-		case 'C':
-			code = perror.Code(value)
-		case 'M':
-			message = value
-		default:
-			extra = append(extra, perror.ExtraField{
-				Type:  perror.Extra(typ),
-				Value: value,
-			})
-		}
-	}
-
-	T.Error = perror.New(
-		severity,
-		code,
-		message,
-		extra...,
-	)
-	return true
-}
-
-func (T *ErrorResponse) IntoPacket(packet fed.Packet) fed.Packet {
-	size := 1
-	size += len(T.Error.Severity()) + 2
-	size += len(T.Error.Code()) + 2
-	size += len(T.Error.Message()) + 2
-	for _, field := range T.Error.Extra() {
-		size += len(field.Value) + 2
-	}
-
-	packet = packet.Reset(TypeErrorResponse, size)
-
-	packet = packet.AppendUint8('S')
-	packet = packet.AppendString(string(T.Error.Severity()))
-
-	packet = packet.AppendUint8('C')
-	packet = packet.AppendString(string(T.Error.Code()))
-
-	packet = packet.AppendUint8('M')
-	packet = packet.AppendString(T.Error.Message())
-
-	for _, field := range T.Error.Extra() {
-		packet = packet.AppendUint8(uint8(field.Type))
-		packet = packet.AppendString(field.Value)
-	}
-
-	packet = packet.AppendUint8(0)
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/errors.go b/lib/fed/packets/v3.0/errors.go
deleted file mode 100644
index b7bc928bb4bc9565be27eb54f1f8e18dc8ba4d9a..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/errors.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package packets
-
-import "gfx.cafe/gfx/pggat/lib/perror"
-
-var (
-	ErrBadFormat = perror.New(
-		perror.FATAL,
-		perror.ProtocolViolation,
-		"Bad packet format",
-	)
-	ErrUnexpectedPacket = perror.New(
-		perror.FATAL,
-		perror.ProtocolViolation,
-		"unexpected packet",
-	)
-)
diff --git a/lib/fed/packets/v3.0/execute.go b/lib/fed/packets/v3.0/execute.go
deleted file mode 100644
index 9d8c172d2d657dc6e0dae70037c0b3d59b762358..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/execute.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package packets
-
-import "gfx.cafe/gfx/pggat/lib/fed"
-
-type Execute struct {
-	Target  string
-	MaxRows int32
-}
-
-func (T *Execute) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeExecute {
-		return false
-	}
-	p := packet.ReadString(&T.Target)
-	p = p.ReadInt32(&T.MaxRows)
-	return true
-}
-
-func (T *Execute) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = packet.Reset(TypeExecute, len(T.Target)+5)
-	packet = packet.AppendString(T.Target)
-	packet = packet.AppendInt32(T.MaxRows)
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/negotiateprotocolversion.go b/lib/fed/packets/v3.0/negotiateprotocolversion.go
deleted file mode 100644
index aad5dfadb33ce7cfd82a18f8d0f6e1d39fa06894..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/negotiateprotocolversion.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package packets
-
-import (
-	"gfx.cafe/gfx/pggat/lib/fed"
-	"gfx.cafe/gfx/pggat/lib/util/slices"
-)
-
-type NegotiateProtocolVersion struct {
-	MinorProtocolVersion int32
-	UnrecognizedOptions  []string
-}
-
-func (T *NegotiateProtocolVersion) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeNegotiateProtocolVersion {
-		return false
-	}
-	p := packet.ReadInt32(&T.MinorProtocolVersion)
-
-	var numUnrecognizedOptions int32
-	p = p.ReadInt32(&numUnrecognizedOptions)
-
-	T.UnrecognizedOptions = slices.Resize(T.UnrecognizedOptions, int(numUnrecognizedOptions))
-	for i := 0; i < int(numUnrecognizedOptions); i++ {
-		p = p.ReadString(&T.UnrecognizedOptions[i])
-	}
-
-	return true
-}
-
-func (T *NegotiateProtocolVersion) IntoPacket(packet fed.Packet) fed.Packet {
-	size := 8
-	for _, v := range T.UnrecognizedOptions {
-		size += len(v) + 1
-	}
-
-	packet = packet.Reset(TypeNegotiateProtocolVersion, size)
-	packet = packet.AppendInt32(T.MinorProtocolVersion)
-	packet = packet.AppendInt32(int32(len(T.UnrecognizedOptions)))
-	for _, v := range T.UnrecognizedOptions {
-		packet = packet.AppendString(v)
-	}
-
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/packets.go b/lib/fed/packets/v3.0/packets.go
new file mode 100644
index 0000000000000000000000000000000000000000..7bafb19b0c403cfb1f5196e3aa4ff87cb9ee46a7
--- /dev/null
+++ b/lib/fed/packets/v3.0/packets.go
@@ -0,0 +1,3222 @@
+package packets
+
+// automatically generated. do not edit
+
+import (
+	"gfx.cafe/gfx/pggat/lib/fed"
+	"gfx.cafe/gfx/pggat/lib/util/slices"
+
+	"errors"
+)
+
+var (
+	ErrUnexpectedPacket = errors.New("unexpected packet")
+	ErrInvalidFormat    = errors.New("invalid packet format")
+)
+
+const (
+	TypeAuthentication           = 'R'
+	TypeBackendKeyData           = 'K'
+	TypeBind                     = 'B'
+	TypeBindComplete             = '2'
+	TypeClose                    = 'C'
+	TypeCloseComplete            = '3'
+	TypeCommandComplete          = 'C'
+	TypeCopyBothResponse         = 'W'
+	TypeCopyData                 = 'd'
+	TypeCopyDone                 = 'c'
+	TypeCopyFail                 = 'f'
+	TypeCopyInResponse           = 'G'
+	TypeCopyOutResponse          = 'H'
+	TypeDataRow                  = 'D'
+	TypeDescribe                 = 'D'
+	TypeEmptyQueryResponse       = 'I'
+	TypeErrorResponse            = 'E'
+	TypeExecute                  = 'E'
+	TypeFlush                    = 'H'
+	TypeFunctionCall             = 'F'
+	TypeFunctionCallResponse     = 'V'
+	TypeGSSResponse              = 'p'
+	TypeNegotiateProtocolVersion = 'v'
+	TypeNoData                   = 'n'
+	TypeNoticeResponse           = 'N'
+	TypeNotificationResponse     = 'A'
+	TypeParameterDescription     = 't'
+	TypeParameterStatus          = 'S'
+	TypeParse                    = 'P'
+	TypeParseComplete            = '1'
+	TypePasswordMessage          = 'p'
+	TypePortalSuspended          = 's'
+	TypeQuery                    = 'Q'
+	TypeReadyForQuery            = 'Z'
+	TypeRowDescription           = 'T'
+	TypeSASLInitialResponse      = 'p'
+	TypeSASLResponse             = 'p'
+	TypeSync                     = 'S'
+	TypeTerminate                = 'X'
+)
+
+type AuthenticationPayloadCleartextPassword struct{}
+
+func (*AuthenticationPayloadCleartextPassword) AuthenticationPayloadMode() int32 {
+	return 3
+}
+
+func (T *AuthenticationPayloadCleartextPassword) Length() (length int) {
+
+	return
+}
+
+func (T *AuthenticationPayloadCleartextPassword) ReadFrom(decoder *fed.Decoder) (err error) {
+
+	return
+}
+
+func (T *AuthenticationPayloadCleartextPassword) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+type AuthenticationPayloadGSS struct{}
+
+func (*AuthenticationPayloadGSS) AuthenticationPayloadMode() int32 {
+	return 7
+}
+
+func (T *AuthenticationPayloadGSS) Length() (length int) {
+
+	return
+}
+
+func (T *AuthenticationPayloadGSS) ReadFrom(decoder *fed.Decoder) (err error) {
+
+	return
+}
+
+func (T *AuthenticationPayloadGSS) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+type AuthenticationPayloadGSSContinue []uint8
+
+func (*AuthenticationPayloadGSSContinue) AuthenticationPayloadMode() int32 {
+	return 8
+}
+
+func (T *AuthenticationPayloadGSSContinue) Length() (length int) {
+	for _, temp1 := range *T {
+		_ = temp1
+
+		length += 1
+
+	}
+
+	return
+}
+
+func (T *AuthenticationPayloadGSSContinue) ReadFrom(decoder *fed.Decoder) (err error) {
+	(*T) = (*T)[:0]
+
+	for {
+		if decoder.Position() >= decoder.Length() {
+			break
+		}
+
+		(*T) = slices.Resize((*T), len((*T))+1)
+
+		*(*uint8)(&((*T)[len((*T))-1])), err = decoder.Uint8()
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+func (T *AuthenticationPayloadGSSContinue) WriteTo(encoder *fed.Encoder) (err error) {
+	for _, temp2 := range *T {
+		err = encoder.Uint8(uint8(temp2))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+type AuthenticationPayloadKerberosV5 struct{}
+
+func (*AuthenticationPayloadKerberosV5) AuthenticationPayloadMode() int32 {
+	return 2
+}
+
+func (T *AuthenticationPayloadKerberosV5) Length() (length int) {
+
+	return
+}
+
+func (T *AuthenticationPayloadKerberosV5) ReadFrom(decoder *fed.Decoder) (err error) {
+
+	return
+}
+
+func (T *AuthenticationPayloadKerberosV5) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+type AuthenticationPayloadMD5Password [4]uint8
+
+func (*AuthenticationPayloadMD5Password) AuthenticationPayloadMode() int32 {
+	return 5
+}
+
+func (T *AuthenticationPayloadMD5Password) Length() (length int) {
+	for _, temp3 := range *T {
+		_ = temp3
+
+		length += 1
+
+	}
+
+	return
+}
+
+func (T *AuthenticationPayloadMD5Password) ReadFrom(decoder *fed.Decoder) (err error) {
+	for temp4 := 0; temp4 < 4; temp4++ {
+		*(*uint8)(&((*T)[temp4])), err = decoder.Uint8()
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+func (T *AuthenticationPayloadMD5Password) WriteTo(encoder *fed.Encoder) (err error) {
+	for _, temp5 := range *T {
+		err = encoder.Uint8(uint8(temp5))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+type AuthenticationPayloadOk struct{}
+
+func (*AuthenticationPayloadOk) AuthenticationPayloadMode() int32 {
+	return 0
+}
+
+func (T *AuthenticationPayloadOk) Length() (length int) {
+
+	return
+}
+
+func (T *AuthenticationPayloadOk) ReadFrom(decoder *fed.Decoder) (err error) {
+
+	return
+}
+
+func (T *AuthenticationPayloadOk) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+type AuthenticationPayloadSASLMethod struct {
+	Method string
+}
+
+type AuthenticationPayloadSASL []AuthenticationPayloadSASLMethod
+
+func (*AuthenticationPayloadSASL) AuthenticationPayloadMode() int32 {
+	return 10
+}
+
+func (T *AuthenticationPayloadSASL) Length() (length int) {
+	for _, temp6 := range *T {
+		_ = temp6
+
+		length += len(temp6.Method) + 1
+
+	}
+
+	var temp7 string
+	_ = temp7
+
+	length += len(temp7) + 1
+
+	return
+}
+
+func (T *AuthenticationPayloadSASL) ReadFrom(decoder *fed.Decoder) (err error) {
+	(*T) = (*T)[:0]
+
+	for {
+		(*T) = slices.Resize((*T), len((*T))+1)
+
+		*(*string)(&((*T)[len((*T))-1].Method)), err = decoder.String()
+		if err != nil {
+			return
+		}
+		if (*T)[len((*T))-1].Method == *new(string) {
+			(*T) = (*T)[:len((*T))-1]
+			break
+		}
+	}
+
+	return
+}
+
+func (T *AuthenticationPayloadSASL) WriteTo(encoder *fed.Encoder) (err error) {
+	for _, temp8 := range *T {
+		err = encoder.String(string(temp8.Method))
+		if err != nil {
+			return
+		}
+
+	}
+
+	var temp9 string
+
+	err = encoder.String(string(temp9))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+type AuthenticationPayloadSASLContinue []uint8
+
+func (*AuthenticationPayloadSASLContinue) AuthenticationPayloadMode() int32 {
+	return 11
+}
+
+func (T *AuthenticationPayloadSASLContinue) Length() (length int) {
+	for _, temp10 := range *T {
+		_ = temp10
+
+		length += 1
+
+	}
+
+	return
+}
+
+func (T *AuthenticationPayloadSASLContinue) ReadFrom(decoder *fed.Decoder) (err error) {
+	(*T) = (*T)[:0]
+
+	for {
+		if decoder.Position() >= decoder.Length() {
+			break
+		}
+
+		(*T) = slices.Resize((*T), len((*T))+1)
+
+		*(*uint8)(&((*T)[len((*T))-1])), err = decoder.Uint8()
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+func (T *AuthenticationPayloadSASLContinue) WriteTo(encoder *fed.Encoder) (err error) {
+	for _, temp11 := range *T {
+		err = encoder.Uint8(uint8(temp11))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+type AuthenticationPayloadSASLFinal []uint8
+
+func (*AuthenticationPayloadSASLFinal) AuthenticationPayloadMode() int32 {
+	return 12
+}
+
+func (T *AuthenticationPayloadSASLFinal) Length() (length int) {
+	for _, temp12 := range *T {
+		_ = temp12
+
+		length += 1
+
+	}
+
+	return
+}
+
+func (T *AuthenticationPayloadSASLFinal) ReadFrom(decoder *fed.Decoder) (err error) {
+	(*T) = (*T)[:0]
+
+	for {
+		if decoder.Position() >= decoder.Length() {
+			break
+		}
+
+		(*T) = slices.Resize((*T), len((*T))+1)
+
+		*(*uint8)(&((*T)[len((*T))-1])), err = decoder.Uint8()
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+func (T *AuthenticationPayloadSASLFinal) WriteTo(encoder *fed.Encoder) (err error) {
+	for _, temp13 := range *T {
+		err = encoder.Uint8(uint8(temp13))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+type AuthenticationPayloadSSPI struct{}
+
+func (*AuthenticationPayloadSSPI) AuthenticationPayloadMode() int32 {
+	return 9
+}
+
+func (T *AuthenticationPayloadSSPI) Length() (length int) {
+
+	return
+}
+
+func (T *AuthenticationPayloadSSPI) ReadFrom(decoder *fed.Decoder) (err error) {
+
+	return
+}
+
+func (T *AuthenticationPayloadSSPI) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+type AuthenticationPayloadMode interface {
+	AuthenticationPayloadMode() int32
+
+	Length() int
+	ReadFrom(decoder *fed.Decoder) error
+	WriteTo(encoder *fed.Encoder) error
+}
+type AuthenticationPayload struct {
+	Mode AuthenticationPayloadMode
+}
+
+type Authentication AuthenticationPayload
+
+func (T *Authentication) Type() fed.Type {
+	return TypeAuthentication
+}
+
+func (T *Authentication) Length() (length int) {
+	length += 4
+
+	length += (*T).Mode.Length()
+
+	return
+}
+
+func (T *Authentication) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	var temp14 int32
+
+	*(*int32)(&(temp14)), err = decoder.Int32()
+	if err != nil {
+		return
+	}
+
+	switch temp14 {
+	case 3:
+		(*T).Mode = new(AuthenticationPayloadCleartextPassword)
+	case 7:
+		(*T).Mode = new(AuthenticationPayloadGSS)
+	case 8:
+		(*T).Mode = new(AuthenticationPayloadGSSContinue)
+	case 2:
+		(*T).Mode = new(AuthenticationPayloadKerberosV5)
+	case 5:
+		(*T).Mode = new(AuthenticationPayloadMD5Password)
+	case 0:
+		(*T).Mode = new(AuthenticationPayloadOk)
+	case 10:
+		(*T).Mode = new(AuthenticationPayloadSASL)
+	case 11:
+		(*T).Mode = new(AuthenticationPayloadSASLContinue)
+	case 12:
+		(*T).Mode = new(AuthenticationPayloadSASLFinal)
+	case 9:
+		(*T).Mode = new(AuthenticationPayloadSSPI)
+	default:
+		err = ErrInvalidFormat
+		return
+	}
+
+	err = (*T).Mode.ReadFrom(decoder)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (T *Authentication) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.Int32(int32((*T).Mode.AuthenticationPayloadMode()))
+	if err != nil {
+		return
+	}
+
+	err = (*T).Mode.WriteTo(encoder)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+var _ fed.Packet = (*Authentication)(nil)
+
+type BackendKeyDataPayload struct {
+	ProcessID int32
+	SecretKey int32
+}
+
+type BackendKeyData BackendKeyDataPayload
+
+func (T *BackendKeyData) Type() fed.Type {
+	return TypeBackendKeyData
+}
+
+func (T *BackendKeyData) Length() (length int) {
+	length += 4
+
+	length += 4
+
+	return
+}
+
+func (T *BackendKeyData) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*int32)(&((*T).ProcessID)), err = decoder.Int32()
+	if err != nil {
+		return
+	}
+	*(*int32)(&((*T).SecretKey)), err = decoder.Int32()
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (T *BackendKeyData) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.Int32(int32((*T).ProcessID))
+	if err != nil {
+		return
+	}
+
+	err = encoder.Int32(int32((*T).SecretKey))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+var _ fed.Packet = (*BackendKeyData)(nil)
+
+type BindPayload struct {
+	Destination       string
+	Source            string
+	FormatCodes       []int16
+	Parameters        [][]uint8
+	ResultFormatCodes []int16
+}
+
+type Bind BindPayload
+
+func (T *Bind) Type() fed.Type {
+	return TypeBind
+}
+
+func (T *Bind) Length() (length int) {
+	length += len((*T).Destination) + 1
+
+	length += len((*T).Source) + 1
+
+	temp15 := uint16(len((*T).FormatCodes))
+	_ = temp15
+
+	length += 2
+
+	for _, temp16 := range (*T).FormatCodes {
+		_ = temp16
+
+		length += 2
+
+	}
+
+	temp17 := uint16(len((*T).Parameters))
+	_ = temp17
+
+	length += 2
+
+	for _, temp18 := range (*T).Parameters {
+		_ = temp18
+
+		temp19 := int32(len(temp18))
+		_ = temp19
+
+		length += 4
+
+		for _, temp20 := range temp18 {
+			_ = temp20
+
+			length += 1
+
+		}
+
+	}
+
+	temp21 := uint16(len((*T).ResultFormatCodes))
+	_ = temp21
+
+	length += 2
+
+	for _, temp22 := range (*T).ResultFormatCodes {
+		_ = temp22
+
+		length += 2
+
+	}
+
+	return
+}
+
+func (T *Bind) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*string)(&((*T).Destination)), err = decoder.String()
+	if err != nil {
+		return
+	}
+	*(*string)(&((*T).Source)), err = decoder.String()
+	if err != nil {
+		return
+	}
+	var temp23 uint16
+	*(*uint16)(&(temp23)), err = decoder.Uint16()
+	if err != nil {
+		return
+	}
+
+	(*T).FormatCodes = slices.Resize((*T).FormatCodes, int(temp23))
+
+	for temp24 := 0; temp24 < int(temp23); temp24++ {
+		*(*int16)(&((*T).FormatCodes[temp24])), err = decoder.Int16()
+		if err != nil {
+			return
+		}
+
+	}
+
+	var temp25 uint16
+	*(*uint16)(&(temp25)), err = decoder.Uint16()
+	if err != nil {
+		return
+	}
+
+	(*T).Parameters = slices.Resize((*T).Parameters, int(temp25))
+
+	for temp26 := 0; temp26 < int(temp25); temp26++ {
+		var temp27 int32
+		*(*int32)(&(temp27)), err = decoder.Int32()
+		if err != nil {
+			return
+		}
+
+		if temp27 == -1 {
+			(*T).Parameters[temp26] = nil
+		} else {
+			(*T).Parameters[temp26] = slices.Resize((*T).Parameters[temp26], int(temp27))
+
+			for temp28 := 0; temp28 < int(temp27); temp28++ {
+				*(*uint8)(&((*T).Parameters[temp26][temp28])), err = decoder.Uint8()
+				if err != nil {
+					return
+				}
+
+			}
+		}
+
+	}
+
+	var temp29 uint16
+	*(*uint16)(&(temp29)), err = decoder.Uint16()
+	if err != nil {
+		return
+	}
+
+	(*T).ResultFormatCodes = slices.Resize((*T).ResultFormatCodes, int(temp29))
+
+	for temp30 := 0; temp30 < int(temp29); temp30++ {
+		*(*int16)(&((*T).ResultFormatCodes[temp30])), err = decoder.Int16()
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+func (T *Bind) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.String(string((*T).Destination))
+	if err != nil {
+		return
+	}
+
+	err = encoder.String(string((*T).Source))
+	if err != nil {
+		return
+	}
+
+	temp31 := uint16(len((*T).FormatCodes))
+
+	err = encoder.Uint16(uint16(temp31))
+	if err != nil {
+		return
+	}
+
+	for _, temp32 := range (*T).FormatCodes {
+		err = encoder.Int16(int16(temp32))
+		if err != nil {
+			return
+		}
+
+	}
+
+	temp33 := uint16(len((*T).Parameters))
+
+	err = encoder.Uint16(uint16(temp33))
+	if err != nil {
+		return
+	}
+
+	for _, temp34 := range (*T).Parameters {
+		temp35 := int32(len(temp34))
+
+		if temp34 == nil {
+			temp35 = -1
+		}
+
+		err = encoder.Int32(int32(temp35))
+		if err != nil {
+			return
+		}
+
+		for _, temp36 := range temp34 {
+			err = encoder.Uint8(uint8(temp36))
+			if err != nil {
+				return
+			}
+
+		}
+
+	}
+
+	temp37 := uint16(len((*T).ResultFormatCodes))
+
+	err = encoder.Uint16(uint16(temp37))
+	if err != nil {
+		return
+	}
+
+	for _, temp38 := range (*T).ResultFormatCodes {
+		err = encoder.Int16(int16(temp38))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+var _ fed.Packet = (*Bind)(nil)
+
+type BindComplete struct{}
+
+func (T *BindComplete) Type() fed.Type {
+	return TypeBindComplete
+}
+
+func (T *BindComplete) Length() (length int) {
+
+	return
+}
+
+func (T *BindComplete) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	return
+}
+
+func (T *BindComplete) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+var _ fed.Packet = (*BindComplete)(nil)
+
+type ClosePayload struct {
+	Which uint8
+	Name  string
+}
+
+type Close ClosePayload
+
+func (T *Close) Type() fed.Type {
+	return TypeClose
+}
+
+func (T *Close) Length() (length int) {
+	length += 1
+
+	length += len((*T).Name) + 1
+
+	return
+}
+
+func (T *Close) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*uint8)(&((*T).Which)), err = decoder.Uint8()
+	if err != nil {
+		return
+	}
+	*(*string)(&((*T).Name)), err = decoder.String()
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (T *Close) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.Uint8(uint8((*T).Which))
+	if err != nil {
+		return
+	}
+
+	err = encoder.String(string((*T).Name))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+var _ fed.Packet = (*Close)(nil)
+
+type CloseComplete struct{}
+
+func (T *CloseComplete) Type() fed.Type {
+	return TypeCloseComplete
+}
+
+func (T *CloseComplete) Length() (length int) {
+
+	return
+}
+
+func (T *CloseComplete) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	return
+}
+
+func (T *CloseComplete) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+var _ fed.Packet = (*CloseComplete)(nil)
+
+type CommandComplete string
+
+func (T *CommandComplete) Type() fed.Type {
+	return TypeCommandComplete
+}
+
+func (T *CommandComplete) Length() (length int) {
+	length += len((*T)) + 1
+
+	return
+}
+
+func (T *CommandComplete) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*string)(&(*T)), err = decoder.String()
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (T *CommandComplete) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.String(string((*T)))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+var _ fed.Packet = (*CommandComplete)(nil)
+
+type CopyBothResponsePayload struct {
+	Mode              int8
+	ColumnFormatCodes []int16
+}
+
+type CopyBothResponse CopyBothResponsePayload
+
+func (T *CopyBothResponse) Type() fed.Type {
+	return TypeCopyBothResponse
+}
+
+func (T *CopyBothResponse) Length() (length int) {
+	length += 1
+
+	temp39 := uint16(len((*T).ColumnFormatCodes))
+	_ = temp39
+
+	length += 2
+
+	for _, temp40 := range (*T).ColumnFormatCodes {
+		_ = temp40
+
+		length += 2
+
+	}
+
+	return
+}
+
+func (T *CopyBothResponse) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*int8)(&((*T).Mode)), err = decoder.Int8()
+	if err != nil {
+		return
+	}
+	var temp41 uint16
+	*(*uint16)(&(temp41)), err = decoder.Uint16()
+	if err != nil {
+		return
+	}
+
+	(*T).ColumnFormatCodes = slices.Resize((*T).ColumnFormatCodes, int(temp41))
+
+	for temp42 := 0; temp42 < int(temp41); temp42++ {
+		*(*int16)(&((*T).ColumnFormatCodes[temp42])), err = decoder.Int16()
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+func (T *CopyBothResponse) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.Int8(int8((*T).Mode))
+	if err != nil {
+		return
+	}
+
+	temp43 := uint16(len((*T).ColumnFormatCodes))
+
+	err = encoder.Uint16(uint16(temp43))
+	if err != nil {
+		return
+	}
+
+	for _, temp44 := range (*T).ColumnFormatCodes {
+		err = encoder.Int16(int16(temp44))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+var _ fed.Packet = (*CopyBothResponse)(nil)
+
+type CopyData []uint8
+
+func (T *CopyData) Type() fed.Type {
+	return TypeCopyData
+}
+
+func (T *CopyData) Length() (length int) {
+	for _, temp45 := range *T {
+		_ = temp45
+
+		length += 1
+
+	}
+
+	return
+}
+
+func (T *CopyData) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	(*T) = (*T)[:0]
+
+	for {
+		if decoder.Position() >= decoder.Length() {
+			break
+		}
+
+		(*T) = slices.Resize((*T), len((*T))+1)
+
+		*(*uint8)(&((*T)[len((*T))-1])), err = decoder.Uint8()
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+func (T *CopyData) WriteTo(encoder *fed.Encoder) (err error) {
+	for _, temp46 := range *T {
+		err = encoder.Uint8(uint8(temp46))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+var _ fed.Packet = (*CopyData)(nil)
+
+type CopyDone struct{}
+
+func (T *CopyDone) Type() fed.Type {
+	return TypeCopyDone
+}
+
+func (T *CopyDone) Length() (length int) {
+
+	return
+}
+
+func (T *CopyDone) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	return
+}
+
+func (T *CopyDone) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+var _ fed.Packet = (*CopyDone)(nil)
+
+type CopyFail string
+
+func (T *CopyFail) Type() fed.Type {
+	return TypeCopyFail
+}
+
+func (T *CopyFail) Length() (length int) {
+	length += len((*T)) + 1
+
+	return
+}
+
+func (T *CopyFail) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*string)(&(*T)), err = decoder.String()
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (T *CopyFail) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.String(string((*T)))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+var _ fed.Packet = (*CopyFail)(nil)
+
+type CopyInResponsePayload struct {
+	Mode              int8
+	ColumnFormatCodes []int16
+}
+
+type CopyInResponse CopyInResponsePayload
+
+func (T *CopyInResponse) Type() fed.Type {
+	return TypeCopyInResponse
+}
+
+func (T *CopyInResponse) Length() (length int) {
+	length += 1
+
+	temp47 := uint16(len((*T).ColumnFormatCodes))
+	_ = temp47
+
+	length += 2
+
+	for _, temp48 := range (*T).ColumnFormatCodes {
+		_ = temp48
+
+		length += 2
+
+	}
+
+	return
+}
+
+func (T *CopyInResponse) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*int8)(&((*T).Mode)), err = decoder.Int8()
+	if err != nil {
+		return
+	}
+	var temp49 uint16
+	*(*uint16)(&(temp49)), err = decoder.Uint16()
+	if err != nil {
+		return
+	}
+
+	(*T).ColumnFormatCodes = slices.Resize((*T).ColumnFormatCodes, int(temp49))
+
+	for temp50 := 0; temp50 < int(temp49); temp50++ {
+		*(*int16)(&((*T).ColumnFormatCodes[temp50])), err = decoder.Int16()
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+func (T *CopyInResponse) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.Int8(int8((*T).Mode))
+	if err != nil {
+		return
+	}
+
+	temp51 := uint16(len((*T).ColumnFormatCodes))
+
+	err = encoder.Uint16(uint16(temp51))
+	if err != nil {
+		return
+	}
+
+	for _, temp52 := range (*T).ColumnFormatCodes {
+		err = encoder.Int16(int16(temp52))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+var _ fed.Packet = (*CopyInResponse)(nil)
+
+type CopyOutResponsePayload struct {
+	Mode              int8
+	ColumnFormatCodes []int16
+}
+
+type CopyOutResponse CopyOutResponsePayload
+
+func (T *CopyOutResponse) Type() fed.Type {
+	return TypeCopyOutResponse
+}
+
+func (T *CopyOutResponse) Length() (length int) {
+	length += 1
+
+	temp53 := uint16(len((*T).ColumnFormatCodes))
+	_ = temp53
+
+	length += 2
+
+	for _, temp54 := range (*T).ColumnFormatCodes {
+		_ = temp54
+
+		length += 2
+
+	}
+
+	return
+}
+
+func (T *CopyOutResponse) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*int8)(&((*T).Mode)), err = decoder.Int8()
+	if err != nil {
+		return
+	}
+	var temp55 uint16
+	*(*uint16)(&(temp55)), err = decoder.Uint16()
+	if err != nil {
+		return
+	}
+
+	(*T).ColumnFormatCodes = slices.Resize((*T).ColumnFormatCodes, int(temp55))
+
+	for temp56 := 0; temp56 < int(temp55); temp56++ {
+		*(*int16)(&((*T).ColumnFormatCodes[temp56])), err = decoder.Int16()
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+func (T *CopyOutResponse) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.Int8(int8((*T).Mode))
+	if err != nil {
+		return
+	}
+
+	temp57 := uint16(len((*T).ColumnFormatCodes))
+
+	err = encoder.Uint16(uint16(temp57))
+	if err != nil {
+		return
+	}
+
+	for _, temp58 := range (*T).ColumnFormatCodes {
+		err = encoder.Int16(int16(temp58))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+var _ fed.Packet = (*CopyOutResponse)(nil)
+
+type DataRow [][]uint8
+
+func (T *DataRow) Type() fed.Type {
+	return TypeDataRow
+}
+
+func (T *DataRow) Length() (length int) {
+	temp59 := uint16(len((*T)))
+	_ = temp59
+
+	length += 2
+
+	for _, temp60 := range *T {
+		_ = temp60
+
+		temp61 := int32(len(temp60))
+		_ = temp61
+
+		length += 4
+
+		for _, temp62 := range temp60 {
+			_ = temp62
+
+			length += 1
+
+		}
+
+	}
+
+	return
+}
+
+func (T *DataRow) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	var temp63 uint16
+	*(*uint16)(&(temp63)), err = decoder.Uint16()
+	if err != nil {
+		return
+	}
+
+	(*T) = slices.Resize((*T), int(temp63))
+
+	for temp64 := 0; temp64 < int(temp63); temp64++ {
+		var temp65 int32
+		*(*int32)(&(temp65)), err = decoder.Int32()
+		if err != nil {
+			return
+		}
+
+		if temp65 == -1 {
+			(*T)[temp64] = nil
+		} else {
+			(*T)[temp64] = slices.Resize((*T)[temp64], int(temp65))
+
+			for temp66 := 0; temp66 < int(temp65); temp66++ {
+				*(*uint8)(&((*T)[temp64][temp66])), err = decoder.Uint8()
+				if err != nil {
+					return
+				}
+
+			}
+		}
+
+	}
+
+	return
+}
+
+func (T *DataRow) WriteTo(encoder *fed.Encoder) (err error) {
+	temp67 := uint16(len((*T)))
+
+	err = encoder.Uint16(uint16(temp67))
+	if err != nil {
+		return
+	}
+
+	for _, temp68 := range *T {
+		temp69 := int32(len(temp68))
+
+		if temp68 == nil {
+			temp69 = -1
+		}
+
+		err = encoder.Int32(int32(temp69))
+		if err != nil {
+			return
+		}
+
+		for _, temp70 := range temp68 {
+			err = encoder.Uint8(uint8(temp70))
+			if err != nil {
+				return
+			}
+
+		}
+
+	}
+
+	return
+}
+
+var _ fed.Packet = (*DataRow)(nil)
+
+type DescribePayload struct {
+	Which uint8
+	Name  string
+}
+
+type Describe DescribePayload
+
+func (T *Describe) Type() fed.Type {
+	return TypeDescribe
+}
+
+func (T *Describe) Length() (length int) {
+	length += 1
+
+	length += len((*T).Name) + 1
+
+	return
+}
+
+func (T *Describe) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*uint8)(&((*T).Which)), err = decoder.Uint8()
+	if err != nil {
+		return
+	}
+	*(*string)(&((*T).Name)), err = decoder.String()
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (T *Describe) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.Uint8(uint8((*T).Which))
+	if err != nil {
+		return
+	}
+
+	err = encoder.String(string((*T).Name))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+var _ fed.Packet = (*Describe)(nil)
+
+type EmptyQueryResponse struct{}
+
+func (T *EmptyQueryResponse) Type() fed.Type {
+	return TypeEmptyQueryResponse
+}
+
+func (T *EmptyQueryResponse) Length() (length int) {
+
+	return
+}
+
+func (T *EmptyQueryResponse) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	return
+}
+
+func (T *EmptyQueryResponse) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+var _ fed.Packet = (*EmptyQueryResponse)(nil)
+
+type ErrorResponseField struct {
+	Code  uint8
+	Value string
+}
+
+type ErrorResponse []ErrorResponseField
+
+func (T *ErrorResponse) Type() fed.Type {
+	return TypeErrorResponse
+}
+
+func (T *ErrorResponse) Length() (length int) {
+	for _, temp71 := range *T {
+		_ = temp71
+
+		length += 1
+
+		length += len(temp71.Value) + 1
+
+	}
+
+	var temp72 uint8
+	_ = temp72
+
+	length += 1
+
+	return
+}
+
+func (T *ErrorResponse) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	(*T) = (*T)[:0]
+
+	for {
+		(*T) = slices.Resize((*T), len((*T))+1)
+
+		*(*uint8)(&((*T)[len((*T))-1].Code)), err = decoder.Uint8()
+		if err != nil {
+			return
+		}
+		if (*T)[len((*T))-1].Code == *new(uint8) {
+			(*T) = (*T)[:len((*T))-1]
+			break
+		}
+		*(*string)(&((*T)[len((*T))-1].Value)), err = decoder.String()
+		if err != nil {
+			return
+		}
+	}
+
+	return
+}
+
+func (T *ErrorResponse) WriteTo(encoder *fed.Encoder) (err error) {
+	for _, temp73 := range *T {
+		err = encoder.Uint8(uint8(temp73.Code))
+		if err != nil {
+			return
+		}
+
+		err = encoder.String(string(temp73.Value))
+		if err != nil {
+			return
+		}
+
+	}
+
+	var temp74 uint8
+
+	err = encoder.Uint8(uint8(temp74))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+var _ fed.Packet = (*ErrorResponse)(nil)
+
+type ExecutePayload struct {
+	Target  string
+	MaxRows uint32
+}
+
+type Execute ExecutePayload
+
+func (T *Execute) Type() fed.Type {
+	return TypeExecute
+}
+
+func (T *Execute) Length() (length int) {
+	length += len((*T).Target) + 1
+
+	length += 4
+
+	return
+}
+
+func (T *Execute) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*string)(&((*T).Target)), err = decoder.String()
+	if err != nil {
+		return
+	}
+	*(*uint32)(&((*T).MaxRows)), err = decoder.Uint32()
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (T *Execute) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.String(string((*T).Target))
+	if err != nil {
+		return
+	}
+
+	err = encoder.Uint32(uint32((*T).MaxRows))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+var _ fed.Packet = (*Execute)(nil)
+
+type Flush struct{}
+
+func (T *Flush) Type() fed.Type {
+	return TypeFlush
+}
+
+func (T *Flush) Length() (length int) {
+
+	return
+}
+
+func (T *Flush) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	return
+}
+
+func (T *Flush) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+var _ fed.Packet = (*Flush)(nil)
+
+type FunctionCallPayload struct {
+	ObjectID            int32
+	ArgumentFormatCodes []int16
+	Arguments           [][]uint8
+	ResultFormatCode    int16
+}
+
+type FunctionCall FunctionCallPayload
+
+func (T *FunctionCall) Type() fed.Type {
+	return TypeFunctionCall
+}
+
+func (T *FunctionCall) Length() (length int) {
+	length += 4
+
+	temp75 := uint16(len((*T).ArgumentFormatCodes))
+	_ = temp75
+
+	length += 2
+
+	for _, temp76 := range (*T).ArgumentFormatCodes {
+		_ = temp76
+
+		length += 2
+
+	}
+
+	temp77 := uint16(len((*T).Arguments))
+	_ = temp77
+
+	length += 2
+
+	for _, temp78 := range (*T).Arguments {
+		_ = temp78
+
+		temp79 := int32(len(temp78))
+		_ = temp79
+
+		length += 4
+
+		for _, temp80 := range temp78 {
+			_ = temp80
+
+			length += 1
+
+		}
+
+	}
+
+	length += 2
+
+	return
+}
+
+func (T *FunctionCall) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*int32)(&((*T).ObjectID)), err = decoder.Int32()
+	if err != nil {
+		return
+	}
+	var temp81 uint16
+	*(*uint16)(&(temp81)), err = decoder.Uint16()
+	if err != nil {
+		return
+	}
+
+	(*T).ArgumentFormatCodes = slices.Resize((*T).ArgumentFormatCodes, int(temp81))
+
+	for temp82 := 0; temp82 < int(temp81); temp82++ {
+		*(*int16)(&((*T).ArgumentFormatCodes[temp82])), err = decoder.Int16()
+		if err != nil {
+			return
+		}
+
+	}
+
+	var temp83 uint16
+	*(*uint16)(&(temp83)), err = decoder.Uint16()
+	if err != nil {
+		return
+	}
+
+	(*T).Arguments = slices.Resize((*T).Arguments, int(temp83))
+
+	for temp84 := 0; temp84 < int(temp83); temp84++ {
+		var temp85 int32
+		*(*int32)(&(temp85)), err = decoder.Int32()
+		if err != nil {
+			return
+		}
+
+		if temp85 == -1 {
+			(*T).Arguments[temp84] = nil
+		} else {
+			(*T).Arguments[temp84] = slices.Resize((*T).Arguments[temp84], int(temp85))
+
+			for temp86 := 0; temp86 < int(temp85); temp86++ {
+				*(*uint8)(&((*T).Arguments[temp84][temp86])), err = decoder.Uint8()
+				if err != nil {
+					return
+				}
+
+			}
+		}
+
+	}
+
+	*(*int16)(&((*T).ResultFormatCode)), err = decoder.Int16()
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (T *FunctionCall) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.Int32(int32((*T).ObjectID))
+	if err != nil {
+		return
+	}
+
+	temp87 := uint16(len((*T).ArgumentFormatCodes))
+
+	err = encoder.Uint16(uint16(temp87))
+	if err != nil {
+		return
+	}
+
+	for _, temp88 := range (*T).ArgumentFormatCodes {
+		err = encoder.Int16(int16(temp88))
+		if err != nil {
+			return
+		}
+
+	}
+
+	temp89 := uint16(len((*T).Arguments))
+
+	err = encoder.Uint16(uint16(temp89))
+	if err != nil {
+		return
+	}
+
+	for _, temp90 := range (*T).Arguments {
+		temp91 := int32(len(temp90))
+
+		if temp90 == nil {
+			temp91 = -1
+		}
+
+		err = encoder.Int32(int32(temp91))
+		if err != nil {
+			return
+		}
+
+		for _, temp92 := range temp90 {
+			err = encoder.Uint8(uint8(temp92))
+			if err != nil {
+				return
+			}
+
+		}
+
+	}
+
+	err = encoder.Int16(int16((*T).ResultFormatCode))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+var _ fed.Packet = (*FunctionCall)(nil)
+
+type FunctionCallResponse []uint8
+
+func (T *FunctionCallResponse) Type() fed.Type {
+	return TypeFunctionCallResponse
+}
+
+func (T *FunctionCallResponse) Length() (length int) {
+	temp93 := int32(len((*T)))
+	_ = temp93
+
+	length += 4
+
+	for _, temp94 := range *T {
+		_ = temp94
+
+		length += 1
+
+	}
+
+	return
+}
+
+func (T *FunctionCallResponse) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	var temp95 int32
+	*(*int32)(&(temp95)), err = decoder.Int32()
+	if err != nil {
+		return
+	}
+
+	if temp95 == -1 {
+		(*T) = nil
+	} else {
+		(*T) = slices.Resize((*T), int(temp95))
+
+		for temp96 := 0; temp96 < int(temp95); temp96++ {
+			*(*uint8)(&((*T)[temp96])), err = decoder.Uint8()
+			if err != nil {
+				return
+			}
+
+		}
+	}
+
+	return
+}
+
+func (T *FunctionCallResponse) WriteTo(encoder *fed.Encoder) (err error) {
+	temp97 := int32(len((*T)))
+
+	if (*T) == nil {
+		temp97 = -1
+	}
+
+	err = encoder.Int32(int32(temp97))
+	if err != nil {
+		return
+	}
+
+	for _, temp98 := range *T {
+		err = encoder.Uint8(uint8(temp98))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+var _ fed.Packet = (*FunctionCallResponse)(nil)
+
+type GSSResponse []uint8
+
+func (T *GSSResponse) Type() fed.Type {
+	return TypeGSSResponse
+}
+
+func (T *GSSResponse) Length() (length int) {
+	for _, temp99 := range *T {
+		_ = temp99
+
+		length += 1
+
+	}
+
+	return
+}
+
+func (T *GSSResponse) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	(*T) = (*T)[:0]
+
+	for {
+		if decoder.Position() >= decoder.Length() {
+			break
+		}
+
+		(*T) = slices.Resize((*T), len((*T))+1)
+
+		*(*uint8)(&((*T)[len((*T))-1])), err = decoder.Uint8()
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+func (T *GSSResponse) WriteTo(encoder *fed.Encoder) (err error) {
+	for _, temp100 := range *T {
+		err = encoder.Uint8(uint8(temp100))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+var _ fed.Packet = (*GSSResponse)(nil)
+
+type NegotiateProtocolVersionPayload struct {
+	MinorProtocolVersion        int32
+	UnrecognizedProtocolOptions []string
+}
+
+type NegotiateProtocolVersion NegotiateProtocolVersionPayload
+
+func (T *NegotiateProtocolVersion) Type() fed.Type {
+	return TypeNegotiateProtocolVersion
+}
+
+func (T *NegotiateProtocolVersion) Length() (length int) {
+	length += 4
+
+	temp101 := uint32(len((*T).UnrecognizedProtocolOptions))
+	_ = temp101
+
+	length += 4
+
+	for _, temp102 := range (*T).UnrecognizedProtocolOptions {
+		_ = temp102
+
+		length += len(temp102) + 1
+
+	}
+
+	return
+}
+
+func (T *NegotiateProtocolVersion) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*int32)(&((*T).MinorProtocolVersion)), err = decoder.Int32()
+	if err != nil {
+		return
+	}
+	var temp103 uint32
+	*(*uint32)(&(temp103)), err = decoder.Uint32()
+	if err != nil {
+		return
+	}
+
+	(*T).UnrecognizedProtocolOptions = slices.Resize((*T).UnrecognizedProtocolOptions, int(temp103))
+
+	for temp104 := 0; temp104 < int(temp103); temp104++ {
+		*(*string)(&((*T).UnrecognizedProtocolOptions[temp104])), err = decoder.String()
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+func (T *NegotiateProtocolVersion) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.Int32(int32((*T).MinorProtocolVersion))
+	if err != nil {
+		return
+	}
+
+	temp105 := uint32(len((*T).UnrecognizedProtocolOptions))
+
+	err = encoder.Uint32(uint32(temp105))
+	if err != nil {
+		return
+	}
+
+	for _, temp106 := range (*T).UnrecognizedProtocolOptions {
+		err = encoder.String(string(temp106))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+var _ fed.Packet = (*NegotiateProtocolVersion)(nil)
+
+type NoData struct{}
+
+func (T *NoData) Type() fed.Type {
+	return TypeNoData
+}
+
+func (T *NoData) Length() (length int) {
+
+	return
+}
+
+func (T *NoData) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	return
+}
+
+func (T *NoData) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+var _ fed.Packet = (*NoData)(nil)
+
+type NoticeResponseField struct {
+	Code  uint8
+	Value string
+}
+
+type NoticeResponse []NoticeResponseField
+
+func (T *NoticeResponse) Type() fed.Type {
+	return TypeNoticeResponse
+}
+
+func (T *NoticeResponse) Length() (length int) {
+	for _, temp107 := range *T {
+		_ = temp107
+
+		length += 1
+
+		length += len(temp107.Value) + 1
+
+	}
+
+	var temp108 uint8
+	_ = temp108
+
+	length += 1
+
+	return
+}
+
+func (T *NoticeResponse) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	(*T) = (*T)[:0]
+
+	for {
+		(*T) = slices.Resize((*T), len((*T))+1)
+
+		*(*uint8)(&((*T)[len((*T))-1].Code)), err = decoder.Uint8()
+		if err != nil {
+			return
+		}
+		if (*T)[len((*T))-1].Code == *new(uint8) {
+			(*T) = (*T)[:len((*T))-1]
+			break
+		}
+		*(*string)(&((*T)[len((*T))-1].Value)), err = decoder.String()
+		if err != nil {
+			return
+		}
+	}
+
+	return
+}
+
+func (T *NoticeResponse) WriteTo(encoder *fed.Encoder) (err error) {
+	for _, temp109 := range *T {
+		err = encoder.Uint8(uint8(temp109.Code))
+		if err != nil {
+			return
+		}
+
+		err = encoder.String(string(temp109.Value))
+		if err != nil {
+			return
+		}
+
+	}
+
+	var temp110 uint8
+
+	err = encoder.Uint8(uint8(temp110))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+var _ fed.Packet = (*NoticeResponse)(nil)
+
+type NotificationResponsePayload struct {
+	ProcessID int32
+	Channel   string
+	Payload   string
+}
+
+type NotificationResponse NotificationResponsePayload
+
+func (T *NotificationResponse) Type() fed.Type {
+	return TypeNotificationResponse
+}
+
+func (T *NotificationResponse) Length() (length int) {
+	length += 4
+
+	length += len((*T).Channel) + 1
+
+	length += len((*T).Payload) + 1
+
+	return
+}
+
+func (T *NotificationResponse) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*int32)(&((*T).ProcessID)), err = decoder.Int32()
+	if err != nil {
+		return
+	}
+	*(*string)(&((*T).Channel)), err = decoder.String()
+	if err != nil {
+		return
+	}
+	*(*string)(&((*T).Payload)), err = decoder.String()
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (T *NotificationResponse) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.Int32(int32((*T).ProcessID))
+	if err != nil {
+		return
+	}
+
+	err = encoder.String(string((*T).Channel))
+	if err != nil {
+		return
+	}
+
+	err = encoder.String(string((*T).Payload))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+var _ fed.Packet = (*NotificationResponse)(nil)
+
+type ParameterDescription []int32
+
+func (T *ParameterDescription) Type() fed.Type {
+	return TypeParameterDescription
+}
+
+func (T *ParameterDescription) Length() (length int) {
+	temp111 := uint16(len((*T)))
+	_ = temp111
+
+	length += 2
+
+	for _, temp112 := range *T {
+		_ = temp112
+
+		length += 4
+
+	}
+
+	return
+}
+
+func (T *ParameterDescription) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	var temp113 uint16
+	*(*uint16)(&(temp113)), err = decoder.Uint16()
+	if err != nil {
+		return
+	}
+
+	(*T) = slices.Resize((*T), int(temp113))
+
+	for temp114 := 0; temp114 < int(temp113); temp114++ {
+		*(*int32)(&((*T)[temp114])), err = decoder.Int32()
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+func (T *ParameterDescription) WriteTo(encoder *fed.Encoder) (err error) {
+	temp115 := uint16(len((*T)))
+
+	err = encoder.Uint16(uint16(temp115))
+	if err != nil {
+		return
+	}
+
+	for _, temp116 := range *T {
+		err = encoder.Int32(int32(temp116))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+var _ fed.Packet = (*ParameterDescription)(nil)
+
+type ParameterStatusPayload struct {
+	Key   string
+	Value string
+}
+
+type ParameterStatus ParameterStatusPayload
+
+func (T *ParameterStatus) Type() fed.Type {
+	return TypeParameterStatus
+}
+
+func (T *ParameterStatus) Length() (length int) {
+	length += len((*T).Key) + 1
+
+	length += len((*T).Value) + 1
+
+	return
+}
+
+func (T *ParameterStatus) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*string)(&((*T).Key)), err = decoder.String()
+	if err != nil {
+		return
+	}
+	*(*string)(&((*T).Value)), err = decoder.String()
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (T *ParameterStatus) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.String(string((*T).Key))
+	if err != nil {
+		return
+	}
+
+	err = encoder.String(string((*T).Value))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+var _ fed.Packet = (*ParameterStatus)(nil)
+
+type ParsePayload struct {
+	Destination        string
+	Query              string
+	ParameterDataTypes []int32
+}
+
+type Parse ParsePayload
+
+func (T *Parse) Type() fed.Type {
+	return TypeParse
+}
+
+func (T *Parse) Length() (length int) {
+	length += len((*T).Destination) + 1
+
+	length += len((*T).Query) + 1
+
+	temp117 := uint16(len((*T).ParameterDataTypes))
+	_ = temp117
+
+	length += 2
+
+	for _, temp118 := range (*T).ParameterDataTypes {
+		_ = temp118
+
+		length += 4
+
+	}
+
+	return
+}
+
+func (T *Parse) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*string)(&((*T).Destination)), err = decoder.String()
+	if err != nil {
+		return
+	}
+	*(*string)(&((*T).Query)), err = decoder.String()
+	if err != nil {
+		return
+	}
+	var temp119 uint16
+	*(*uint16)(&(temp119)), err = decoder.Uint16()
+	if err != nil {
+		return
+	}
+
+	(*T).ParameterDataTypes = slices.Resize((*T).ParameterDataTypes, int(temp119))
+
+	for temp120 := 0; temp120 < int(temp119); temp120++ {
+		*(*int32)(&((*T).ParameterDataTypes[temp120])), err = decoder.Int32()
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+func (T *Parse) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.String(string((*T).Destination))
+	if err != nil {
+		return
+	}
+
+	err = encoder.String(string((*T).Query))
+	if err != nil {
+		return
+	}
+
+	temp121 := uint16(len((*T).ParameterDataTypes))
+
+	err = encoder.Uint16(uint16(temp121))
+	if err != nil {
+		return
+	}
+
+	for _, temp122 := range (*T).ParameterDataTypes {
+		err = encoder.Int32(int32(temp122))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+var _ fed.Packet = (*Parse)(nil)
+
+type ParseComplete struct{}
+
+func (T *ParseComplete) Type() fed.Type {
+	return TypeParseComplete
+}
+
+func (T *ParseComplete) Length() (length int) {
+
+	return
+}
+
+func (T *ParseComplete) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	return
+}
+
+func (T *ParseComplete) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+var _ fed.Packet = (*ParseComplete)(nil)
+
+type PasswordMessage string
+
+func (T *PasswordMessage) Type() fed.Type {
+	return TypePasswordMessage
+}
+
+func (T *PasswordMessage) Length() (length int) {
+	length += len((*T)) + 1
+
+	return
+}
+
+func (T *PasswordMessage) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*string)(&(*T)), err = decoder.String()
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (T *PasswordMessage) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.String(string((*T)))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+var _ fed.Packet = (*PasswordMessage)(nil)
+
+type PortalSuspended struct{}
+
+func (T *PortalSuspended) Type() fed.Type {
+	return TypePortalSuspended
+}
+
+func (T *PortalSuspended) Length() (length int) {
+
+	return
+}
+
+func (T *PortalSuspended) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	return
+}
+
+func (T *PortalSuspended) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+var _ fed.Packet = (*PortalSuspended)(nil)
+
+type Query string
+
+func (T *Query) Type() fed.Type {
+	return TypeQuery
+}
+
+func (T *Query) Length() (length int) {
+	length += len((*T)) + 1
+
+	return
+}
+
+func (T *Query) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*string)(&(*T)), err = decoder.String()
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (T *Query) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.String(string((*T)))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+var _ fed.Packet = (*Query)(nil)
+
+type ReadyForQuery uint8
+
+func (T *ReadyForQuery) Type() fed.Type {
+	return TypeReadyForQuery
+}
+
+func (T *ReadyForQuery) Length() (length int) {
+	length += 1
+
+	return
+}
+
+func (T *ReadyForQuery) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*uint8)(&(*T)), err = decoder.Uint8()
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (T *ReadyForQuery) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.Uint8(uint8((*T)))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+var _ fed.Packet = (*ReadyForQuery)(nil)
+
+type RowDescriptionRow struct {
+	Name                  string
+	TableID               int32
+	ColumnAttributeNumber int16
+	FieldDataType         int32
+	DataTypeSize          int16
+	TypeModifier          int32
+	FormatCode            int16
+}
+
+type RowDescription []RowDescriptionRow
+
+func (T *RowDescription) Type() fed.Type {
+	return TypeRowDescription
+}
+
+func (T *RowDescription) Length() (length int) {
+	temp123 := uint16(len((*T)))
+	_ = temp123
+
+	length += 2
+
+	for _, temp124 := range *T {
+		_ = temp124
+
+		length += len(temp124.Name) + 1
+
+		length += 4
+
+		length += 2
+
+		length += 4
+
+		length += 2
+
+		length += 4
+
+		length += 2
+
+	}
+
+	return
+}
+
+func (T *RowDescription) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	var temp125 uint16
+	*(*uint16)(&(temp125)), err = decoder.Uint16()
+	if err != nil {
+		return
+	}
+
+	(*T) = slices.Resize((*T), int(temp125))
+
+	for temp126 := 0; temp126 < int(temp125); temp126++ {
+		*(*string)(&((*T)[temp126].Name)), err = decoder.String()
+		if err != nil {
+			return
+		}
+		*(*int32)(&((*T)[temp126].TableID)), err = decoder.Int32()
+		if err != nil {
+			return
+		}
+		*(*int16)(&((*T)[temp126].ColumnAttributeNumber)), err = decoder.Int16()
+		if err != nil {
+			return
+		}
+		*(*int32)(&((*T)[temp126].FieldDataType)), err = decoder.Int32()
+		if err != nil {
+			return
+		}
+		*(*int16)(&((*T)[temp126].DataTypeSize)), err = decoder.Int16()
+		if err != nil {
+			return
+		}
+		*(*int32)(&((*T)[temp126].TypeModifier)), err = decoder.Int32()
+		if err != nil {
+			return
+		}
+		*(*int16)(&((*T)[temp126].FormatCode)), err = decoder.Int16()
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+func (T *RowDescription) WriteTo(encoder *fed.Encoder) (err error) {
+	temp127 := uint16(len((*T)))
+
+	err = encoder.Uint16(uint16(temp127))
+	if err != nil {
+		return
+	}
+
+	for _, temp128 := range *T {
+		err = encoder.String(string(temp128.Name))
+		if err != nil {
+			return
+		}
+
+		err = encoder.Int32(int32(temp128.TableID))
+		if err != nil {
+			return
+		}
+
+		err = encoder.Int16(int16(temp128.ColumnAttributeNumber))
+		if err != nil {
+			return
+		}
+
+		err = encoder.Int32(int32(temp128.FieldDataType))
+		if err != nil {
+			return
+		}
+
+		err = encoder.Int16(int16(temp128.DataTypeSize))
+		if err != nil {
+			return
+		}
+
+		err = encoder.Int32(int32(temp128.TypeModifier))
+		if err != nil {
+			return
+		}
+
+		err = encoder.Int16(int16(temp128.FormatCode))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+var _ fed.Packet = (*RowDescription)(nil)
+
+type SASLInitialResponsePayload struct {
+	Mechanism             string
+	InitialClientResponse []uint8
+}
+
+type SASLInitialResponse SASLInitialResponsePayload
+
+func (T *SASLInitialResponse) Type() fed.Type {
+	return TypeSASLInitialResponse
+}
+
+func (T *SASLInitialResponse) Length() (length int) {
+	length += len((*T).Mechanism) + 1
+
+	temp129 := int32(len((*T).InitialClientResponse))
+	_ = temp129
+
+	length += 4
+
+	for _, temp130 := range (*T).InitialClientResponse {
+		_ = temp130
+
+		length += 1
+
+	}
+
+	return
+}
+
+func (T *SASLInitialResponse) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	*(*string)(&((*T).Mechanism)), err = decoder.String()
+	if err != nil {
+		return
+	}
+	var temp131 int32
+	*(*int32)(&(temp131)), err = decoder.Int32()
+	if err != nil {
+		return
+	}
+
+	if temp131 == -1 {
+		(*T).InitialClientResponse = nil
+	} else {
+		(*T).InitialClientResponse = slices.Resize((*T).InitialClientResponse, int(temp131))
+
+		for temp132 := 0; temp132 < int(temp131); temp132++ {
+			*(*uint8)(&((*T).InitialClientResponse[temp132])), err = decoder.Uint8()
+			if err != nil {
+				return
+			}
+
+		}
+	}
+
+	return
+}
+
+func (T *SASLInitialResponse) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.String(string((*T).Mechanism))
+	if err != nil {
+		return
+	}
+
+	temp133 := int32(len((*T).InitialClientResponse))
+
+	if (*T).InitialClientResponse == nil {
+		temp133 = -1
+	}
+
+	err = encoder.Int32(int32(temp133))
+	if err != nil {
+		return
+	}
+
+	for _, temp134 := range (*T).InitialClientResponse {
+		err = encoder.Uint8(uint8(temp134))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+var _ fed.Packet = (*SASLInitialResponse)(nil)
+
+type SASLResponse []uint8
+
+func (T *SASLResponse) Type() fed.Type {
+	return TypeSASLResponse
+}
+
+func (T *SASLResponse) Length() (length int) {
+	for _, temp135 := range *T {
+		_ = temp135
+
+		length += 1
+
+	}
+
+	return
+}
+
+func (T *SASLResponse) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	(*T) = (*T)[:0]
+
+	for {
+		if decoder.Position() >= decoder.Length() {
+			break
+		}
+
+		(*T) = slices.Resize((*T), len((*T))+1)
+
+		*(*uint8)(&((*T)[len((*T))-1])), err = decoder.Uint8()
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+func (T *SASLResponse) WriteTo(encoder *fed.Encoder) (err error) {
+	for _, temp136 := range *T {
+		err = encoder.Uint8(uint8(temp136))
+		if err != nil {
+			return
+		}
+
+	}
+
+	return
+}
+
+var _ fed.Packet = (*SASLResponse)(nil)
+
+type StartupPayloadControlPayloadCancelKey struct {
+	ProcessID int32
+	SecretKey int32
+}
+
+type StartupPayloadControlPayloadCancel StartupPayloadControlPayloadCancelKey
+
+func (*StartupPayloadControlPayloadCancel) StartupPayloadControlPayloadMode() int16 {
+	return 5678
+}
+
+func (T *StartupPayloadControlPayloadCancel) Length() (length int) {
+	length += 4
+
+	length += 4
+
+	return
+}
+
+func (T *StartupPayloadControlPayloadCancel) ReadFrom(decoder *fed.Decoder) (err error) {
+	*(*int32)(&((*T).ProcessID)), err = decoder.Int32()
+	if err != nil {
+		return
+	}
+	*(*int32)(&((*T).SecretKey)), err = decoder.Int32()
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (T *StartupPayloadControlPayloadCancel) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.Int32(int32((*T).ProcessID))
+	if err != nil {
+		return
+	}
+
+	err = encoder.Int32(int32((*T).SecretKey))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+type StartupPayloadControlPayloadGSSAPI struct{}
+
+func (*StartupPayloadControlPayloadGSSAPI) StartupPayloadControlPayloadMode() int16 {
+	return 5680
+}
+
+func (T *StartupPayloadControlPayloadGSSAPI) Length() (length int) {
+
+	return
+}
+
+func (T *StartupPayloadControlPayloadGSSAPI) ReadFrom(decoder *fed.Decoder) (err error) {
+
+	return
+}
+
+func (T *StartupPayloadControlPayloadGSSAPI) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+type StartupPayloadControlPayloadSSL struct{}
+
+func (*StartupPayloadControlPayloadSSL) StartupPayloadControlPayloadMode() int16 {
+	return 5679
+}
+
+func (T *StartupPayloadControlPayloadSSL) Length() (length int) {
+
+	return
+}
+
+func (T *StartupPayloadControlPayloadSSL) ReadFrom(decoder *fed.Decoder) (err error) {
+
+	return
+}
+
+func (T *StartupPayloadControlPayloadSSL) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+type StartupPayloadControlPayloadMode interface {
+	StartupPayloadControlPayloadMode() int16
+
+	Length() int
+	ReadFrom(decoder *fed.Decoder) error
+	WriteTo(encoder *fed.Encoder) error
+}
+type StartupPayloadControlPayload struct {
+	Mode StartupPayloadControlPayloadMode
+}
+
+type StartupPayloadControl StartupPayloadControlPayload
+
+func (*StartupPayloadControl) StartupPayloadMode() int16 {
+	return 1234
+}
+
+func (T *StartupPayloadControl) Length() (length int) {
+	length += 2
+
+	length += (*T).Mode.Length()
+
+	return
+}
+
+func (T *StartupPayloadControl) ReadFrom(decoder *fed.Decoder) (err error) {
+	var temp137 int16
+
+	*(*int16)(&(temp137)), err = decoder.Int16()
+	if err != nil {
+		return
+	}
+
+	switch temp137 {
+	case 5678:
+		(*T).Mode = new(StartupPayloadControlPayloadCancel)
+	case 5680:
+		(*T).Mode = new(StartupPayloadControlPayloadGSSAPI)
+	case 5679:
+		(*T).Mode = new(StartupPayloadControlPayloadSSL)
+	default:
+		err = ErrInvalidFormat
+		return
+	}
+
+	err = (*T).Mode.ReadFrom(decoder)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (T *StartupPayloadControl) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.Int16(int16((*T).Mode.StartupPayloadControlPayloadMode()))
+	if err != nil {
+		return
+	}
+
+	err = (*T).Mode.WriteTo(encoder)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+type StartupPayloadVersion3PayloadParameter struct {
+	Key   string
+	Value string
+}
+
+type StartupPayloadVersion3Payload struct {
+	MinorVersion int16
+	Parameters   []StartupPayloadVersion3PayloadParameter
+}
+
+type StartupPayloadVersion3 StartupPayloadVersion3Payload
+
+func (*StartupPayloadVersion3) StartupPayloadMode() int16 {
+	return 3
+}
+
+func (T *StartupPayloadVersion3) Length() (length int) {
+	length += 2
+
+	for _, temp138 := range (*T).Parameters {
+		_ = temp138
+
+		length += len(temp138.Key) + 1
+
+		length += len(temp138.Value) + 1
+
+	}
+
+	var temp139 string
+	_ = temp139
+
+	length += len(temp139) + 1
+
+	return
+}
+
+func (T *StartupPayloadVersion3) ReadFrom(decoder *fed.Decoder) (err error) {
+	*(*int16)(&((*T).MinorVersion)), err = decoder.Int16()
+	if err != nil {
+		return
+	}
+	(*T).Parameters = (*T).Parameters[:0]
+
+	for {
+		(*T).Parameters = slices.Resize((*T).Parameters, len((*T).Parameters)+1)
+
+		*(*string)(&((*T).Parameters[len((*T).Parameters)-1].Key)), err = decoder.String()
+		if err != nil {
+			return
+		}
+		if (*T).Parameters[len((*T).Parameters)-1].Key == *new(string) {
+			(*T).Parameters = (*T).Parameters[:len((*T).Parameters)-1]
+			break
+		}
+		*(*string)(&((*T).Parameters[len((*T).Parameters)-1].Value)), err = decoder.String()
+		if err != nil {
+			return
+		}
+	}
+
+	return
+}
+
+func (T *StartupPayloadVersion3) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.Int16(int16((*T).MinorVersion))
+	if err != nil {
+		return
+	}
+
+	for _, temp140 := range (*T).Parameters {
+		err = encoder.String(string(temp140.Key))
+		if err != nil {
+			return
+		}
+
+		err = encoder.String(string(temp140.Value))
+		if err != nil {
+			return
+		}
+
+	}
+
+	var temp141 string
+
+	err = encoder.String(string(temp141))
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+type StartupPayloadMode interface {
+	StartupPayloadMode() int16
+
+	Length() int
+	ReadFrom(decoder *fed.Decoder) error
+	WriteTo(encoder *fed.Encoder) error
+}
+type StartupPayload struct {
+	Mode StartupPayloadMode
+}
+
+type Startup StartupPayload
+
+func (T *Startup) Type() fed.Type {
+	return 0
+}
+
+func (T *Startup) Length() (length int) {
+	length += 2
+
+	length += (*T).Mode.Length()
+
+	return
+}
+
+func (T *Startup) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	var temp142 int16
+
+	*(*int16)(&(temp142)), err = decoder.Int16()
+	if err != nil {
+		return
+	}
+
+	switch temp142 {
+	case 1234:
+		(*T).Mode = new(StartupPayloadControl)
+	case 3:
+		(*T).Mode = new(StartupPayloadVersion3)
+	default:
+		err = ErrInvalidFormat
+		return
+	}
+
+	err = (*T).Mode.ReadFrom(decoder)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (T *Startup) WriteTo(encoder *fed.Encoder) (err error) {
+	err = encoder.Int16(int16((*T).Mode.StartupPayloadMode()))
+	if err != nil {
+		return
+	}
+
+	err = (*T).Mode.WriteTo(encoder)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+var _ fed.Packet = (*Startup)(nil)
+
+type Sync struct{}
+
+func (T *Sync) Type() fed.Type {
+	return TypeSync
+}
+
+func (T *Sync) Length() (length int) {
+
+	return
+}
+
+func (T *Sync) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	return
+}
+
+func (T *Sync) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+var _ fed.Packet = (*Sync)(nil)
+
+type Terminate struct{}
+
+func (T *Terminate) Type() fed.Type {
+	return TypeTerminate
+}
+
+func (T *Terminate) Length() (length int) {
+
+	return
+}
+
+func (T *Terminate) ReadFrom(decoder *fed.Decoder) (err error) {
+	if decoder.Type() != T.Type() {
+		return ErrUnexpectedPacket
+	}
+
+	return
+}
+
+func (T *Terminate) WriteTo(encoder *fed.Encoder) (err error) {
+
+	return
+}
+
+var _ fed.Packet = (*Terminate)(nil)
diff --git a/lib/fed/packets/v3.0/parameterstatus.go b/lib/fed/packets/v3.0/parameterstatus.go
deleted file mode 100644
index 2280971fac953618dc054a0c9c196df76dc117df..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/parameterstatus.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package packets
-
-import "gfx.cafe/gfx/pggat/lib/fed"
-
-type ParameterStatus struct {
-	Key   string
-	Value string
-}
-
-func (T *ParameterStatus) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeParameterStatus {
-		return false
-	}
-	p := packet.ReadString(&T.Key)
-	p = p.ReadString(&T.Value)
-	return true
-}
-
-func (T *ParameterStatus) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = packet.Reset(TypeParameterStatus, len(T.Key)+len(T.Value)+2)
-	packet = packet.AppendString(T.Key)
-	packet = packet.AppendString(T.Value)
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/parse.go b/lib/fed/packets/v3.0/parse.go
deleted file mode 100644
index 1ae827a42c91c05cd4d5528bc569eeb4bfa8e51c..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/parse.go
+++ /dev/null
@@ -1,38 +0,0 @@
-package packets
-
-import (
-	"gfx.cafe/gfx/pggat/lib/fed"
-	"gfx.cafe/gfx/pggat/lib/util/slices"
-)
-
-type Parse struct {
-	Destination        string
-	Query              string
-	ParameterDataTypes []int32
-}
-
-func (T *Parse) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeParse {
-		return false
-	}
-	p := packet.ReadString(&T.Destination)
-	p = p.ReadString(&T.Query)
-	var parameterDataTypesCount int16
-	p = p.ReadInt16(&parameterDataTypesCount)
-	T.ParameterDataTypes = slices.Resize(T.ParameterDataTypes, int(parameterDataTypesCount))
-	for i := 0; i < int(parameterDataTypesCount); i++ {
-		p = p.ReadInt32(&T.ParameterDataTypes[i])
-	}
-	return true
-}
-
-func (T *Parse) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = packet.Reset(TypeParse, len(T.Destination)+len(T.Query)+4+len(T.ParameterDataTypes)*4)
-	packet = packet.AppendString(T.Destination)
-	packet = packet.AppendString(T.Query)
-	packet = packet.AppendInt16(int16(len(T.ParameterDataTypes)))
-	for _, v := range T.ParameterDataTypes {
-		packet = packet.AppendInt32(v)
-	}
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/passwordmessage.go b/lib/fed/packets/v3.0/passwordmessage.go
deleted file mode 100644
index 7994328304204bceb80eac06877ee526bbfbd457..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/passwordmessage.go
+++ /dev/null
@@ -1,23 +0,0 @@
-package packets
-
-import (
-	"gfx.cafe/gfx/pggat/lib/fed"
-)
-
-type PasswordMessage struct {
-	Password string
-}
-
-func (T *PasswordMessage) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeAuthenticationResponse {
-		return false
-	}
-	packet.ReadString(&T.Password)
-	return true
-}
-
-func (T *PasswordMessage) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = packet.Reset(TypeAuthenticationResponse, len(T.Password)+1)
-	packet = packet.AppendString(T.Password)
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/query.go b/lib/fed/packets/v3.0/query.go
deleted file mode 100644
index 5a0e43afdd9b09518ecea02420c4e28c65f1ddda..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/query.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package packets
-
-import "gfx.cafe/gfx/pggat/lib/fed"
-
-type Query string
-
-func (T *Query) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeQuery {
-		return false
-	}
-	packet.ReadString((*string)(T))
-	return true
-}
-
-func (T *Query) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = packet.Reset(TypeQuery, len(*T)+1)
-	packet = packet.AppendString(string(*T))
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/readyforquery.go b/lib/fed/packets/v3.0/readyforquery.go
deleted file mode 100644
index aaf111dd3c4f74413934ebd337056bf8fc9ed5eb..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/readyforquery.go
+++ /dev/null
@@ -1,21 +0,0 @@
-package packets
-
-import (
-	"gfx.cafe/gfx/pggat/lib/fed"
-)
-
-type ReadyForQuery byte
-
-func (T *ReadyForQuery) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeReadyForQuery {
-		return false
-	}
-	packet.ReadUint8((*byte)(T))
-	return true
-}
-
-func (T *ReadyForQuery) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = fed.NewPacket(TypeReadyForQuery, 1)
-	packet = packet.AppendUint8(byte(*T))
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/rowdescription.go b/lib/fed/packets/v3.0/rowdescription.go
deleted file mode 100644
index fa4001c520d36fae689a42a7e50d9a304eb4dd3c..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/rowdescription.go
+++ /dev/null
@@ -1,63 +0,0 @@
-package packets
-
-import (
-	"gfx.cafe/gfx/pggat/lib/fed"
-	"gfx.cafe/gfx/pggat/lib/util/slices"
-)
-
-type RowDescriptionField struct {
-	Name         string
-	TableID      int32
-	ColumnID     int16
-	Type         int32
-	TypeLength   int16
-	TypeModifier int32
-	FormatCode   int16
-}
-
-type RowDescription struct {
-	Fields []RowDescriptionField
-}
-
-func (T *RowDescription) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeRowDescription {
-		return false
-	}
-
-	var fieldsPerRow uint16
-	p := packet.ReadUint16(&fieldsPerRow)
-	T.Fields = slices.Resize(T.Fields, int(fieldsPerRow))
-	for i := 0; i < int(fieldsPerRow); i++ {
-		p = p.ReadString(&T.Fields[i].Name)
-		p = p.ReadInt32(&T.Fields[i].TableID)
-		p = p.ReadInt16(&T.Fields[i].ColumnID)
-		p = p.ReadInt32(&T.Fields[i].Type)
-		p = p.ReadInt16(&T.Fields[i].TypeLength)
-		p = p.ReadInt32(&T.Fields[i].TypeModifier)
-		p = p.ReadInt16(&T.Fields[i].FormatCode)
-	}
-
-	return true
-}
-
-func (T *RowDescription) IntoPacket(packet fed.Packet) fed.Packet {
-	size := 2
-	for _, v := range T.Fields {
-		size += len(v.Name) + 1
-		size += 4 + 2 + 4 + 2 + 4 + 2
-	}
-
-	packet = packet.Reset(TypeRowDescription, size)
-	packet = packet.AppendUint16(uint16(len(T.Fields)))
-	for _, v := range T.Fields {
-		packet = packet.AppendString(v.Name)
-		packet = packet.AppendInt32(v.TableID)
-		packet = packet.AppendInt16(v.ColumnID)
-		packet = packet.AppendInt32(v.Type)
-		packet = packet.AppendInt16(v.TypeLength)
-		packet = packet.AppendInt32(v.TypeModifier)
-		packet = packet.AppendInt16(v.FormatCode)
-	}
-
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/saslinitialresponse.go b/lib/fed/packets/v3.0/saslinitialresponse.go
deleted file mode 100644
index b9046788c0f16a71d1bfca4669e51ee8c54d45ab..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/saslinitialresponse.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package packets
-
-import (
-	"gfx.cafe/gfx/pggat/lib/fed"
-	"gfx.cafe/gfx/pggat/lib/util/slices"
-)
-
-type SASLInitialResponse struct {
-	Mechanism       string
-	InitialResponse []byte
-}
-
-func (T *SASLInitialResponse) ReadFromPacket(packet fed.Packet) bool {
-	if packet.Type() != TypeAuthenticationResponse {
-		return false
-	}
-
-	p := packet.ReadString(&T.Mechanism)
-
-	var initialResponseSize int32
-	p = p.ReadInt32(&initialResponseSize)
-
-	T.InitialResponse = slices.Resize(T.InitialResponse, int(initialResponseSize))
-	p = p.ReadBytes(T.InitialResponse)
-
-	return true
-}
-
-func (T *SASLInitialResponse) IntoPacket(packet fed.Packet) fed.Packet {
-	packet = packet.Reset(TypeAuthenticationResponse, len(T.Mechanism)+5+len(T.InitialResponse))
-	packet = packet.AppendString(T.Mechanism)
-	packet = packet.AppendInt32(int32(len(T.InitialResponse)))
-	packet = packet.AppendBytes(T.InitialResponse)
-	return packet
-}
diff --git a/lib/fed/packets/v3.0/types.go b/lib/fed/packets/v3.0/types.go
deleted file mode 100644
index f1d5335e7923940a588442a40b88e299d074a09a..0000000000000000000000000000000000000000
--- a/lib/fed/packets/v3.0/types.go
+++ /dev/null
@@ -1,42 +0,0 @@
-package packets
-
-import "gfx.cafe/gfx/pggat/lib/fed"
-
-const (
-	TypeAuthentication           fed.Type = 'R'
-	TypeBackendKeyData           fed.Type = 'K'
-	TypeBind                     fed.Type = 'B'
-	TypeBindComplete             fed.Type = '2'
-	TypeClose                    fed.Type = 'C'
-	TypeCloseComplete            fed.Type = '3'
-	TypeCommandComplete          fed.Type = 'C'
-	TypeCopyData                 fed.Type = 'd'
-	TypeCopyDone                 fed.Type = 'c'
-	TypeCopyFail                 fed.Type = 'f'
-	TypeCopyInResponse           fed.Type = 'G'
-	TypeCopyOutResponse          fed.Type = 'H'
-	TypeCopyBothResponse         fed.Type = 'W'
-	TypeDataRow                  fed.Type = 'D'
-	TypeDescribe                 fed.Type = 'D'
-	TypeEmptyQueryResponse       fed.Type = 'I'
-	TypeErrorResponse            fed.Type = 'E'
-	TypeExecute                  fed.Type = 'E'
-	TypeFlush                    fed.Type = 'H'
-	TypeFunctionCall             fed.Type = 'F'
-	TypeFunctionCallResponse     fed.Type = 'V'
-	TypeAuthenticationResponse   fed.Type = 'p'
-	TypeNegotiateProtocolVersion fed.Type = 'v'
-	TypeNoData                   fed.Type = 'n'
-	TypeNoticeResponse           fed.Type = 'N'
-	TypeNotificationResponse     fed.Type = 'A'
-	TypeParameterDescription     fed.Type = 't'
-	TypeParameterStatus          fed.Type = 'S'
-	TypeParse                    fed.Type = 'P'
-	TypeParseComplete            fed.Type = '1'
-	TypePortalSuspended          fed.Type = 's'
-	TypeQuery                    fed.Type = 'Q'
-	TypeReadyForQuery            fed.Type = 'Z'
-	TypeRowDescription           fed.Type = 'T'
-	TypeSync                     fed.Type = 'S'
-	TypeTerminate                fed.Type = 'X'
-)
diff --git a/lib/fed/readwriter.go b/lib/fed/readwriter.go
deleted file mode 100644
index bde9a0d17f45d0b48b682e4c87d2108b419ff9dd..0000000000000000000000000000000000000000
--- a/lib/fed/readwriter.go
+++ /dev/null
@@ -1,20 +0,0 @@
-package fed
-
-type Reader interface {
-	ReadPacket(typed bool, buffer Packet) (Packet, error)
-}
-
-type Writer interface {
-	WritePacket(Packet) error
-}
-
-type ReadWriter interface {
-	Reader
-	Writer
-}
-
-type ReadWriteCloser interface {
-	ReadWriter
-
-	Close() error
-}
diff --git a/lib/fed/ssl.go b/lib/fed/ssl.go
deleted file mode 100644
index 9b830d23ded6eef3b32461fb91053ec67a3d61ae..0000000000000000000000000000000000000000
--- a/lib/fed/ssl.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package fed
-
-import "crypto/tls"
-
-type SSL interface {
-	SSL() bool
-}
-
-type SSLClient interface {
-	SSL
-
-	EnableSSLClient(config *tls.Config) error
-}
-
-type SSLServer interface {
-	SSL
-
-	EnableSSLServer(config *tls.Config) error
-}
diff --git a/lib/perror/packet.go b/lib/perror/packet.go
new file mode 100644
index 0000000000000000000000000000000000000000..e025ce9c0cea2236192363d0e5cc1cd8d9c1e55b
--- /dev/null
+++ b/lib/perror/packet.go
@@ -0,0 +1,30 @@
+package perror
+
+import packets "gfx.cafe/gfx/pggat/lib/fed/packets/v3.0"
+
+func ToPacket(err Error) *packets.ErrorResponse {
+	var resp packets.ErrorResponse
+	resp = append(
+		resp,
+		packets.ErrorResponseField{
+			Code:  'S',
+			Value: string(err.Severity()),
+		},
+		packets.ErrorResponseField{
+			Code:  'C',
+			Value: string(err.Code()),
+		},
+		packets.ErrorResponseField{
+			Code:  'M',
+			Value: err.Message(),
+		},
+	)
+	extra := err.Extra()
+	for _, field := range extra {
+		resp = append(resp, packets.ErrorResponseField{
+			Code:  uint8(field.Type),
+			Value: field.Value,
+		})
+	}
+	return &resp
+}