diff --git a/cmd/protoc-gen-go/internal_gengo/init.go b/cmd/protoc-gen-go/internal_gengo/init.go
index ffa7f00..369df13 100644
--- a/cmd/protoc-gen-go/internal_gengo/init.go
+++ b/cmd/protoc-gen-go/internal_gengo/init.go
@@ -9,7 +9,7 @@
 	"unicode/utf8"
 
 	"google.golang.org/protobuf/compiler/protogen"
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 
 	"google.golang.org/protobuf/types/descriptorpb"
 )
@@ -146,13 +146,13 @@
 	// annotation proto from protoc-gen-go.
 	b := m.Desc.Options().(*descriptorpb.MessageOptions).ProtoReflect().GetUnknown()
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
-		if num == trackFieldUse_fieldNumber && typ == wire.VarintType {
-			v, _ := wire.ConsumeVarint(b)
-			tracked = wire.DecodeBool(v)
+		if num == trackFieldUse_fieldNumber && typ == protowire.VarintType {
+			v, _ := protowire.ConsumeVarint(b)
+			tracked = protowire.DecodeBool(v)
 		}
-		m := wire.ConsumeFieldValue(num, typ, b)
+		m := protowire.ConsumeFieldValue(num, typ, b)
 		b = b[m:]
 	}
 	return tracked
diff --git a/encoding/prototext/encode.go b/encoding/prototext/encode.go
index 7801791..83b65a6 100644
--- a/encoding/prototext/encode.go
+++ b/encoding/prototext/encode.go
@@ -10,9 +10,9 @@
 	"strconv"
 	"unicode/utf8"
 
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/encoding/messageset"
 	"google.golang.org/protobuf/internal/encoding/text"
-	"google.golang.org/protobuf/internal/encoding/wire"
 	"google.golang.org/protobuf/internal/errors"
 	"google.golang.org/protobuf/internal/fieldnum"
 	"google.golang.org/protobuf/internal/flags"
@@ -336,31 +336,31 @@
 	const dec = 10
 	const hex = 16
 	for len(b) > 0 {
-		num, wtype, n := wire.ConsumeTag(b)
+		num, wtype, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		e.WriteName(strconv.FormatInt(int64(num), dec))
 
 		switch wtype {
-		case wire.VarintType:
+		case protowire.VarintType:
 			var v uint64
-			v, n = wire.ConsumeVarint(b)
+			v, n = protowire.ConsumeVarint(b)
 			e.WriteUint(v)
-		case wire.Fixed32Type:
+		case protowire.Fixed32Type:
 			var v uint32
-			v, n = wire.ConsumeFixed32(b)
+			v, n = protowire.ConsumeFixed32(b)
 			e.WriteLiteral("0x" + strconv.FormatUint(uint64(v), hex))
-		case wire.Fixed64Type:
+		case protowire.Fixed64Type:
 			var v uint64
-			v, n = wire.ConsumeFixed64(b)
+			v, n = protowire.ConsumeFixed64(b)
 			e.WriteLiteral("0x" + strconv.FormatUint(v, hex))
-		case wire.BytesType:
+		case protowire.BytesType:
 			var v []byte
-			v, n = wire.ConsumeBytes(b)
+			v, n = protowire.ConsumeBytes(b)
 			e.WriteString(string(v))
-		case wire.StartGroupType:
+		case protowire.StartGroupType:
 			e.StartMessage()
 			var v []byte
-			v, n = wire.ConsumeGroup(num, b)
+			v, n = protowire.ConsumeGroup(num, b)
 			e.marshalUnknown(v)
 			e.EndMessage()
 		default:
diff --git a/internal/encoding/wire/wire.go b/encoding/protowire/wire.go
similarity index 98%
rename from internal/encoding/wire/wire.go
rename to encoding/protowire/wire.go
index e624ff8..a427f8b 100644
--- a/internal/encoding/wire/wire.go
+++ b/encoding/protowire/wire.go
@@ -2,10 +2,12 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package wire parses and formats the protobuf wire encoding.
-//
+// Package protowire parses and formats the raw wire encoding.
 // See https://developers.google.com/protocol-buffers/docs/encoding.
-package wire
+//
+// For marshaling and unmarshaling entire protobuf messages,
+// use the "google.golang.org/protobuf/proto" package instead.
+package protowire
 
 import (
 	"io"
diff --git a/internal/encoding/wire/wire_test.go b/encoding/protowire/wire_test.go
similarity index 99%
rename from internal/encoding/wire/wire_test.go
rename to encoding/protowire/wire_test.go
index f82a526..10ec7f8 100644
--- a/internal/encoding/wire/wire_test.go
+++ b/encoding/protowire/wire_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package wire
+package protowire
 
 import (
 	"bytes"
diff --git a/internal/cmd/generate-types/impl.go b/internal/cmd/generate-types/impl.go
index 2328de2..932c8b0 100644
--- a/internal/cmd/generate-types/impl.go
+++ b/internal/cmd/generate-types/impl.go
@@ -31,21 +31,21 @@
 */ -}}
 {{- define "Size" -}}
 {{- if .WireType.ConstSize -}}
-wire.Size{{.WireType}}()
+protowire.Size{{.WireType}}()
 {{- else if eq .WireType "Bytes" -}}
-wire.SizeBytes(len({{.FromGoType}}))
+protowire.SizeBytes(len({{.FromGoType}}))
 {{- else -}}
-wire.Size{{.WireType}}({{.FromGoType}})
+protowire.Size{{.WireType}}({{.FromGoType}})
 {{- end -}}
 {{- end -}}
 
 {{- define "SizeValue" -}}
 {{- if .WireType.ConstSize -}}
-wire.Size{{.WireType}}()
+protowire.Size{{.WireType}}()
 {{- else if eq .WireType "Bytes" -}}
-wire.SizeBytes(len({{.FromValue}}))
+protowire.SizeBytes(len({{.FromValue}}))
 {{- else -}}
-wire.Size{{.WireType}}({{.FromValue}})
+protowire.Size{{.WireType}}({{.FromValue}})
 {{- end -}}
 {{- end -}}
 
@@ -54,23 +54,23 @@
 */ -}}
 {{- define "Append" -}}
 {{- if eq .Name "String" -}}
-b = wire.AppendString(b, {{.FromGoType}})
+b = protowire.AppendString(b, {{.FromGoType}})
 {{- else -}}
-b = wire.Append{{.WireType}}(b, {{.FromGoType}})
+b = protowire.Append{{.WireType}}(b, {{.FromGoType}})
 {{- end -}}
 {{- end -}}
 
 {{- define "AppendValue" -}}
 {{- if eq .Name "String" -}}
-b = wire.AppendString(b, {{.FromValue}})
+b = protowire.AppendString(b, {{.FromValue}})
 {{- else -}}
-b = wire.Append{{.WireType}}(b, {{.FromValue}})
+b = protowire.Append{{.WireType}}(b, {{.FromValue}})
 {{- end -}}
 {{- end -}}
 
 {{- define "Consume" -}}
 {{- if eq .Name "String" -}}
-v, n := wire.ConsumeString(b)
+v, n := protowire.ConsumeString(b)
 {{- else if eq .WireType "Varint" -}}
 var v uint64
 var n int
@@ -81,10 +81,10 @@
 	v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 	n = 2
 } else {
-	v, n = wire.ConsumeVarint(b)
+	v, n = protowire.ConsumeVarint(b)
 }
 {{- else -}}
-v, n := wire.Consume{{.WireType}}(b)
+v, n := protowire.Consume{{.WireType}}(b)
 {{- end -}}
 {{- end -}}
 
@@ -102,19 +102,19 @@
 // append{{.Name}} wire encodes a {{.GoType}} pointer as a {{.Name}}.
 func append{{.Name}}(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.{{.GoType.PointerMethod}}()
-	b = wire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, f.wiretag)
 	{{template "Append" .}}
 	return b, nil
 }
 
 // consume{{.Name}} wire decodes a {{.GoType}} pointer as a {{.Name}}.
-func consume{{.Name}}(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consume{{.Name}}(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	if wtyp != {{.WireType.Expr}} {
 		return out, errUnknown
 	}
 	{{template "Consume" .}}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*p.{{.GoType.PointerMethod}}() = {{.ToGoType}}
 	out.n = n
@@ -132,7 +132,7 @@
 // append{{.Name}}ValidateUTF8 wire encodes a {{.GoType}} pointer as a {{.Name}}.
 func append{{.Name}}ValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.{{.GoType.PointerMethod}}()
-	b = wire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, f.wiretag)
 	{{template "Append" .}}
 	if !utf8.Valid{{if eq .Name "String"}}String{{end}}(v) {
 		return b, errInvalidUTF8{}
@@ -141,13 +141,13 @@
 }
 
 // consume{{.Name}}ValidateUTF8 wire decodes a {{.GoType}} pointer as a {{.Name}}.
-func consume{{.Name}}ValidateUTF8(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consume{{.Name}}ValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	if wtyp != {{.WireType.Expr}} {
 		return out, errUnknown
 	}
 	{{template "Consume" .}}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	if !utf8.Valid{{if eq .Name "String"}}String{{end}}(v) {
 		return out, errInvalidUTF8{}
@@ -182,7 +182,7 @@
 	if {{template "IsZero" .}} {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, f.wiretag)
 	{{template "Append" .}}
 	return b, nil
 }
@@ -190,13 +190,13 @@
 {{if .ToGoTypeNoZero}}
 // consume{{.Name}}NoZero wire decodes a {{.GoType}} pointer as a {{.Name}}.
 // The zero value is not decoded.
-func consume{{.Name}}NoZero(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consume{{.Name}}NoZero(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	if wtyp != {{.WireType.Expr}} {
 		return out, errUnknown
 	}
 	{{template "Consume" .}}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*p.{{.GoType.PointerMethod}}() = {{.ToGoTypeNoZero}}
 	out.n = n
@@ -219,7 +219,7 @@
 	if {{template "IsZero" .}} {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, f.wiretag)
 	{{template "Append" .}}
 	if !utf8.Valid{{if eq .Name "String"}}String{{end}}(v) {
 		return b, errInvalidUTF8{}
@@ -229,13 +229,13 @@
 
 {{if .ToGoTypeNoZero}}
 // consume{{.Name}}NoZeroValidateUTF8 wire decodes a {{.GoType}} pointer as a {{.Name}}.
-func consume{{.Name}}NoZeroValidateUTF8(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consume{{.Name}}NoZeroValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	if wtyp != {{.WireType.Expr}} {
 		return out, errUnknown
 	}
 	{{template "Consume" .}}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	if !utf8.Valid{{if eq .Name "String"}}String{{end}}(v) {
 		return out, errInvalidUTF8{}
@@ -268,19 +268,19 @@
 // It panics if the pointer is nil.
 func append{{.Name}}Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := **p.{{.GoType.PointerMethod}}Ptr()
-	b = wire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, f.wiretag)
 	{{template "Append" .}}
 	return b, nil
 }
 
 // consume{{.Name}}Ptr wire decodes a *{{.GoType}} pointer as a {{.Name}}.
-func consume{{.Name}}Ptr(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consume{{.Name}}Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	if wtyp != {{.WireType.Expr}} {
 		return out, errUnknown
 	}
 	{{template "Consume" .}}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	vp := p.{{.GoType.PointerMethod}}Ptr()
 	if *vp == nil {
@@ -316,26 +316,26 @@
 func append{{.Name}}Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.{{.GoType.PointerMethod}}Slice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, f.wiretag)
 		{{template "Append" .}}
 	}
 	return b, nil
 }
 
 // consume{{.Name}}Slice wire decodes a []{{.GoType}} pointer as a repeated {{.Name}}.
-func consume{{.Name}}Slice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consume{{.Name}}Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.{{.GoType.PointerMethod}}Slice()
 	{{- if .WireType.Packable}}
-	if wtyp == wire.BytesType {
+	if wtyp == protowire.BytesType {
 		s := *sp
-		b, n := wire.ConsumeBytes(b)
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			{{template "Consume" .}}
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 			s = append(s, {{.ToGoType}})
 			b = b[n:]
@@ -350,7 +350,7 @@
 	}
 	{{template "Consume" .}}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*sp = append(*sp, {{.ToGoType}})
 	out.n = n
@@ -369,7 +369,7 @@
 func append{{.Name}}SliceValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.{{.GoType.PointerMethod}}Slice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, f.wiretag)
 		{{template "Append" .}}
 		if !utf8.Valid{{if eq .Name "String"}}String{{end}}(v) {
 			return b, errInvalidUTF8{}
@@ -379,14 +379,14 @@
 }
 
 // consume{{.Name}}SliceValidateUTF8 wire decodes a []{{.GoType}} pointer as a repeated {{.Name}}.
-func consume{{.Name}}SliceValidateUTF8(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consume{{.Name}}SliceValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.{{.GoType.PointerMethod}}Slice()
 	if wtyp != {{.WireType.Expr}} {
 		return out, errUnknown
 	}
 	{{template "Consume" .}}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	if !utf8.Valid{{if eq .Name "String"}}String{{end}}(v) {
 		return out, errInvalidUTF8{}
@@ -419,7 +419,7 @@
 		n += {{template "Size" .}}
 	}
 	{{- end}}
-	return f.tagsize + wire.SizeBytes(n)
+	return f.tagsize + protowire.SizeBytes(n)
 }
 
 // append{{.Name}}PackedSlice encodes a []{{.GoType}} pointer as a packed repeated {{.Name}}.
@@ -428,7 +428,7 @@
 	if len(s) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, f.wiretag)
 	{{if .WireType.ConstSize -}}
 	n := len(s) * {{template "Size" .}}
 	{{- else -}}
@@ -437,7 +437,7 @@
 		n += {{template "Size" .}}
 	}
 	{{- end}}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for _, v := range s {
 		{{template "Append" .}}
 	}
@@ -462,19 +462,19 @@
 
 // append{{.Name}}Value encodes a {{.GoType}} value as a {{.Name}}.
 func append{{.Name}}Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, wiretag)
 	{{template "AppendValue" .}}
 	return b, nil
 }
 
 // consume{{.Name}}Value decodes a {{.GoType}} value as a {{.Name}}.
-func consume{{.Name}}Value(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consume{{.Name}}Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	if wtyp != {{.WireType.Expr}} {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	{{template "Consume" .}}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
 	return {{.ToValue}}, out, nil
@@ -494,7 +494,7 @@
 {{if (eq .Name "String")}}
 // append{{.Name}}ValueValidateUTF8 encodes a {{.GoType}} value as a {{.Name}}.
 func append{{.Name}}ValueValidateUTF8(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, wiretag)
 	{{template "AppendValue" .}}
 	if !utf8.ValidString({{.FromValue}}) {
 		return b, errInvalidUTF8{}
@@ -503,13 +503,13 @@
 }
 
 // consume{{.Name}}ValueValidateUTF8 decodes a {{.GoType}} value as a {{.Name}}.
-func consume{{.Name}}ValueValidateUTF8(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consume{{.Name}}ValueValidateUTF8(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	if wtyp != {{.WireType.Expr}} {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	{{template "Consume" .}}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	if !utf8.ValidString(v) {
 		return protoreflect.Value{}, out, errInvalidUTF8{}
@@ -545,25 +545,25 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, wiretag)
 		{{template "AppendValue" .}}
 	}
 	return b, nil
 }
 
 // consume{{.Name}}SliceValue wire decodes a []{{.GoType}} value as a repeated {{.Name}}.
-func consume{{.Name}}SliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consume{{.Name}}SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
 	{{- if .WireType.Packable}}
-	if wtyp == wire.BytesType {
-		b, n := wire.ConsumeBytes(b)
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return protoreflect.Value{}, out, wire.ParseError(n)
+			return protoreflect.Value{}, out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			{{template "Consume" .}}
 			if n < 0 {
-				return protoreflect.Value{}, out, wire.ParseError(n)
+				return protoreflect.Value{}, out, protowire.ParseError(n)
 			}
 			list.Append({{.ToValue}})
 			b = b[n:]
@@ -577,7 +577,7 @@
 	}
 	{{template "Consume" .}}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	list.Append({{.ToValue}})
 	out.n = n
@@ -612,7 +612,7 @@
 		n += {{template "SizeValue" .}}
 	}
 	{{- end}}
-	return tagsize + wire.SizeBytes(n)
+	return tagsize + protowire.SizeBytes(n)
 }
 
 // append{{.Name}}PackedSliceValue encodes a []{{.GoType}} value as a packed repeated {{.Name}}.
@@ -622,7 +622,7 @@
 	if llen == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, wiretag)
 	{{if .WireType.ConstSize -}}
 	n := llen * {{template "SizeValue" .}}
 	{{- else -}}
@@ -632,7 +632,7 @@
 		n += {{template "SizeValue" .}}
 	}
 	{{- end}}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
 		{{template "AppendValue" .}}
@@ -655,7 +655,7 @@
 // We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices.
 var emptyBuf [0]byte
 
-var wireTypes = map[protoreflect.Kind]wire.Type{
+var wireTypes = map[protoreflect.Kind]protowire.Type{
 {{range . -}}
 	protoreflect.{{.Name}}Kind: {{.WireType.Expr}},
 {{end}}
diff --git a/internal/cmd/generate-types/main.go b/internal/cmd/generate-types/main.go
index bf1da2b..0d3e731 100644
--- a/internal/cmd/generate-types/main.go
+++ b/internal/cmd/generate-types/main.go
@@ -190,7 +190,7 @@
 		"unicode/utf8",
 		"",
 		"google.golang.org/protobuf/internal/descfmt",
-		"google.golang.org/protobuf/internal/encoding/wire",
+		"google.golang.org/protobuf/encoding/protowire",
 		"google.golang.org/protobuf/internal/errors",
 		"google.golang.org/protobuf/internal/strs",
 		"google.golang.org/protobuf/internal/pragma",
diff --git a/internal/cmd/generate-types/proto.go b/internal/cmd/generate-types/proto.go
index 682f5f6..8ea491b 100644
--- a/internal/cmd/generate-types/proto.go
+++ b/internal/cmd/generate-types/proto.go
@@ -21,9 +21,9 @@
 
 func (w WireType) Expr() Expr {
 	if w == WireGroup {
-		return "wire.StartGroupType"
+		return "protowire.StartGroupType"
 	}
-	return "wire." + Expr(w) + "Type"
+	return "protowire." + Expr(w) + "Type"
 }
 
 func (w WireType) Packable() bool {
@@ -113,11 +113,11 @@
 	{
 		Name:       "Bool",
 		WireType:   WireVarint,
-		ToValue:    "protoreflect.ValueOfBool(wire.DecodeBool(v))",
-		FromValue:  "wire.EncodeBool(v.Bool())",
+		ToValue:    "protoreflect.ValueOfBool(protowire.DecodeBool(v))",
+		FromValue:  "protowire.EncodeBool(v.Bool())",
 		GoType:     GoBool,
-		ToGoType:   "wire.DecodeBool(v)",
-		FromGoType: "wire.EncodeBool(v)",
+		ToGoType:   "protowire.DecodeBool(v)",
+		FromGoType: "protowire.EncodeBool(v)",
 	},
 	{
 		Name:      "Enum",
@@ -137,11 +137,11 @@
 	{
 		Name:       "Sint32",
 		WireType:   WireVarint,
-		ToValue:    "protoreflect.ValueOfInt32(int32(wire.DecodeZigZag(v & math.MaxUint32)))",
-		FromValue:  "wire.EncodeZigZag(int64(int32(v.Int())))",
+		ToValue:    "protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32)))",
+		FromValue:  "protowire.EncodeZigZag(int64(int32(v.Int())))",
 		GoType:     GoInt32,
-		ToGoType:   "int32(wire.DecodeZigZag(v & math.MaxUint32))",
-		FromGoType: "wire.EncodeZigZag(int64(v))",
+		ToGoType:   "int32(protowire.DecodeZigZag(v & math.MaxUint32))",
+		FromGoType: "protowire.EncodeZigZag(int64(v))",
 	},
 	{
 		Name:       "Uint32",
@@ -164,11 +164,11 @@
 	{
 		Name:       "Sint64",
 		WireType:   WireVarint,
-		ToValue:    "protoreflect.ValueOfInt64(wire.DecodeZigZag(v))",
-		FromValue:  "wire.EncodeZigZag(v.Int())",
+		ToValue:    "protoreflect.ValueOfInt64(protowire.DecodeZigZag(v))",
+		FromValue:  "protowire.EncodeZigZag(v.Int())",
 		GoType:     GoInt64,
-		ToGoType:   "wire.DecodeZigZag(v)",
-		FromGoType: "wire.EncodeZigZag(v)",
+		ToGoType:   "protowire.DecodeZigZag(v)",
+		FromGoType: "protowire.EncodeZigZag(v)",
 	},
 	{
 		Name:       "Uint64",
@@ -277,7 +277,7 @@
 // unmarshalScalar decodes a value of the given kind.
 //
 // Message values are decoded into a []byte which aliases the input data.
-func (o UnmarshalOptions) unmarshalScalar(b []byte, wtyp wire.Type, fd protoreflect.FieldDescriptor) (val protoreflect.Value, n int, err error) {
+func (o UnmarshalOptions) unmarshalScalar(b []byte, wtyp protowire.Type, fd protoreflect.FieldDescriptor) (val protoreflect.Value, n int, err error) {
 	switch fd.Kind() {
 	{{- range .}}
 	case {{.Expr}}:
@@ -285,12 +285,12 @@
 			return val, 0, errUnknown
 		}
 		{{if (eq .WireType "Group") -}}
-		v, n := wire.ConsumeGroup(fd.Number(), b)
+		v, n := protowire.ConsumeGroup(fd.Number(), b)
 		{{- else -}}
-		v, n := wire.Consume{{.WireType}}(b)
+		v, n := protowire.Consume{{.WireType}}(b)
 		{{- end}}
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
 		{{if (eq .Name "String") -}}
 		if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
@@ -304,20 +304,20 @@
 	}
 }
 
-func (o UnmarshalOptions) unmarshalList(b []byte, wtyp wire.Type, list protoreflect.List, fd protoreflect.FieldDescriptor) (n int, err error) {
+func (o UnmarshalOptions) unmarshalList(b []byte, wtyp protowire.Type, list protoreflect.List, fd protoreflect.FieldDescriptor) (n int, err error) {
 	switch fd.Kind() {
 	{{- range .}}
 	case {{.Expr}}:
 		{{- if .WireType.Packable}}
-		if wtyp == wire.BytesType {
-			buf, n := wire.ConsumeBytes(b)
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
 			if n < 0 {
-				return 0, wire.ParseError(n)
+				return 0, protowire.ParseError(n)
 			}
 			for len(buf) > 0 {
-				v, n := wire.Consume{{.WireType}}(buf)
+				v, n := protowire.Consume{{.WireType}}(buf)
 				if n < 0 {
-					return 0, wire.ParseError(n)
+					return 0, protowire.ParseError(n)
 				}
 				buf = buf[n:]
 				list.Append({{.ToValue}})
@@ -329,12 +329,12 @@
 			return 0, errUnknown
 		}
 		{{if (eq .WireType "Group") -}}
-		v, n := wire.ConsumeGroup(fd.Number(), b)
+		v, n := protowire.ConsumeGroup(fd.Number(), b)
 		{{- else -}}
-		v, n := wire.Consume{{.WireType}}(b)
+		v, n := protowire.Consume{{.WireType}}(b)
 		{{- end}}
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
 		{{if (eq .Name "String") -}}
 		if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
@@ -366,7 +366,7 @@
 }
 
 var protoEncodeTemplate = template.Must(template.New("").Parse(`
-var wireTypes = map[protoreflect.Kind]wire.Type{
+var wireTypes = map[protoreflect.Kind]protowire.Type{
 {{- range .}}
 	{{.Expr}}: {{.WireType.Expr}},
 {{- end}}
@@ -380,7 +380,7 @@
 		if strs.EnforceUTF8(fd) && !utf8.ValidString(v.String()) {
 			return b, errors.InvalidUTF8(string(fd.FullName()))
 		}
-		b = wire.AppendString(b, {{.FromValue}})
+		b = protowire.AppendString(b, {{.FromValue}})
 		{{- else if (eq .Name "Message") -}}
 		var pos int
 		var err error
@@ -396,9 +396,9 @@
 		if err != nil {
 			return b, err
 		}
-		b = wire.AppendVarint(b, wire.EncodeTag(fd.Number(), wire.EndGroupType))
+		b = protowire.AppendVarint(b, protowire.EncodeTag(fd.Number(), protowire.EndGroupType))
 		{{- else -}}
-		b = wire.Append{{.WireType}}(b, {{.FromValue}})
+		b = protowire.Append{{.WireType}}(b, {{.FromValue}})
 		{{- end}}
 	{{- end}}
 	default:
@@ -413,20 +413,20 @@
 }
 
 var protoSizeTemplate = template.Must(template.New("").Parse(`
-func sizeSingular(num wire.Number, kind protoreflect.Kind, v protoreflect.Value) int {
+func sizeSingular(num protowire.Number, kind protoreflect.Kind, v protoreflect.Value) int {
 	switch kind {
 	{{- range .}}
 	case {{.Expr}}:
 		{{if (eq .Name "Message") -}}
-		return wire.SizeBytes(sizeMessage(v.Message()))
+		return protowire.SizeBytes(sizeMessage(v.Message()))
 		{{- else if or (eq .WireType "Fixed32") (eq .WireType "Fixed64") -}}
-		return wire.Size{{.WireType}}()
+		return protowire.Size{{.WireType}}()
 		{{- else if (eq .WireType "Bytes") -}}
-		return wire.Size{{.WireType}}(len({{.FromValue}}))
+		return protowire.Size{{.WireType}}(len({{.FromValue}}))
 		{{- else if (eq .WireType "Group") -}}
-		return wire.Size{{.WireType}}(num, sizeMessage(v.Message()))
+		return protowire.Size{{.WireType}}(num, sizeMessage(v.Message()))
 		{{- else -}}
-		return wire.Size{{.WireType}}({{.FromValue}})
+		return protowire.Size{{.WireType}}({{.FromValue}})
 		{{- end}}
 	{{- end}}
 	default:
diff --git a/internal/cmd/pbdump/pbdump.go b/internal/cmd/pbdump/pbdump.go
index 62e3a27..456fdb6 100644
--- a/internal/cmd/pbdump/pbdump.go
+++ b/internal/cmd/pbdump/pbdump.go
@@ -17,8 +17,8 @@
 	"strconv"
 	"strings"
 
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/encoding/pack"
-	"google.golang.org/protobuf/internal/encoding/wire"
 	"google.golang.org/protobuf/internal/errors"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/reflect/protodesc"
@@ -142,7 +142,7 @@
 
 // fields is a tree of fields, keyed by a field number.
 // Fields representing messages or groups have sub-fields.
-type fields map[wire.Number]*field
+type fields map[protowire.Number]*field
 type field struct {
 	kind protoreflect.Kind
 	sub  fields // only for MessageKind or GroupKind
@@ -173,8 +173,8 @@
 	}
 	prefix = strings.TrimPrefix(prefix+"."+s[:i], ".")
 	n, _ := strconv.ParseInt(s[:i], 10, 32)
-	num := wire.Number(n)
-	if num < wire.MinValidNumber || wire.MaxValidNumber < num {
+	num := protowire.Number(n)
+	if num < protowire.MinValidNumber || protowire.MaxValidNumber < num {
 		return errors.New("invalid field: %v", prefix)
 	}
 	s = strings.TrimPrefix(s[i:], ".")
@@ -244,7 +244,7 @@
 	return m
 }
 
-func (fs fields) sortedNums() (ns []wire.Number) {
+func (fs fields) sortedNums() (ns []protowire.Number) {
 	for n := range fs {
 		ns = append(ns, n)
 	}
diff --git a/internal/encoding/messageset/messageset.go b/internal/encoding/messageset/messageset.go
index 67c6173..b1eeea5 100644
--- a/internal/encoding/messageset/messageset.go
+++ b/internal/encoding/messageset/messageset.go
@@ -8,7 +8,7 @@
 import (
 	"math"
 
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/errors"
 	pref "google.golang.org/protobuf/reflect/protoreflect"
 	preg "google.golang.org/protobuf/reflect/protoregistry"
@@ -26,9 +26,9 @@
 //		}
 //	}
 const (
-	FieldItem    = wire.Number(1)
-	FieldTypeID  = wire.Number(2)
-	FieldMessage = wire.Number(3)
+	FieldItem    = protowire.Number(1)
+	FieldTypeID  = protowire.Number(2)
+	FieldMessage = protowire.Number(3)
 )
 
 // ExtensionName is the field name for extensions of MessageSet.
@@ -79,8 +79,8 @@
 
 // SizeField returns the size of a MessageSet item field containing an extension
 // with the given field number, not counting the contents of the message subfield.
-func SizeField(num wire.Number) int {
-	return 2*wire.SizeTag(FieldItem) + wire.SizeTag(FieldTypeID) + wire.SizeVarint(uint64(num))
+func SizeField(num protowire.Number) int {
+	return 2*protowire.SizeTag(FieldItem) + protowire.SizeTag(FieldTypeID) + protowire.SizeVarint(uint64(num))
 }
 
 // Unmarshal parses a MessageSet.
@@ -90,17 +90,17 @@
 //
 // If wantLen is true, the item values include the varint length prefix.
 // This is ugly, but simplifies the fast-path decoder in internal/impl.
-func Unmarshal(b []byte, wantLen bool, fn func(typeID wire.Number, value []byte) error) error {
+func Unmarshal(b []byte, wantLen bool, fn func(typeID protowire.Number, value []byte) error) error {
 	for len(b) > 0 {
-		num, wtyp, n := wire.ConsumeTag(b)
+		num, wtyp, n := protowire.ConsumeTag(b)
 		if n < 0 {
-			return wire.ParseError(n)
+			return protowire.ParseError(n)
 		}
 		b = b[n:]
-		if num != FieldItem || wtyp != wire.StartGroupType {
-			n := wire.ConsumeFieldValue(num, wtyp, b)
+		if num != FieldItem || wtyp != protowire.StartGroupType {
+			n := protowire.ConsumeFieldValue(num, wtyp, b)
 			if n < 0 {
-				return wire.ParseError(n)
+				return protowire.ParseError(n)
 			}
 			b = b[n:]
 			continue
@@ -126,36 +126,36 @@
 // item length.
 //
 // If wantLen is true, the returned message value includes the length prefix.
-func ConsumeFieldValue(b []byte, wantLen bool) (typeid wire.Number, message []byte, n int, err error) {
+func ConsumeFieldValue(b []byte, wantLen bool) (typeid protowire.Number, message []byte, n int, err error) {
 	ilen := len(b)
 	for {
-		num, wtyp, n := wire.ConsumeTag(b)
+		num, wtyp, n := protowire.ConsumeTag(b)
 		if n < 0 {
-			return 0, nil, 0, wire.ParseError(n)
+			return 0, nil, 0, protowire.ParseError(n)
 		}
 		b = b[n:]
 		switch {
-		case num == FieldItem && wtyp == wire.EndGroupType:
+		case num == FieldItem && wtyp == protowire.EndGroupType:
 			if wantLen && len(message) == 0 {
 				// The message field was missing, which should never happen.
 				// Be prepared for this case anyway.
-				message = wire.AppendVarint(message, 0)
+				message = protowire.AppendVarint(message, 0)
 			}
 			return typeid, message, ilen - len(b), nil
-		case num == FieldTypeID && wtyp == wire.VarintType:
-			v, n := wire.ConsumeVarint(b)
+		case num == FieldTypeID && wtyp == protowire.VarintType:
+			v, n := protowire.ConsumeVarint(b)
 			if n < 0 {
-				return 0, nil, 0, wire.ParseError(n)
+				return 0, nil, 0, protowire.ParseError(n)
 			}
 			b = b[n:]
 			if v < 1 || v > math.MaxInt32 {
 				return 0, nil, 0, errors.New("invalid type_id in message set")
 			}
-			typeid = wire.Number(v)
-		case num == FieldMessage && wtyp == wire.BytesType:
-			m, n := wire.ConsumeBytes(b)
+			typeid = protowire.Number(v)
+		case num == FieldMessage && wtyp == protowire.BytesType:
+			m, n := protowire.ConsumeBytes(b)
 			if n < 0 {
-				return 0, nil, 0, wire.ParseError(n)
+				return 0, nil, 0, protowire.ParseError(n)
 			}
 			if message == nil {
 				if wantLen {
@@ -172,10 +172,10 @@
 				// quite inefficient since we need to strip the length off
 				// the existing data and reconstruct it with the combined length.
 				if wantLen {
-					_, nn := wire.ConsumeVarint(message)
+					_, nn := protowire.ConsumeVarint(message)
 					m0 := message[nn:]
 					message = nil
-					message = wire.AppendVarint(message, uint64(len(m0)+len(m)))
+					message = protowire.AppendVarint(message, uint64(len(m0)+len(m)))
 					message = append(message, m0...)
 					message = append(message, m...)
 				} else {
@@ -185,9 +185,9 @@
 			b = b[n:]
 		default:
 			// We have no place to put it, so we just ignore unknown fields.
-			n := wire.ConsumeFieldValue(num, wtyp, b)
+			n := protowire.ConsumeFieldValue(num, wtyp, b)
 			if n < 0 {
-				return 0, nil, 0, wire.ParseError(n)
+				return 0, nil, 0, protowire.ParseError(n)
 			}
 			b = b[n:]
 		}
@@ -197,16 +197,16 @@
 // AppendFieldStart appends the start of a MessageSet item field containing
 // an extension with the given number. The caller must add the message
 // subfield (including the tag).
-func AppendFieldStart(b []byte, num wire.Number) []byte {
-	b = wire.AppendTag(b, FieldItem, wire.StartGroupType)
-	b = wire.AppendTag(b, FieldTypeID, wire.VarintType)
-	b = wire.AppendVarint(b, uint64(num))
+func AppendFieldStart(b []byte, num protowire.Number) []byte {
+	b = protowire.AppendTag(b, FieldItem, protowire.StartGroupType)
+	b = protowire.AppendTag(b, FieldTypeID, protowire.VarintType)
+	b = protowire.AppendVarint(b, uint64(num))
 	return b
 }
 
 // AppendFieldEnd appends the trailing end group marker for a MessageSet item field.
 func AppendFieldEnd(b []byte) []byte {
-	return wire.AppendTag(b, FieldItem, wire.EndGroupType)
+	return protowire.AppendTag(b, FieldItem, protowire.EndGroupType)
 }
 
 // SizeUnknown returns the size of an unknown fields section in MessageSet format.
@@ -214,17 +214,17 @@
 // See AppendUnknown.
 func SizeUnknown(unknown []byte) (size int) {
 	for len(unknown) > 0 {
-		num, typ, n := wire.ConsumeTag(unknown)
-		if n < 0 || typ != wire.BytesType {
+		num, typ, n := protowire.ConsumeTag(unknown)
+		if n < 0 || typ != protowire.BytesType {
 			return 0
 		}
 		unknown = unknown[n:]
-		_, n = wire.ConsumeBytes(unknown)
+		_, n = protowire.ConsumeBytes(unknown)
 		if n < 0 {
 			return 0
 		}
 		unknown = unknown[n:]
-		size += SizeField(num) + wire.SizeTag(FieldMessage) + n
+		size += SizeField(num) + protowire.SizeTag(FieldMessage) + n
 	}
 	return size
 }
@@ -239,17 +239,17 @@
 // This function converts the unknown fields back into MessageSet form.
 func AppendUnknown(b, unknown []byte) ([]byte, error) {
 	for len(unknown) > 0 {
-		num, typ, n := wire.ConsumeTag(unknown)
-		if n < 0 || typ != wire.BytesType {
+		num, typ, n := protowire.ConsumeTag(unknown)
+		if n < 0 || typ != protowire.BytesType {
 			return nil, errors.New("invalid data in message set unknown fields")
 		}
 		unknown = unknown[n:]
-		_, n = wire.ConsumeBytes(unknown)
+		_, n = protowire.ConsumeBytes(unknown)
 		if n < 0 {
 			return nil, errors.New("invalid data in message set unknown fields")
 		}
 		b = AppendFieldStart(b, num)
-		b = wire.AppendTag(b, FieldMessage, wire.BytesType)
+		b = protowire.AppendTag(b, FieldMessage, protowire.BytesType)
 		b = append(b, unknown[:n]...)
 		b = AppendFieldEnd(b)
 		unknown = unknown[n:]
diff --git a/internal/encoding/pack/pack.go b/internal/encoding/pack/pack.go
index 4e172e6..163002f 100644
--- a/internal/encoding/pack/pack.go
+++ b/internal/encoding/pack/pack.go
@@ -21,32 +21,32 @@
 	"unicode"
 	"unicode/utf8"
 
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/reflect/protoreflect"
 )
 
 // Number is the field number; aliased from the wire package for convenience.
-type Number = wire.Number
+type Number = protowire.Number
 
 // Number type constants; copied from the wire package for convenience.
 const (
-	MinValidNumber      Number = wire.MinValidNumber
-	FirstReservedNumber Number = wire.FirstReservedNumber
-	LastReservedNumber  Number = wire.LastReservedNumber
-	MaxValidNumber      Number = wire.MaxValidNumber
+	MinValidNumber      Number = protowire.MinValidNumber
+	FirstReservedNumber Number = protowire.FirstReservedNumber
+	LastReservedNumber  Number = protowire.LastReservedNumber
+	MaxValidNumber      Number = protowire.MaxValidNumber
 )
 
 // Type is the wire type; aliased from the wire package for convenience.
-type Type = wire.Type
+type Type = protowire.Type
 
 // Wire type constants; copied from the wire package for convenience.
 const (
-	VarintType     Type = wire.VarintType
-	Fixed32Type    Type = wire.Fixed32Type
-	Fixed64Type    Type = wire.Fixed64Type
-	BytesType      Type = wire.BytesType
-	StartGroupType Type = wire.StartGroupType
-	EndGroupType   Type = wire.EndGroupType
+	VarintType     Type = protowire.VarintType
+	Fixed32Type    Type = protowire.Fixed32Type
+	Fixed64Type    Type = protowire.Fixed64Type
+	BytesType      Type = protowire.BytesType
+	StartGroupType Type = protowire.StartGroupType
+	EndGroupType   Type = protowire.EndGroupType
 )
 
 type (
@@ -140,25 +140,25 @@
 		case Message:
 			n += v.Size()
 		case Tag:
-			n += wire.SizeTag(v.Number)
+			n += protowire.SizeTag(v.Number)
 		case Bool:
-			n += wire.SizeVarint(wire.EncodeBool(false))
+			n += protowire.SizeVarint(protowire.EncodeBool(false))
 		case Varint:
-			n += wire.SizeVarint(uint64(v))
+			n += protowire.SizeVarint(uint64(v))
 		case Svarint:
-			n += wire.SizeVarint(wire.EncodeZigZag(int64(v)))
+			n += protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
 		case Uvarint:
-			n += wire.SizeVarint(uint64(v))
+			n += protowire.SizeVarint(uint64(v))
 		case Int32, Uint32, Float32:
-			n += wire.SizeFixed32()
+			n += protowire.SizeFixed32()
 		case Int64, Uint64, Float64:
-			n += wire.SizeFixed64()
+			n += protowire.SizeFixed64()
 		case String:
-			n += wire.SizeBytes(len(v))
+			n += protowire.SizeBytes(len(v))
 		case Bytes:
-			n += wire.SizeBytes(len(v))
+			n += protowire.SizeBytes(len(v))
 		case LengthPrefix:
-			n += wire.SizeBytes(Message(v).Size())
+			n += protowire.SizeBytes(Message(v).Size())
 		case Denormalized:
 			n += int(v.Count) + Message{v.Value}.Size()
 		case Raw:
@@ -199,36 +199,36 @@
 		case Message:
 			out = append(out, v.Marshal()...)
 		case Tag:
-			out = wire.AppendTag(out, v.Number, v.Type)
+			out = protowire.AppendTag(out, v.Number, v.Type)
 		case Bool:
-			out = wire.AppendVarint(out, wire.EncodeBool(bool(v)))
+			out = protowire.AppendVarint(out, protowire.EncodeBool(bool(v)))
 		case Varint:
-			out = wire.AppendVarint(out, uint64(v))
+			out = protowire.AppendVarint(out, uint64(v))
 		case Svarint:
-			out = wire.AppendVarint(out, wire.EncodeZigZag(int64(v)))
+			out = protowire.AppendVarint(out, protowire.EncodeZigZag(int64(v)))
 		case Uvarint:
-			out = wire.AppendVarint(out, uint64(v))
+			out = protowire.AppendVarint(out, uint64(v))
 		case Int32:
-			out = wire.AppendFixed32(out, uint32(v))
+			out = protowire.AppendFixed32(out, uint32(v))
 		case Uint32:
-			out = wire.AppendFixed32(out, uint32(v))
+			out = protowire.AppendFixed32(out, uint32(v))
 		case Float32:
-			out = wire.AppendFixed32(out, math.Float32bits(float32(v)))
+			out = protowire.AppendFixed32(out, math.Float32bits(float32(v)))
 		case Int64:
-			out = wire.AppendFixed64(out, uint64(v))
+			out = protowire.AppendFixed64(out, uint64(v))
 		case Uint64:
-			out = wire.AppendFixed64(out, uint64(v))
+			out = protowire.AppendFixed64(out, uint64(v))
 		case Float64:
-			out = wire.AppendFixed64(out, math.Float64bits(float64(v)))
+			out = protowire.AppendFixed64(out, math.Float64bits(float64(v)))
 		case String:
-			out = wire.AppendBytes(out, []byte(v))
+			out = protowire.AppendBytes(out, []byte(v))
 		case Bytes:
-			out = wire.AppendBytes(out, []byte(v))
+			out = protowire.AppendBytes(out, []byte(v))
 		case LengthPrefix:
-			out = wire.AppendBytes(out, Message(v).Marshal())
+			out = protowire.AppendBytes(out, Message(v).Marshal())
 		case Denormalized:
 			b := Message{v.Value}.Marshal()
-			_, n := wire.ConsumeVarint(b)
+			_, n := protowire.ConsumeVarint(b)
 			out = append(out, b[:n]...)
 			for i := uint(0); i < v.Count; i++ {
 				out[len(out)-1] |= 0x80 // set continuation bit on previous
@@ -301,8 +301,8 @@
 
 func (p *parser) parseMessage(msgDesc protoreflect.MessageDescriptor, group bool) {
 	for len(p.in) > 0 {
-		v, n := wire.ConsumeVarint(p.in)
-		num, typ := wire.DecodeTag(v)
+		v, n := protowire.ConsumeVarint(p.in)
+		num, typ := protowire.DecodeTag(v)
 		if n < 0 || num < 0 || v > math.MaxUint32 {
 			p.out, p.in = append(p.out, Raw(p.in)), nil
 			return
@@ -311,7 +311,7 @@
 			return // if inside a group, then stop
 		}
 		p.out, p.in = append(p.out, Tag{num, typ}), p.in[n:]
-		if m := n - wire.SizeVarint(v); m > 0 {
+		if m := n - protowire.SizeVarint(v); m > 0 {
 			p.out[len(p.out)-1] = Denormalized{uint(m), p.out[len(p.out)-1]}
 		}
 
@@ -353,7 +353,7 @@
 }
 
 func (p *parser) parseVarint(kind protoreflect.Kind) {
-	v, n := wire.ConsumeVarint(p.in)
+	v, n := protowire.ConsumeVarint(p.in)
 	if n < 0 {
 		p.out, p.in = append(p.out, Raw(p.in)), nil
 		return
@@ -371,17 +371,17 @@
 	case protoreflect.Int32Kind, protoreflect.Int64Kind:
 		p.out, p.in = append(p.out, Varint(v)), p.in[n:]
 	case protoreflect.Sint32Kind, protoreflect.Sint64Kind:
-		p.out, p.in = append(p.out, Svarint(wire.DecodeZigZag(v))), p.in[n:]
+		p.out, p.in = append(p.out, Svarint(protowire.DecodeZigZag(v))), p.in[n:]
 	default:
 		p.out, p.in = append(p.out, Uvarint(v)), p.in[n:]
 	}
-	if m := n - wire.SizeVarint(v); m > 0 {
+	if m := n - protowire.SizeVarint(v); m > 0 {
 		p.out[len(p.out)-1] = Denormalized{uint(m), p.out[len(p.out)-1]}
 	}
 }
 
 func (p *parser) parseFixed32(kind protoreflect.Kind) {
-	v, n := wire.ConsumeFixed32(p.in)
+	v, n := protowire.ConsumeFixed32(p.in)
 	if n < 0 {
 		p.out, p.in = append(p.out, Raw(p.in)), nil
 		return
@@ -397,7 +397,7 @@
 }
 
 func (p *parser) parseFixed64(kind protoreflect.Kind) {
-	v, n := wire.ConsumeFixed64(p.in)
+	v, n := protowire.ConsumeFixed64(p.in)
 	if n < 0 {
 		p.out, p.in = append(p.out, Raw(p.in)), nil
 		return
@@ -413,13 +413,13 @@
 }
 
 func (p *parser) parseBytes(isPacked bool, kind protoreflect.Kind, desc protoreflect.MessageDescriptor) {
-	v, n := wire.ConsumeVarint(p.in)
+	v, n := protowire.ConsumeVarint(p.in)
 	if n < 0 {
 		p.out, p.in = append(p.out, Raw(p.in)), nil
 		return
 	}
 	p.out, p.in = append(p.out, Uvarint(v)), p.in[n:]
-	if m := n - wire.SizeVarint(v); m > 0 {
+	if m := n - protowire.SizeVarint(v); m > 0 {
 		p.out[len(p.out)-1] = Denormalized{uint(m), p.out[len(p.out)-1]}
 	}
 	if v > uint64(len(p.in)) {
@@ -442,7 +442,7 @@
 			p.out, p.in = append(p.out, Bytes(p.in[:v])), p.in[v:]
 		}
 	}
-	if m := n - wire.SizeVarint(v); m > 0 {
+	if m := n - protowire.SizeVarint(v); m > 0 {
 		p.out[len(p.out)-1] = Denormalized{uint(m), p.out[len(p.out)-1]}
 	}
 }
@@ -475,10 +475,10 @@
 	p.in = p2.in
 
 	// Append the trailing end group.
-	v, n := wire.ConsumeVarint(p.in)
-	if num, typ := wire.DecodeTag(v); typ == EndGroupType {
+	v, n := protowire.ConsumeVarint(p.in)
+	if num, typ := protowire.DecodeTag(v); typ == EndGroupType {
 		p.out, p.in = append(p.out, Tag{num, typ}), p.in[n:]
-		if m := n - wire.SizeVarint(v); m > 0 {
+		if m := n - protowire.SizeVarint(v); m > 0 {
 			p.out[len(p.out)-1] = Denormalized{uint(m), p.out[len(p.out)-1]}
 		}
 	}
diff --git a/internal/filedesc/build.go b/internal/filedesc/build.go
index f4af7ad..462d384 100644
--- a/internal/filedesc/build.go
+++ b/internal/filedesc/build.go
@@ -6,7 +6,7 @@
 package filedesc
 
 import (
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/fieldnum"
 	"google.golang.org/protobuf/reflect/protoreflect"
 	pref "google.golang.org/protobuf/reflect/protoreflect"
@@ -118,11 +118,11 @@
 // or a MessageDescriptorProto depending on whether isFile is set.
 func (db *Builder) unmarshalCounts(b []byte, isFile bool) {
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			if isFile {
 				switch num {
@@ -148,7 +148,7 @@
 				}
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
diff --git a/internal/filedesc/desc_init.go b/internal/filedesc/desc_init.go
index 249021f..c0cddf8 100644
--- a/internal/filedesc/desc_init.go
+++ b/internal/filedesc/desc_init.go
@@ -7,7 +7,7 @@
 import (
 	"sync"
 
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/fieldnum"
 	"google.golang.org/protobuf/internal/strs"
 	pref "google.golang.org/protobuf/reflect/protoreflect"
@@ -100,11 +100,11 @@
 	var posEnums, posMessages, posExtensions, posServices int
 	b0 := b
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.FileDescriptorProto_Syntax:
@@ -155,7 +155,7 @@
 			}
 			prevField = num
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 			prevField = -1 // ignore known field numbers of unknown wire type
 		}
@@ -184,8 +184,8 @@
 	if numEnums > 0 {
 		b := b0[posEnums:]
 		for i := range fd.L1.Enums.List {
-			_, n := wire.ConsumeVarint(b)
-			v, m := wire.ConsumeBytes(b[n:])
+			_, n := protowire.ConsumeVarint(b)
+			v, m := protowire.ConsumeBytes(b[n:])
 			fd.L1.Enums.List[i].unmarshalSeed(v, sb, fd, fd, i)
 			b = b[n+m:]
 		}
@@ -193,8 +193,8 @@
 	if numMessages > 0 {
 		b := b0[posMessages:]
 		for i := range fd.L1.Messages.List {
-			_, n := wire.ConsumeVarint(b)
-			v, m := wire.ConsumeBytes(b[n:])
+			_, n := protowire.ConsumeVarint(b)
+			v, m := protowire.ConsumeBytes(b[n:])
 			fd.L1.Messages.List[i].unmarshalSeed(v, sb, fd, fd, i)
 			b = b[n+m:]
 		}
@@ -202,8 +202,8 @@
 	if numExtensions > 0 {
 		b := b0[posExtensions:]
 		for i := range fd.L1.Extensions.List {
-			_, n := wire.ConsumeVarint(b)
-			v, m := wire.ConsumeBytes(b[n:])
+			_, n := protowire.ConsumeVarint(b)
+			v, m := protowire.ConsumeBytes(b[n:])
 			fd.L1.Extensions.List[i].unmarshalSeed(v, sb, fd, fd, i)
 			b = b[n+m:]
 		}
@@ -211,8 +211,8 @@
 	if numServices > 0 {
 		b := b0[posServices:]
 		for i := range fd.L1.Services.List {
-			_, n := wire.ConsumeVarint(b)
-			v, m := wire.ConsumeBytes(b[n:])
+			_, n := protowire.ConsumeVarint(b)
+			v, m := protowire.ConsumeBytes(b[n:])
 			fd.L1.Services.List[i].unmarshalSeed(v, sb, fd, fd, i)
 			b = b[n+m:]
 		}
@@ -226,11 +226,11 @@
 
 	var numValues int
 	for b := b; len(b) > 0; {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.EnumDescriptorProto_Name:
@@ -239,7 +239,7 @@
 				numValues++
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -253,11 +253,11 @@
 	ed.L2 = new(EnumL2)
 	ed.L2.Values.List = make([]EnumValue, numValues)
 	for i := 0; len(b) > 0; {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.EnumDescriptorProto_Value:
@@ -265,7 +265,7 @@
 				i++
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -281,11 +281,11 @@
 	var posEnums, posMessages, posExtensions int
 	b0 := b
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.DescriptorProto_Name:
@@ -319,7 +319,7 @@
 			}
 			prevField = num
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 			prevField = -1 // ignore known field numbers of unknown wire type
 		}
@@ -340,8 +340,8 @@
 	if numEnums > 0 {
 		b := b0[posEnums:]
 		for i := range md.L1.Enums.List {
-			_, n := wire.ConsumeVarint(b)
-			v, m := wire.ConsumeBytes(b[n:])
+			_, n := protowire.ConsumeVarint(b)
+			v, m := protowire.ConsumeBytes(b[n:])
 			md.L1.Enums.List[i].unmarshalSeed(v, sb, pf, md, i)
 			b = b[n+m:]
 		}
@@ -349,8 +349,8 @@
 	if numMessages > 0 {
 		b := b0[posMessages:]
 		for i := range md.L1.Messages.List {
-			_, n := wire.ConsumeVarint(b)
-			v, m := wire.ConsumeBytes(b[n:])
+			_, n := protowire.ConsumeVarint(b)
+			v, m := protowire.ConsumeBytes(b[n:])
 			md.L1.Messages.List[i].unmarshalSeed(v, sb, pf, md, i)
 			b = b[n+m:]
 		}
@@ -358,8 +358,8 @@
 	if numExtensions > 0 {
 		b := b0[posExtensions:]
 		for i := range md.L1.Extensions.List {
-			_, n := wire.ConsumeVarint(b)
-			v, m := wire.ConsumeBytes(b[n:])
+			_, n := protowire.ConsumeVarint(b)
+			v, m := protowire.ConsumeBytes(b[n:])
 			md.L1.Extensions.List[i].unmarshalSeed(v, sb, pf, md, i)
 			b = b[n+m:]
 		}
@@ -368,20 +368,20 @@
 
 func (md *Message) unmarshalSeedOptions(b []byte) {
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.VarintType:
-			v, m := wire.ConsumeVarint(b)
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.MessageOptions_MapEntry:
-				md.L1.IsMapEntry = wire.DecodeBool(v)
+				md.L1.IsMapEntry = protowire.DecodeBool(v)
 			case fieldnum.MessageOptions_MessageSetWireFormat:
-				md.L1.IsMessageSet = wire.DecodeBool(v)
+				md.L1.IsMessageSet = protowire.DecodeBool(v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -393,11 +393,11 @@
 	xd.L0.Index = i
 
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.VarintType:
-			v, m := wire.ConsumeVarint(b)
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.FieldDescriptorProto_Number:
@@ -407,8 +407,8 @@
 			case fieldnum.FieldDescriptorProto_Type:
 				xd.L1.Kind = pref.Kind(v)
 			}
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.FieldDescriptorProto_Name:
@@ -417,7 +417,7 @@
 				xd.L1.Extendee = PlaceholderMessage(makeFullName(sb, v))
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -429,18 +429,18 @@
 	sd.L0.Index = i
 
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.ServiceDescriptorProto_Name:
 				sd.L0.FullName = appendFullName(sb, pd.FullName(), v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
diff --git a/internal/filedesc/desc_lazy.go b/internal/filedesc/desc_lazy.go
index c43b3e2..cdf3164 100644
--- a/internal/filedesc/desc_lazy.go
+++ b/internal/filedesc/desc_lazy.go
@@ -8,8 +8,8 @@
 	"reflect"
 	"sync"
 
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/descopts"
-	"google.golang.org/protobuf/internal/encoding/wire"
 	"google.golang.org/protobuf/internal/fieldnum"
 	"google.golang.org/protobuf/internal/strs"
 	"google.golang.org/protobuf/proto"
@@ -136,11 +136,11 @@
 	var rawOptions []byte
 	fd.L2 = new(FileL2)
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.VarintType:
-			v, m := wire.ConsumeVarint(b)
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.FileDescriptorProto_PublicDependency:
@@ -148,8 +148,8 @@
 			case fieldnum.FileDescriptorProto_WeakDependency:
 				fd.L2.Imports[v].IsWeak = true
 			}
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.FileDescriptorProto_Dependency:
@@ -175,7 +175,7 @@
 				rawOptions = appendOptions(rawOptions, v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -189,11 +189,11 @@
 		ed.L2 = new(EnumL2)
 	}
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.EnumDescriptorProto_Value:
@@ -206,7 +206,7 @@
 				rawOptions = appendOptions(rawOptions, v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -221,11 +221,11 @@
 
 func unmarshalEnumReservedRange(b []byte) (r [2]pref.EnumNumber) {
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.VarintType:
-			v, m := wire.ConsumeVarint(b)
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.EnumDescriptorProto_EnumReservedRange_Start:
@@ -234,7 +234,7 @@
 				r[1] = pref.EnumNumber(v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -248,18 +248,18 @@
 
 	var rawOptions []byte
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.VarintType:
-			v, m := wire.ConsumeVarint(b)
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.EnumValueDescriptorProto_Number:
 				vd.L1.Number = pref.EnumNumber(v)
 			}
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.EnumValueDescriptorProto_Name:
@@ -269,7 +269,7 @@
 				rawOptions = appendOptions(rawOptions, v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -282,11 +282,11 @@
 	var rawOptions []byte
 	md.L2 = new(MessageL2)
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.DescriptorProto_Field:
@@ -316,7 +316,7 @@
 				rawOptions = appendOptions(rawOptions, v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -340,20 +340,20 @@
 
 func (md *Message) unmarshalOptions(b []byte) {
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.VarintType:
-			v, m := wire.ConsumeVarint(b)
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.MessageOptions_MapEntry:
-				md.L1.IsMapEntry = wire.DecodeBool(v)
+				md.L1.IsMapEntry = protowire.DecodeBool(v)
 			case fieldnum.MessageOptions_MessageSetWireFormat:
-				md.L1.IsMessageSet = wire.DecodeBool(v)
+				md.L1.IsMessageSet = protowire.DecodeBool(v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -361,11 +361,11 @@
 
 func unmarshalMessageReservedRange(b []byte) (r [2]pref.FieldNumber) {
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.VarintType:
-			v, m := wire.ConsumeVarint(b)
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.DescriptorProto_ReservedRange_Start:
@@ -374,7 +374,7 @@
 				r[1] = pref.FieldNumber(v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -383,11 +383,11 @@
 
 func unmarshalMessageExtensionRange(b []byte) (r [2]pref.FieldNumber, rawOptions []byte) {
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.VarintType:
-			v, m := wire.ConsumeVarint(b)
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.DescriptorProto_ExtensionRange_Start:
@@ -395,15 +395,15 @@
 			case fieldnum.DescriptorProto_ExtensionRange_End:
 				r[1] = pref.FieldNumber(v)
 			}
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.DescriptorProto_ExtensionRange_Options:
 				rawOptions = appendOptions(rawOptions, v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -418,11 +418,11 @@
 	var rawTypeName []byte
 	var rawOptions []byte
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.VarintType:
-			v, m := wire.ConsumeVarint(b)
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.FieldDescriptorProto_Number:
@@ -442,8 +442,8 @@
 				}
 				fd.L1.ContainingOneof = od
 			}
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.FieldDescriptorProto_Name:
@@ -459,7 +459,7 @@
 				rawOptions = appendOptions(rawOptions, v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -479,24 +479,24 @@
 	const FieldOptions_EnforceUTF8 = 13
 
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.VarintType:
-			v, m := wire.ConsumeVarint(b)
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.FieldOptions_Packed:
 				fd.L1.HasPacked = true
-				fd.L1.IsPacked = wire.DecodeBool(v)
+				fd.L1.IsPacked = protowire.DecodeBool(v)
 			case fieldnum.FieldOptions_Weak:
-				fd.L1.IsWeak = wire.DecodeBool(v)
+				fd.L1.IsWeak = protowire.DecodeBool(v)
 			case FieldOptions_EnforceUTF8:
 				fd.L1.HasEnforceUTF8 = true
-				fd.L1.EnforceUTF8 = wire.DecodeBool(v)
+				fd.L1.EnforceUTF8 = protowire.DecodeBool(v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -509,11 +509,11 @@
 
 	var rawOptions []byte
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.OneofDescriptorProto_Name:
@@ -522,7 +522,7 @@
 				rawOptions = appendOptions(rawOptions, v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -534,11 +534,11 @@
 	var rawOptions []byte
 	xd.L2 = new(ExtensionL2)
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.FieldDescriptorProto_JsonName:
@@ -552,7 +552,7 @@
 				rawOptions = appendOptions(rawOptions, v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -570,18 +570,18 @@
 
 func (xd *Extension) unmarshalOptions(b []byte) {
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.VarintType:
-			v, m := wire.ConsumeVarint(b)
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.FieldOptions_Packed:
-				xd.L2.IsPacked = wire.DecodeBool(v)
+				xd.L2.IsPacked = protowire.DecodeBool(v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -592,11 +592,11 @@
 	var rawOptions []byte
 	sd.L2 = new(ServiceL2)
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.ServiceDescriptorProto_Method:
@@ -605,7 +605,7 @@
 				rawOptions = appendOptions(rawOptions, v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
@@ -625,20 +625,20 @@
 
 	var rawOptions []byte
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
+		num, typ, n := protowire.ConsumeTag(b)
 		b = b[n:]
 		switch typ {
-		case wire.VarintType:
-			v, m := wire.ConsumeVarint(b)
+		case protowire.VarintType:
+			v, m := protowire.ConsumeVarint(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.MethodDescriptorProto_ClientStreaming:
-				md.L1.IsStreamingClient = wire.DecodeBool(v)
+				md.L1.IsStreamingClient = protowire.DecodeBool(v)
 			case fieldnum.MethodDescriptorProto_ServerStreaming:
-				md.L1.IsStreamingServer = wire.DecodeBool(v)
+				md.L1.IsStreamingServer = protowire.DecodeBool(v)
 			}
-		case wire.BytesType:
-			v, m := wire.ConsumeBytes(b)
+		case protowire.BytesType:
+			v, m := protowire.ConsumeBytes(b)
 			b = b[m:]
 			switch num {
 			case fieldnum.MethodDescriptorProto_Name:
@@ -651,7 +651,7 @@
 				rawOptions = appendOptions(rawOptions, v)
 			}
 		default:
-			m := wire.ConsumeFieldValue(num, typ, b)
+			m := protowire.ConsumeFieldValue(num, typ, b)
 			b = b[m:]
 		}
 	}
diff --git a/internal/filedesc/desc_list.go b/internal/filedesc/desc_list.go
index d251991..1b7089b 100644
--- a/internal/filedesc/desc_list.go
+++ b/internal/filedesc/desc_list.go
@@ -10,8 +10,8 @@
 	"sort"
 	"sync"
 
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/descfmt"
-	"google.golang.org/protobuf/internal/encoding/wire"
 	"google.golang.org/protobuf/internal/errors"
 	"google.golang.org/protobuf/internal/pragma"
 	"google.golang.org/protobuf/reflect/protoreflect"
@@ -186,9 +186,9 @@
 // reserved number range.
 func isValidFieldNumber(n protoreflect.FieldNumber, isMessageSet bool) bool {
 	if isMessageSet {
-		return wire.MinValidNumber <= n && n <= math.MaxInt32
+		return protowire.MinValidNumber <= n && n <= math.MaxInt32
 	}
-	return wire.MinValidNumber <= n && n <= wire.MaxValidNumber
+	return protowire.MinValidNumber <= n && n <= protowire.MaxValidNumber
 }
 
 // CheckOverlap reports an error if p and q overlap.
diff --git a/internal/impl/codec_extension.go b/internal/impl/codec_extension.go
index efeea2f..da67a01 100644
--- a/internal/impl/codec_extension.go
+++ b/internal/impl/codec_extension.go
@@ -8,7 +8,7 @@
 	"sync"
 	"sync/atomic"
 
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/errors"
 	pref "google.golang.org/protobuf/reflect/protoreflect"
 )
@@ -46,13 +46,13 @@
 func makeExtensionFieldInfo(xd pref.ExtensionDescriptor) *extensionFieldInfo {
 	var wiretag uint64
 	if !xd.IsPacked() {
-		wiretag = wire.EncodeTag(xd.Number(), wireTypes[xd.Kind()])
+		wiretag = protowire.EncodeTag(xd.Number(), wireTypes[xd.Kind()])
 	} else {
-		wiretag = wire.EncodeTag(xd.Number(), wire.BytesType)
+		wiretag = protowire.EncodeTag(xd.Number(), protowire.BytesType)
 	}
 	e := &extensionFieldInfo{
 		wiretag: wiretag,
-		tagsize: wire.SizeVarint(wiretag),
+		tagsize: protowire.SizeVarint(wiretag),
 		funcs:   encoderFuncsForValue(xd),
 	}
 	// Does the unmarshal function need a value passed to it?
@@ -87,13 +87,13 @@
 	lazy  *lazyExtensionValue
 }
 
-func (f *ExtensionField) appendLazyBytes(xt pref.ExtensionType, xi *extensionFieldInfo, num wire.Number, wtyp wire.Type, b []byte) {
+func (f *ExtensionField) appendLazyBytes(xt pref.ExtensionType, xi *extensionFieldInfo, num protowire.Number, wtyp protowire.Type, b []byte) {
 	if f.lazy == nil {
 		f.lazy = &lazyExtensionValue{xi: xi}
 	}
 	f.typ = xt
 	f.lazy.xi = xi
-	f.lazy.b = wire.AppendTag(f.lazy.b, num, wtyp)
+	f.lazy.b = protowire.AppendTag(f.lazy.b, num, wtyp)
 	f.lazy.b = append(f.lazy.b, b...)
 }
 
@@ -126,14 +126,14 @@
 				b = b[2:]
 			} else {
 				var n int
-				tag, n = wire.ConsumeVarint(b)
+				tag, n = protowire.ConsumeVarint(b)
 				if n < 0 {
 					panic(errors.New("bad tag in lazy extension decoding"))
 				}
 				b = b[n:]
 			}
-			num := wire.Number(tag >> 3)
-			wtyp := wire.Type(tag & 7)
+			num := protowire.Number(tag >> 3)
+			wtyp := protowire.Type(tag & 7)
 			var out unmarshalOutput
 			var err error
 			val, out, err = f.lazy.xi.funcs.unmarshal(b, val, num, wtyp, lazyUnmarshalOptions)
diff --git a/internal/impl/codec_field.go b/internal/impl/codec_field.go
index f9b6836..9497707 100644
--- a/internal/impl/codec_field.go
+++ b/internal/impl/codec_field.go
@@ -9,7 +9,7 @@
 	"reflect"
 	"sync"
 
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/proto"
 	pref "google.golang.org/protobuf/reflect/protoreflect"
 	preg "google.golang.org/protobuf/reflect/protoregistry"
@@ -51,7 +51,7 @@
 		if cf.funcs.isInit != nil {
 			needIsInit = true
 		}
-		mi.coderFields[num].funcs.unmarshal = func(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
+		mi.coderFields[num].funcs.unmarshal = func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
 			var vw reflect.Value         // pointer to wrapper type
 			vi := p.AsValueOf(ft).Elem() // oneof field value of interface kind
 			if !vi.IsNil() && !vi.Elem().IsNil() && vi.Elem().Elem().Type() == ot {
@@ -149,7 +149,7 @@
 			}
 			return appendMessage(b, m, f.wiretag, opts)
 		},
-		unmarshal: func(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
+		unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
 			fs := p.WeakFields()
 			m, ok := fs.get(f.num)
 			if !ok {
@@ -210,7 +210,7 @@
 				m := asMessage(p.AsValueOf(ft).Elem())
 				return appendMessage(b, m, f.wiretag, opts)
 			},
-			unmarshal: func(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
+			unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
 				mp := p.AsValueOf(ft).Elem()
 				if mp.IsNil() {
 					mp.Set(reflect.New(ft.Elem()))
@@ -227,22 +227,22 @@
 }
 
 func sizeMessageInfo(p pointer, f *coderFieldInfo, opts marshalOptions) int {
-	return wire.SizeBytes(f.mi.sizePointer(p.Elem(), opts)) + f.tagsize
+	return protowire.SizeBytes(f.mi.sizePointer(p.Elem(), opts)) + f.tagsize
 }
 
 func appendMessageInfo(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, uint64(f.mi.sizePointer(p.Elem(), opts)))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(f.mi.sizePointer(p.Elem(), opts)))
 	return f.mi.marshalAppendPointer(b, p.Elem(), opts)
 }
 
-func consumeMessageInfo(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.BytesType {
+func consumeMessageInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeBytes(b)
+	v, n := protowire.ConsumeBytes(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	if p.Elem().IsNil() {
 		p.SetPointer(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
@@ -261,22 +261,22 @@
 }
 
 func sizeMessage(m proto.Message, tagsize int, _ marshalOptions) int {
-	return wire.SizeBytes(proto.Size(m)) + tagsize
+	return protowire.SizeBytes(proto.Size(m)) + tagsize
 }
 
 func appendMessage(b []byte, m proto.Message, wiretag uint64, opts marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendVarint(b, uint64(proto.Size(m)))
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, uint64(proto.Size(m)))
 	return opts.Options().MarshalAppend(b, m)
 }
 
-func consumeMessage(b []byte, m proto.Message, wtyp wire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.BytesType {
+func consumeMessage(b []byte, m proto.Message, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeBytes(b)
+	v, n := protowire.ConsumeBytes(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
 		Buf:     v,
@@ -300,7 +300,7 @@
 	return appendMessage(b, m, wiretag, opts)
 }
 
-func consumeMessageValue(b []byte, v pref.Value, _ wire.Number, wtyp wire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error) {
+func consumeMessageValue(b []byte, v pref.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error) {
 	m := v.Message().Interface()
 	out, err := consumeMessage(b, m, wtyp, opts)
 	return v, out, err
@@ -329,7 +329,7 @@
 	return appendGroup(b, m, wiretag, opts)
 }
 
-func consumeGroupValue(b []byte, v pref.Value, num wire.Number, wtyp wire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error) {
+func consumeGroupValue(b []byte, v pref.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error) {
 	m := v.Message().Interface()
 	out, err := consumeGroup(b, m, num, wtyp, opts)
 	return v, out, err
@@ -366,7 +366,7 @@
 				m := asMessage(p.AsValueOf(ft).Elem())
 				return appendGroup(b, m, f.wiretag, opts)
 			},
-			unmarshal: func(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
+			unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
 				mp := p.AsValueOf(ft).Elem()
 				if mp.IsNil() {
 					mp.Set(reflect.New(ft.Elem()))
@@ -387,14 +387,14 @@
 }
 
 func appendGroupType(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, f.wiretag) // start group
+	b = protowire.AppendVarint(b, f.wiretag) // start group
 	b, err := f.mi.marshalAppendPointer(b, p.Elem(), opts)
-	b = wire.AppendVarint(b, f.wiretag+1) // end group
+	b = protowire.AppendVarint(b, f.wiretag+1) // end group
 	return b, err
 }
 
-func consumeGroupType(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.StartGroupType {
+func consumeGroupType(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.StartGroupType {
 		return out, errUnknown
 	}
 	if p.Elem().IsNil() {
@@ -408,19 +408,19 @@
 }
 
 func appendGroup(b []byte, m proto.Message, wiretag uint64, opts marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag) // start group
+	b = protowire.AppendVarint(b, wiretag) // start group
 	b, err := opts.Options().MarshalAppend(b, m)
-	b = wire.AppendVarint(b, wiretag+1) // end group
+	b = protowire.AppendVarint(b, wiretag+1) // end group
 	return b, err
 }
 
-func consumeGroup(b []byte, m proto.Message, num wire.Number, wtyp wire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.StartGroupType {
+func consumeGroup(b []byte, m proto.Message, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.StartGroupType {
 		return out, errUnknown
 	}
-	b, n := wire.ConsumeGroup(num, b)
+	b, n := protowire.ConsumeGroup(num, b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
 		Buf:     b,
@@ -454,7 +454,7 @@
 		marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
 			return appendMessageSlice(b, p, f.wiretag, ft, opts)
 		},
-		unmarshal: func(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
+		unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
 			return consumeMessageSlice(b, p, ft, wtyp, opts)
 		},
 		isInit: func(p pointer, f *coderFieldInfo) error {
@@ -468,7 +468,7 @@
 	s := p.PointerSlice()
 	n := 0
 	for _, v := range s {
-		n += wire.SizeBytes(f.mi.sizePointer(v, opts)) + f.tagsize
+		n += protowire.SizeBytes(f.mi.sizePointer(v, opts)) + f.tagsize
 	}
 	return n
 }
@@ -477,9 +477,9 @@
 	s := p.PointerSlice()
 	var err error
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, f.wiretag)
 		siz := f.mi.sizePointer(v, opts)
-		b = wire.AppendVarint(b, uint64(siz))
+		b = protowire.AppendVarint(b, uint64(siz))
 		b, err = f.mi.marshalAppendPointer(b, v, opts)
 		if err != nil {
 			return b, err
@@ -488,13 +488,13 @@
 	return b, nil
 }
 
-func consumeMessageSliceInfo(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.BytesType {
+func consumeMessageSliceInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeBytes(b)
+	v, n := protowire.ConsumeBytes(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	m := reflect.New(f.mi.GoReflectType.Elem()).Interface()
 	mp := pointerOfIface(m)
@@ -523,7 +523,7 @@
 	n := 0
 	for _, v := range s {
 		m := asMessage(v.AsValueOf(goType.Elem()))
-		n += wire.SizeBytes(proto.Size(m)) + tagsize
+		n += protowire.SizeBytes(proto.Size(m)) + tagsize
 	}
 	return n
 }
@@ -533,9 +533,9 @@
 	var err error
 	for _, v := range s {
 		m := asMessage(v.AsValueOf(goType.Elem()))
-		b = wire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, wiretag)
 		siz := proto.Size(m)
-		b = wire.AppendVarint(b, uint64(siz))
+		b = protowire.AppendVarint(b, uint64(siz))
 		b, err = opts.Options().MarshalAppend(b, m)
 		if err != nil {
 			return b, err
@@ -544,13 +544,13 @@
 	return b, nil
 }
 
-func consumeMessageSlice(b []byte, p pointer, goType reflect.Type, wtyp wire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.BytesType {
+func consumeMessageSlice(b []byte, p pointer, goType reflect.Type, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeBytes(b)
+	v, n := protowire.ConsumeBytes(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	mp := reflect.New(goType.Elem())
 	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
@@ -584,7 +584,7 @@
 	n := 0
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		m := list.Get(i).Message().Interface()
-		n += wire.SizeBytes(proto.Size(m)) + tagsize
+		n += protowire.SizeBytes(proto.Size(m)) + tagsize
 	}
 	return n
 }
@@ -594,9 +594,9 @@
 	mopts := opts.Options()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		m := list.Get(i).Message().Interface()
-		b = wire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, wiretag)
 		siz := proto.Size(m)
-		b = wire.AppendVarint(b, uint64(siz))
+		b = protowire.AppendVarint(b, uint64(siz))
 		var err error
 		b, err = mopts.MarshalAppend(b, m)
 		if err != nil {
@@ -606,14 +606,14 @@
 	return b, nil
 }
 
-func consumeMessageSliceValue(b []byte, listv pref.Value, _ wire.Number, wtyp wire.Type, opts unmarshalOptions) (_ pref.Value, out unmarshalOutput, err error) {
+func consumeMessageSliceValue(b []byte, listv pref.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ pref.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp != wire.BytesType {
+	if wtyp != protowire.BytesType {
 		return pref.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeBytes(b)
+	v, n := protowire.ConsumeBytes(b)
 	if n < 0 {
-		return pref.Value{}, out, wire.ParseError(n)
+		return pref.Value{}, out, protowire.ParseError(n)
 	}
 	m := list.NewElement()
 	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
@@ -663,25 +663,25 @@
 	mopts := opts.Options()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		m := list.Get(i).Message().Interface()
-		b = wire.AppendVarint(b, wiretag) // start group
+		b = protowire.AppendVarint(b, wiretag) // start group
 		var err error
 		b, err = mopts.MarshalAppend(b, m)
 		if err != nil {
 			return b, err
 		}
-		b = wire.AppendVarint(b, wiretag+1) // end group
+		b = protowire.AppendVarint(b, wiretag+1) // end group
 	}
 	return b, nil
 }
 
-func consumeGroupSliceValue(b []byte, listv pref.Value, num wire.Number, wtyp wire.Type, opts unmarshalOptions) (_ pref.Value, out unmarshalOutput, err error) {
+func consumeGroupSliceValue(b []byte, listv pref.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ pref.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp != wire.StartGroupType {
+	if wtyp != protowire.StartGroupType {
 		return pref.Value{}, out, errUnknown
 	}
-	b, n := wire.ConsumeGroup(num, b)
+	b, n := protowire.ConsumeGroup(num, b)
 	if n < 0 {
-		return pref.Value{}, out, wire.ParseError(n)
+		return pref.Value{}, out, protowire.ParseError(n)
 	}
 	m := list.NewElement()
 	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
@@ -726,7 +726,7 @@
 		marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
 			return appendGroupSlice(b, p, f.wiretag, ft, opts)
 		},
-		unmarshal: func(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
+		unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
 			return consumeGroupSlice(b, p, num, wtyp, ft, opts)
 		},
 		isInit: func(p pointer, f *coderFieldInfo) error {
@@ -751,23 +751,23 @@
 	var err error
 	for _, v := range s {
 		m := asMessage(v.AsValueOf(messageType.Elem()))
-		b = wire.AppendVarint(b, wiretag) // start group
+		b = protowire.AppendVarint(b, wiretag) // start group
 		b, err = opts.Options().MarshalAppend(b, m)
 		if err != nil {
 			return b, err
 		}
-		b = wire.AppendVarint(b, wiretag+1) // end group
+		b = protowire.AppendVarint(b, wiretag+1) // end group
 	}
 	return b, nil
 }
 
-func consumeGroupSlice(b []byte, p pointer, num wire.Number, wtyp wire.Type, goType reflect.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.StartGroupType {
+func consumeGroupSlice(b []byte, p pointer, num protowire.Number, wtyp protowire.Type, goType reflect.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.StartGroupType {
 		return out, errUnknown
 	}
-	b, n := wire.ConsumeGroup(num, b)
+	b, n := protowire.ConsumeGroup(num, b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	mp := reflect.New(goType.Elem())
 	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
@@ -796,18 +796,18 @@
 	s := p.PointerSlice()
 	var err error
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag) // start group
+		b = protowire.AppendVarint(b, f.wiretag) // start group
 		b, err = f.mi.marshalAppendPointer(b, v, opts)
 		if err != nil {
 			return b, err
 		}
-		b = wire.AppendVarint(b, f.wiretag+1) // end group
+		b = protowire.AppendVarint(b, f.wiretag+1) // end group
 	}
 	return b, nil
 }
 
-func consumeGroupSliceInfo(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
-	if wtyp != wire.StartGroupType {
+func consumeGroupSliceInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
+	if wtyp != protowire.StartGroupType {
 		return unmarshalOutput{}, errUnknown
 	}
 	m := reflect.New(f.mi.GoReflectType.Elem()).Interface()
diff --git a/internal/impl/codec_gen.go b/internal/impl/codec_gen.go
index 6036b66..2c43b11 100644
--- a/internal/impl/codec_gen.go
+++ b/internal/impl/codec_gen.go
@@ -10,27 +10,27 @@
 	"math"
 	"unicode/utf8"
 
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/reflect/protoreflect"
 )
 
 // sizeBool returns the size of wire encoding a bool pointer as a Bool.
 func sizeBool(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := *p.Bool()
-	return f.tagsize + wire.SizeVarint(wire.EncodeBool(v))
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
 }
 
 // appendBool wire encodes a bool pointer as a Bool.
 func appendBool(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.Bool()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, wire.EncodeBool(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeBool(v))
 	return b, nil
 }
 
 // consumeBool wire decodes a bool pointer as a Bool.
-func consumeBool(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeBool(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -42,12 +42,12 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
-	*p.Bool() = wire.DecodeBool(v)
+	*p.Bool() = protowire.DecodeBool(v)
 	out.n = n
 	return out, nil
 }
@@ -66,7 +66,7 @@
 	if v == false {
 		return 0
 	}
-	return f.tagsize + wire.SizeVarint(wire.EncodeBool(v))
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
 }
 
 // appendBoolNoZero wire encodes a bool pointer as a Bool.
@@ -76,8 +76,8 @@
 	if v == false {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, wire.EncodeBool(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeBool(v))
 	return b, nil
 }
 
@@ -92,21 +92,21 @@
 // It panics if the pointer is nil.
 func sizeBoolPtr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := **p.BoolPtr()
-	return f.tagsize + wire.SizeVarint(wire.EncodeBool(v))
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
 }
 
 // appendBoolPtr wire encodes a *bool pointer as a Bool.
 // It panics if the pointer is nil.
 func appendBoolPtr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := **p.BoolPtr()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, wire.EncodeBool(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeBool(v))
 	return b, nil
 }
 
 // consumeBoolPtr wire decodes a *bool pointer as a Bool.
-func consumeBoolPtr(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeBoolPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -118,16 +118,16 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	vp := p.BoolPtr()
 	if *vp == nil {
 		*vp = new(bool)
 	}
-	**vp = wire.DecodeBool(v)
+	**vp = protowire.DecodeBool(v)
 	out.n = n
 	return out, nil
 }
@@ -143,7 +143,7 @@
 func sizeBoolSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	s := *p.BoolSlice()
 	for _, v := range s {
-		size += f.tagsize + wire.SizeVarint(wire.EncodeBool(v))
+		size += f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
 	}
 	return size
 }
@@ -152,20 +152,20 @@
 func appendBoolSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.BoolSlice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendVarint(b, wire.EncodeBool(v))
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, protowire.EncodeBool(v))
 	}
 	return b, nil
 }
 
 // consumeBoolSlice wire decodes a []bool pointer as a repeated Bool.
-func consumeBoolSlice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeBoolSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.BoolSlice()
-	if wtyp == wire.BytesType {
+	if wtyp == protowire.BytesType {
 		s := *sp
-		b, n := wire.ConsumeBytes(b)
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			var v uint64
@@ -177,19 +177,19 @@
 				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 				n = 2
 			} else {
-				v, n = wire.ConsumeVarint(b)
+				v, n = protowire.ConsumeVarint(b)
 			}
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
-			s = append(s, wire.DecodeBool(v))
+			s = append(s, protowire.DecodeBool(v))
 			b = b[n:]
 		}
 		*sp = s
 		out.n = n
 		return out, nil
 	}
-	if wtyp != wire.VarintType {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -201,12 +201,12 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
-	*sp = append(*sp, wire.DecodeBool(v))
+	*sp = append(*sp, protowire.DecodeBool(v))
 	out.n = n
 	return out, nil
 }
@@ -226,9 +226,9 @@
 	}
 	n := 0
 	for _, v := range s {
-		n += wire.SizeVarint(wire.EncodeBool(v))
+		n += protowire.SizeVarint(protowire.EncodeBool(v))
 	}
-	return f.tagsize + wire.SizeBytes(n)
+	return f.tagsize + protowire.SizeBytes(n)
 }
 
 // appendBoolPackedSlice encodes a []bool pointer as a packed repeated Bool.
@@ -237,14 +237,14 @@
 	if len(s) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, f.wiretag)
 	n := 0
 	for _, v := range s {
-		n += wire.SizeVarint(wire.EncodeBool(v))
+		n += protowire.SizeVarint(protowire.EncodeBool(v))
 	}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for _, v := range s {
-		b = wire.AppendVarint(b, wire.EncodeBool(v))
+		b = protowire.AppendVarint(b, protowire.EncodeBool(v))
 	}
 	return b, nil
 }
@@ -258,19 +258,19 @@
 
 // sizeBoolValue returns the size of wire encoding a bool value as a Bool.
 func sizeBoolValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + wire.SizeVarint(wire.EncodeBool(v.Bool()))
+	return tagsize + protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
 }
 
 // appendBoolValue encodes a bool value as a Bool.
 func appendBoolValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendVarint(b, wire.EncodeBool(v.Bool()))
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
 	return b, nil
 }
 
 // consumeBoolValue decodes a bool value as a Bool.
-func consumeBoolValue(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeBoolValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	var v uint64
@@ -282,13 +282,13 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
-	return protoreflect.ValueOfBool(wire.DecodeBool(v)), out, nil
+	return protoreflect.ValueOfBool(protowire.DecodeBool(v)), out, nil
 }
 
 var coderBoolValue = valueCoderFuncs{
@@ -303,7 +303,7 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		size += tagsize + wire.SizeVarint(wire.EncodeBool(v.Bool()))
+		size += tagsize + protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
 	}
 	return size
 }
@@ -313,19 +313,19 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
-		b = wire.AppendVarint(b, wire.EncodeBool(v.Bool()))
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
 	}
 	return b, nil
 }
 
 // consumeBoolSliceValue wire decodes a []bool value as a repeated Bool.
-func consumeBoolSliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consumeBoolSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp == wire.BytesType {
-		b, n := wire.ConsumeBytes(b)
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return protoreflect.Value{}, out, wire.ParseError(n)
+			return protoreflect.Value{}, out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			var v uint64
@@ -337,18 +337,18 @@
 				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 				n = 2
 			} else {
-				v, n = wire.ConsumeVarint(b)
+				v, n = protowire.ConsumeVarint(b)
 			}
 			if n < 0 {
-				return protoreflect.Value{}, out, wire.ParseError(n)
+				return protoreflect.Value{}, out, protowire.ParseError(n)
 			}
-			list.Append(protoreflect.ValueOfBool(wire.DecodeBool(v)))
+			list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
 			b = b[n:]
 		}
 		out.n = n
 		return listv, out, nil
 	}
-	if wtyp != wire.VarintType {
+	if wtyp != protowire.VarintType {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	var v uint64
@@ -360,12 +360,12 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
-	list.Append(protoreflect.ValueOfBool(wire.DecodeBool(v)))
+	list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
 	out.n = n
 	return listv, out, nil
 }
@@ -387,9 +387,9 @@
 	n := 0
 	for i, llen := 0, llen; i < llen; i++ {
 		v := list.Get(i)
-		n += wire.SizeVarint(wire.EncodeBool(v.Bool()))
+		n += protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
 	}
-	return tagsize + wire.SizeBytes(n)
+	return tagsize + protowire.SizeBytes(n)
 }
 
 // appendBoolPackedSliceValue encodes a []bool value as a packed repeated Bool.
@@ -399,16 +399,16 @@
 	if llen == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, wiretag)
 	n := 0
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		n += wire.SizeVarint(wire.EncodeBool(v.Bool()))
+		n += protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
 	}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wire.EncodeBool(v.Bool()))
+		b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
 	}
 	return b, nil
 }
@@ -422,19 +422,19 @@
 
 // sizeEnumValue returns the size of wire encoding a  value as a Enum.
 func sizeEnumValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + wire.SizeVarint(uint64(v.Enum()))
+	return tagsize + protowire.SizeVarint(uint64(v.Enum()))
 }
 
 // appendEnumValue encodes a  value as a Enum.
 func appendEnumValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendVarint(b, uint64(v.Enum()))
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, uint64(v.Enum()))
 	return b, nil
 }
 
 // consumeEnumValue decodes a  value as a Enum.
-func consumeEnumValue(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeEnumValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	var v uint64
@@ -446,10 +446,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
 	return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)), out, nil
@@ -467,7 +467,7 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		size += tagsize + wire.SizeVarint(uint64(v.Enum()))
+		size += tagsize + protowire.SizeVarint(uint64(v.Enum()))
 	}
 	return size
 }
@@ -477,19 +477,19 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
-		b = wire.AppendVarint(b, uint64(v.Enum()))
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, uint64(v.Enum()))
 	}
 	return b, nil
 }
 
 // consumeEnumSliceValue wire decodes a [] value as a repeated Enum.
-func consumeEnumSliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consumeEnumSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp == wire.BytesType {
-		b, n := wire.ConsumeBytes(b)
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return protoreflect.Value{}, out, wire.ParseError(n)
+			return protoreflect.Value{}, out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			var v uint64
@@ -501,10 +501,10 @@
 				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 				n = 2
 			} else {
-				v, n = wire.ConsumeVarint(b)
+				v, n = protowire.ConsumeVarint(b)
 			}
 			if n < 0 {
-				return protoreflect.Value{}, out, wire.ParseError(n)
+				return protoreflect.Value{}, out, protowire.ParseError(n)
 			}
 			list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
 			b = b[n:]
@@ -512,7 +512,7 @@
 		out.n = n
 		return listv, out, nil
 	}
-	if wtyp != wire.VarintType {
+	if wtyp != protowire.VarintType {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	var v uint64
@@ -524,10 +524,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
 	out.n = n
@@ -551,9 +551,9 @@
 	n := 0
 	for i, llen := 0, llen; i < llen; i++ {
 		v := list.Get(i)
-		n += wire.SizeVarint(uint64(v.Enum()))
+		n += protowire.SizeVarint(uint64(v.Enum()))
 	}
-	return tagsize + wire.SizeBytes(n)
+	return tagsize + protowire.SizeBytes(n)
 }
 
 // appendEnumPackedSliceValue encodes a [] value as a packed repeated Enum.
@@ -563,16 +563,16 @@
 	if llen == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, wiretag)
 	n := 0
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		n += wire.SizeVarint(uint64(v.Enum()))
+		n += protowire.SizeVarint(uint64(v.Enum()))
 	}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, uint64(v.Enum()))
+		b = protowire.AppendVarint(b, uint64(v.Enum()))
 	}
 	return b, nil
 }
@@ -587,20 +587,20 @@
 // sizeInt32 returns the size of wire encoding a int32 pointer as a Int32.
 func sizeInt32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := *p.Int32()
-	return f.tagsize + wire.SizeVarint(uint64(v))
+	return f.tagsize + protowire.SizeVarint(uint64(v))
 }
 
 // appendInt32 wire encodes a int32 pointer as a Int32.
 func appendInt32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.Int32()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, uint64(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
 	return b, nil
 }
 
 // consumeInt32 wire decodes a int32 pointer as a Int32.
-func consumeInt32(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeInt32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -612,10 +612,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*p.Int32() = int32(v)
 	out.n = n
@@ -636,7 +636,7 @@
 	if v == 0 {
 		return 0
 	}
-	return f.tagsize + wire.SizeVarint(uint64(v))
+	return f.tagsize + protowire.SizeVarint(uint64(v))
 }
 
 // appendInt32NoZero wire encodes a int32 pointer as a Int32.
@@ -646,8 +646,8 @@
 	if v == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, uint64(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
 	return b, nil
 }
 
@@ -662,21 +662,21 @@
 // It panics if the pointer is nil.
 func sizeInt32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := **p.Int32Ptr()
-	return f.tagsize + wire.SizeVarint(uint64(v))
+	return f.tagsize + protowire.SizeVarint(uint64(v))
 }
 
 // appendInt32Ptr wire encodes a *int32 pointer as a Int32.
 // It panics if the pointer is nil.
 func appendInt32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := **p.Int32Ptr()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, uint64(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
 	return b, nil
 }
 
 // consumeInt32Ptr wire decodes a *int32 pointer as a Int32.
-func consumeInt32Ptr(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeInt32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -688,10 +688,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	vp := p.Int32Ptr()
 	if *vp == nil {
@@ -713,7 +713,7 @@
 func sizeInt32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	s := *p.Int32Slice()
 	for _, v := range s {
-		size += f.tagsize + wire.SizeVarint(uint64(v))
+		size += f.tagsize + protowire.SizeVarint(uint64(v))
 	}
 	return size
 }
@@ -722,20 +722,20 @@
 func appendInt32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.Int32Slice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendVarint(b, uint64(v))
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, uint64(v))
 	}
 	return b, nil
 }
 
 // consumeInt32Slice wire decodes a []int32 pointer as a repeated Int32.
-func consumeInt32Slice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeInt32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.Int32Slice()
-	if wtyp == wire.BytesType {
+	if wtyp == protowire.BytesType {
 		s := *sp
-		b, n := wire.ConsumeBytes(b)
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			var v uint64
@@ -747,10 +747,10 @@
 				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 				n = 2
 			} else {
-				v, n = wire.ConsumeVarint(b)
+				v, n = protowire.ConsumeVarint(b)
 			}
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 			s = append(s, int32(v))
 			b = b[n:]
@@ -759,7 +759,7 @@
 		out.n = n
 		return out, nil
 	}
-	if wtyp != wire.VarintType {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -771,10 +771,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*sp = append(*sp, int32(v))
 	out.n = n
@@ -796,9 +796,9 @@
 	}
 	n := 0
 	for _, v := range s {
-		n += wire.SizeVarint(uint64(v))
+		n += protowire.SizeVarint(uint64(v))
 	}
-	return f.tagsize + wire.SizeBytes(n)
+	return f.tagsize + protowire.SizeBytes(n)
 }
 
 // appendInt32PackedSlice encodes a []int32 pointer as a packed repeated Int32.
@@ -807,14 +807,14 @@
 	if len(s) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, f.wiretag)
 	n := 0
 	for _, v := range s {
-		n += wire.SizeVarint(uint64(v))
+		n += protowire.SizeVarint(uint64(v))
 	}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for _, v := range s {
-		b = wire.AppendVarint(b, uint64(v))
+		b = protowire.AppendVarint(b, uint64(v))
 	}
 	return b, nil
 }
@@ -828,19 +828,19 @@
 
 // sizeInt32Value returns the size of wire encoding a int32 value as a Int32.
 func sizeInt32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + wire.SizeVarint(uint64(int32(v.Int())))
+	return tagsize + protowire.SizeVarint(uint64(int32(v.Int())))
 }
 
 // appendInt32Value encodes a int32 value as a Int32.
 func appendInt32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendVarint(b, uint64(int32(v.Int())))
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, uint64(int32(v.Int())))
 	return b, nil
 }
 
 // consumeInt32Value decodes a int32 value as a Int32.
-func consumeInt32Value(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeInt32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	var v uint64
@@ -852,10 +852,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
 	return protoreflect.ValueOfInt32(int32(v)), out, nil
@@ -873,7 +873,7 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		size += tagsize + wire.SizeVarint(uint64(int32(v.Int())))
+		size += tagsize + protowire.SizeVarint(uint64(int32(v.Int())))
 	}
 	return size
 }
@@ -883,19 +883,19 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
-		b = wire.AppendVarint(b, uint64(int32(v.Int())))
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, uint64(int32(v.Int())))
 	}
 	return b, nil
 }
 
 // consumeInt32SliceValue wire decodes a []int32 value as a repeated Int32.
-func consumeInt32SliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consumeInt32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp == wire.BytesType {
-		b, n := wire.ConsumeBytes(b)
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return protoreflect.Value{}, out, wire.ParseError(n)
+			return protoreflect.Value{}, out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			var v uint64
@@ -907,10 +907,10 @@
 				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 				n = 2
 			} else {
-				v, n = wire.ConsumeVarint(b)
+				v, n = protowire.ConsumeVarint(b)
 			}
 			if n < 0 {
-				return protoreflect.Value{}, out, wire.ParseError(n)
+				return protoreflect.Value{}, out, protowire.ParseError(n)
 			}
 			list.Append(protoreflect.ValueOfInt32(int32(v)))
 			b = b[n:]
@@ -918,7 +918,7 @@
 		out.n = n
 		return listv, out, nil
 	}
-	if wtyp != wire.VarintType {
+	if wtyp != protowire.VarintType {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	var v uint64
@@ -930,10 +930,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	list.Append(protoreflect.ValueOfInt32(int32(v)))
 	out.n = n
@@ -957,9 +957,9 @@
 	n := 0
 	for i, llen := 0, llen; i < llen; i++ {
 		v := list.Get(i)
-		n += wire.SizeVarint(uint64(int32(v.Int())))
+		n += protowire.SizeVarint(uint64(int32(v.Int())))
 	}
-	return tagsize + wire.SizeBytes(n)
+	return tagsize + protowire.SizeBytes(n)
 }
 
 // appendInt32PackedSliceValue encodes a []int32 value as a packed repeated Int32.
@@ -969,16 +969,16 @@
 	if llen == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, wiretag)
 	n := 0
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		n += wire.SizeVarint(uint64(int32(v.Int())))
+		n += protowire.SizeVarint(uint64(int32(v.Int())))
 	}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, uint64(int32(v.Int())))
+		b = protowire.AppendVarint(b, uint64(int32(v.Int())))
 	}
 	return b, nil
 }
@@ -993,20 +993,20 @@
 // sizeSint32 returns the size of wire encoding a int32 pointer as a Sint32.
 func sizeSint32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := *p.Int32()
-	return f.tagsize + wire.SizeVarint(wire.EncodeZigZag(int64(v)))
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
 }
 
 // appendSint32 wire encodes a int32 pointer as a Sint32.
 func appendSint32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.Int32()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, wire.EncodeZigZag(int64(v)))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
 	return b, nil
 }
 
 // consumeSint32 wire decodes a int32 pointer as a Sint32.
-func consumeSint32(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeSint32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -1018,12 +1018,12 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
-	*p.Int32() = int32(wire.DecodeZigZag(v & math.MaxUint32))
+	*p.Int32() = int32(protowire.DecodeZigZag(v & math.MaxUint32))
 	out.n = n
 	return out, nil
 }
@@ -1042,7 +1042,7 @@
 	if v == 0 {
 		return 0
 	}
-	return f.tagsize + wire.SizeVarint(wire.EncodeZigZag(int64(v)))
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
 }
 
 // appendSint32NoZero wire encodes a int32 pointer as a Sint32.
@@ -1052,8 +1052,8 @@
 	if v == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, wire.EncodeZigZag(int64(v)))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
 	return b, nil
 }
 
@@ -1068,21 +1068,21 @@
 // It panics if the pointer is nil.
 func sizeSint32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := **p.Int32Ptr()
-	return f.tagsize + wire.SizeVarint(wire.EncodeZigZag(int64(v)))
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
 }
 
 // appendSint32Ptr wire encodes a *int32 pointer as a Sint32.
 // It panics if the pointer is nil.
 func appendSint32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := **p.Int32Ptr()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, wire.EncodeZigZag(int64(v)))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
 	return b, nil
 }
 
 // consumeSint32Ptr wire decodes a *int32 pointer as a Sint32.
-func consumeSint32Ptr(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeSint32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -1094,16 +1094,16 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	vp := p.Int32Ptr()
 	if *vp == nil {
 		*vp = new(int32)
 	}
-	**vp = int32(wire.DecodeZigZag(v & math.MaxUint32))
+	**vp = int32(protowire.DecodeZigZag(v & math.MaxUint32))
 	out.n = n
 	return out, nil
 }
@@ -1119,7 +1119,7 @@
 func sizeSint32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	s := *p.Int32Slice()
 	for _, v := range s {
-		size += f.tagsize + wire.SizeVarint(wire.EncodeZigZag(int64(v)))
+		size += f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
 	}
 	return size
 }
@@ -1128,20 +1128,20 @@
 func appendSint32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.Int32Slice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendVarint(b, wire.EncodeZigZag(int64(v)))
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
 	}
 	return b, nil
 }
 
 // consumeSint32Slice wire decodes a []int32 pointer as a repeated Sint32.
-func consumeSint32Slice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeSint32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.Int32Slice()
-	if wtyp == wire.BytesType {
+	if wtyp == protowire.BytesType {
 		s := *sp
-		b, n := wire.ConsumeBytes(b)
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			var v uint64
@@ -1153,19 +1153,19 @@
 				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 				n = 2
 			} else {
-				v, n = wire.ConsumeVarint(b)
+				v, n = protowire.ConsumeVarint(b)
 			}
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
-			s = append(s, int32(wire.DecodeZigZag(v&math.MaxUint32)))
+			s = append(s, int32(protowire.DecodeZigZag(v&math.MaxUint32)))
 			b = b[n:]
 		}
 		*sp = s
 		out.n = n
 		return out, nil
 	}
-	if wtyp != wire.VarintType {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -1177,12 +1177,12 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
-	*sp = append(*sp, int32(wire.DecodeZigZag(v&math.MaxUint32)))
+	*sp = append(*sp, int32(protowire.DecodeZigZag(v&math.MaxUint32)))
 	out.n = n
 	return out, nil
 }
@@ -1202,9 +1202,9 @@
 	}
 	n := 0
 	for _, v := range s {
-		n += wire.SizeVarint(wire.EncodeZigZag(int64(v)))
+		n += protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
 	}
-	return f.tagsize + wire.SizeBytes(n)
+	return f.tagsize + protowire.SizeBytes(n)
 }
 
 // appendSint32PackedSlice encodes a []int32 pointer as a packed repeated Sint32.
@@ -1213,14 +1213,14 @@
 	if len(s) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, f.wiretag)
 	n := 0
 	for _, v := range s {
-		n += wire.SizeVarint(wire.EncodeZigZag(int64(v)))
+		n += protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
 	}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for _, v := range s {
-		b = wire.AppendVarint(b, wire.EncodeZigZag(int64(v)))
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
 	}
 	return b, nil
 }
@@ -1234,19 +1234,19 @@
 
 // sizeSint32Value returns the size of wire encoding a int32 value as a Sint32.
 func sizeSint32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + wire.SizeVarint(wire.EncodeZigZag(int64(int32(v.Int()))))
+	return tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
 }
 
 // appendSint32Value encodes a int32 value as a Sint32.
 func appendSint32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendVarint(b, wire.EncodeZigZag(int64(int32(v.Int()))))
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
 	return b, nil
 }
 
 // consumeSint32Value decodes a int32 value as a Sint32.
-func consumeSint32Value(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeSint32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	var v uint64
@@ -1258,13 +1258,13 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
-	return protoreflect.ValueOfInt32(int32(wire.DecodeZigZag(v & math.MaxUint32))), out, nil
+	return protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))), out, nil
 }
 
 var coderSint32Value = valueCoderFuncs{
@@ -1279,7 +1279,7 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		size += tagsize + wire.SizeVarint(wire.EncodeZigZag(int64(int32(v.Int()))))
+		size += tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
 	}
 	return size
 }
@@ -1289,19 +1289,19 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
-		b = wire.AppendVarint(b, wire.EncodeZigZag(int64(int32(v.Int()))))
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
 	}
 	return b, nil
 }
 
 // consumeSint32SliceValue wire decodes a []int32 value as a repeated Sint32.
-func consumeSint32SliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consumeSint32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp == wire.BytesType {
-		b, n := wire.ConsumeBytes(b)
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return protoreflect.Value{}, out, wire.ParseError(n)
+			return protoreflect.Value{}, out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			var v uint64
@@ -1313,18 +1313,18 @@
 				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 				n = 2
 			} else {
-				v, n = wire.ConsumeVarint(b)
+				v, n = protowire.ConsumeVarint(b)
 			}
 			if n < 0 {
-				return protoreflect.Value{}, out, wire.ParseError(n)
+				return protoreflect.Value{}, out, protowire.ParseError(n)
 			}
-			list.Append(protoreflect.ValueOfInt32(int32(wire.DecodeZigZag(v & math.MaxUint32))))
+			list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
 			b = b[n:]
 		}
 		out.n = n
 		return listv, out, nil
 	}
-	if wtyp != wire.VarintType {
+	if wtyp != protowire.VarintType {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	var v uint64
@@ -1336,12 +1336,12 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
-	list.Append(protoreflect.ValueOfInt32(int32(wire.DecodeZigZag(v & math.MaxUint32))))
+	list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
 	out.n = n
 	return listv, out, nil
 }
@@ -1363,9 +1363,9 @@
 	n := 0
 	for i, llen := 0, llen; i < llen; i++ {
 		v := list.Get(i)
-		n += wire.SizeVarint(wire.EncodeZigZag(int64(int32(v.Int()))))
+		n += protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
 	}
-	return tagsize + wire.SizeBytes(n)
+	return tagsize + protowire.SizeBytes(n)
 }
 
 // appendSint32PackedSliceValue encodes a []int32 value as a packed repeated Sint32.
@@ -1375,16 +1375,16 @@
 	if llen == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, wiretag)
 	n := 0
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		n += wire.SizeVarint(wire.EncodeZigZag(int64(int32(v.Int()))))
+		n += protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
 	}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wire.EncodeZigZag(int64(int32(v.Int()))))
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
 	}
 	return b, nil
 }
@@ -1399,20 +1399,20 @@
 // sizeUint32 returns the size of wire encoding a uint32 pointer as a Uint32.
 func sizeUint32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := *p.Uint32()
-	return f.tagsize + wire.SizeVarint(uint64(v))
+	return f.tagsize + protowire.SizeVarint(uint64(v))
 }
 
 // appendUint32 wire encodes a uint32 pointer as a Uint32.
 func appendUint32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.Uint32()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, uint64(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
 	return b, nil
 }
 
 // consumeUint32 wire decodes a uint32 pointer as a Uint32.
-func consumeUint32(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeUint32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -1424,10 +1424,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*p.Uint32() = uint32(v)
 	out.n = n
@@ -1448,7 +1448,7 @@
 	if v == 0 {
 		return 0
 	}
-	return f.tagsize + wire.SizeVarint(uint64(v))
+	return f.tagsize + protowire.SizeVarint(uint64(v))
 }
 
 // appendUint32NoZero wire encodes a uint32 pointer as a Uint32.
@@ -1458,8 +1458,8 @@
 	if v == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, uint64(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
 	return b, nil
 }
 
@@ -1474,21 +1474,21 @@
 // It panics if the pointer is nil.
 func sizeUint32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := **p.Uint32Ptr()
-	return f.tagsize + wire.SizeVarint(uint64(v))
+	return f.tagsize + protowire.SizeVarint(uint64(v))
 }
 
 // appendUint32Ptr wire encodes a *uint32 pointer as a Uint32.
 // It panics if the pointer is nil.
 func appendUint32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := **p.Uint32Ptr()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, uint64(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
 	return b, nil
 }
 
 // consumeUint32Ptr wire decodes a *uint32 pointer as a Uint32.
-func consumeUint32Ptr(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeUint32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -1500,10 +1500,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	vp := p.Uint32Ptr()
 	if *vp == nil {
@@ -1525,7 +1525,7 @@
 func sizeUint32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	s := *p.Uint32Slice()
 	for _, v := range s {
-		size += f.tagsize + wire.SizeVarint(uint64(v))
+		size += f.tagsize + protowire.SizeVarint(uint64(v))
 	}
 	return size
 }
@@ -1534,20 +1534,20 @@
 func appendUint32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.Uint32Slice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendVarint(b, uint64(v))
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, uint64(v))
 	}
 	return b, nil
 }
 
 // consumeUint32Slice wire decodes a []uint32 pointer as a repeated Uint32.
-func consumeUint32Slice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeUint32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.Uint32Slice()
-	if wtyp == wire.BytesType {
+	if wtyp == protowire.BytesType {
 		s := *sp
-		b, n := wire.ConsumeBytes(b)
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			var v uint64
@@ -1559,10 +1559,10 @@
 				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 				n = 2
 			} else {
-				v, n = wire.ConsumeVarint(b)
+				v, n = protowire.ConsumeVarint(b)
 			}
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 			s = append(s, uint32(v))
 			b = b[n:]
@@ -1571,7 +1571,7 @@
 		out.n = n
 		return out, nil
 	}
-	if wtyp != wire.VarintType {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -1583,10 +1583,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*sp = append(*sp, uint32(v))
 	out.n = n
@@ -1608,9 +1608,9 @@
 	}
 	n := 0
 	for _, v := range s {
-		n += wire.SizeVarint(uint64(v))
+		n += protowire.SizeVarint(uint64(v))
 	}
-	return f.tagsize + wire.SizeBytes(n)
+	return f.tagsize + protowire.SizeBytes(n)
 }
 
 // appendUint32PackedSlice encodes a []uint32 pointer as a packed repeated Uint32.
@@ -1619,14 +1619,14 @@
 	if len(s) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, f.wiretag)
 	n := 0
 	for _, v := range s {
-		n += wire.SizeVarint(uint64(v))
+		n += protowire.SizeVarint(uint64(v))
 	}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for _, v := range s {
-		b = wire.AppendVarint(b, uint64(v))
+		b = protowire.AppendVarint(b, uint64(v))
 	}
 	return b, nil
 }
@@ -1640,19 +1640,19 @@
 
 // sizeUint32Value returns the size of wire encoding a uint32 value as a Uint32.
 func sizeUint32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + wire.SizeVarint(uint64(uint32(v.Uint())))
+	return tagsize + protowire.SizeVarint(uint64(uint32(v.Uint())))
 }
 
 // appendUint32Value encodes a uint32 value as a Uint32.
 func appendUint32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendVarint(b, uint64(uint32(v.Uint())))
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
 	return b, nil
 }
 
 // consumeUint32Value decodes a uint32 value as a Uint32.
-func consumeUint32Value(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeUint32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	var v uint64
@@ -1664,10 +1664,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
 	return protoreflect.ValueOfUint32(uint32(v)), out, nil
@@ -1685,7 +1685,7 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		size += tagsize + wire.SizeVarint(uint64(uint32(v.Uint())))
+		size += tagsize + protowire.SizeVarint(uint64(uint32(v.Uint())))
 	}
 	return size
 }
@@ -1695,19 +1695,19 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
-		b = wire.AppendVarint(b, uint64(uint32(v.Uint())))
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
 	}
 	return b, nil
 }
 
 // consumeUint32SliceValue wire decodes a []uint32 value as a repeated Uint32.
-func consumeUint32SliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consumeUint32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp == wire.BytesType {
-		b, n := wire.ConsumeBytes(b)
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return protoreflect.Value{}, out, wire.ParseError(n)
+			return protoreflect.Value{}, out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			var v uint64
@@ -1719,10 +1719,10 @@
 				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 				n = 2
 			} else {
-				v, n = wire.ConsumeVarint(b)
+				v, n = protowire.ConsumeVarint(b)
 			}
 			if n < 0 {
-				return protoreflect.Value{}, out, wire.ParseError(n)
+				return protoreflect.Value{}, out, protowire.ParseError(n)
 			}
 			list.Append(protoreflect.ValueOfUint32(uint32(v)))
 			b = b[n:]
@@ -1730,7 +1730,7 @@
 		out.n = n
 		return listv, out, nil
 	}
-	if wtyp != wire.VarintType {
+	if wtyp != protowire.VarintType {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	var v uint64
@@ -1742,10 +1742,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	list.Append(protoreflect.ValueOfUint32(uint32(v)))
 	out.n = n
@@ -1769,9 +1769,9 @@
 	n := 0
 	for i, llen := 0, llen; i < llen; i++ {
 		v := list.Get(i)
-		n += wire.SizeVarint(uint64(uint32(v.Uint())))
+		n += protowire.SizeVarint(uint64(uint32(v.Uint())))
 	}
-	return tagsize + wire.SizeBytes(n)
+	return tagsize + protowire.SizeBytes(n)
 }
 
 // appendUint32PackedSliceValue encodes a []uint32 value as a packed repeated Uint32.
@@ -1781,16 +1781,16 @@
 	if llen == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, wiretag)
 	n := 0
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		n += wire.SizeVarint(uint64(uint32(v.Uint())))
+		n += protowire.SizeVarint(uint64(uint32(v.Uint())))
 	}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, uint64(uint32(v.Uint())))
+		b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
 	}
 	return b, nil
 }
@@ -1805,20 +1805,20 @@
 // sizeInt64 returns the size of wire encoding a int64 pointer as a Int64.
 func sizeInt64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := *p.Int64()
-	return f.tagsize + wire.SizeVarint(uint64(v))
+	return f.tagsize + protowire.SizeVarint(uint64(v))
 }
 
 // appendInt64 wire encodes a int64 pointer as a Int64.
 func appendInt64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.Int64()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, uint64(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
 	return b, nil
 }
 
 // consumeInt64 wire decodes a int64 pointer as a Int64.
-func consumeInt64(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeInt64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -1830,10 +1830,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*p.Int64() = int64(v)
 	out.n = n
@@ -1854,7 +1854,7 @@
 	if v == 0 {
 		return 0
 	}
-	return f.tagsize + wire.SizeVarint(uint64(v))
+	return f.tagsize + protowire.SizeVarint(uint64(v))
 }
 
 // appendInt64NoZero wire encodes a int64 pointer as a Int64.
@@ -1864,8 +1864,8 @@
 	if v == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, uint64(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
 	return b, nil
 }
 
@@ -1880,21 +1880,21 @@
 // It panics if the pointer is nil.
 func sizeInt64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := **p.Int64Ptr()
-	return f.tagsize + wire.SizeVarint(uint64(v))
+	return f.tagsize + protowire.SizeVarint(uint64(v))
 }
 
 // appendInt64Ptr wire encodes a *int64 pointer as a Int64.
 // It panics if the pointer is nil.
 func appendInt64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := **p.Int64Ptr()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, uint64(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
 	return b, nil
 }
 
 // consumeInt64Ptr wire decodes a *int64 pointer as a Int64.
-func consumeInt64Ptr(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeInt64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -1906,10 +1906,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	vp := p.Int64Ptr()
 	if *vp == nil {
@@ -1931,7 +1931,7 @@
 func sizeInt64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	s := *p.Int64Slice()
 	for _, v := range s {
-		size += f.tagsize + wire.SizeVarint(uint64(v))
+		size += f.tagsize + protowire.SizeVarint(uint64(v))
 	}
 	return size
 }
@@ -1940,20 +1940,20 @@
 func appendInt64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.Int64Slice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendVarint(b, uint64(v))
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, uint64(v))
 	}
 	return b, nil
 }
 
 // consumeInt64Slice wire decodes a []int64 pointer as a repeated Int64.
-func consumeInt64Slice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeInt64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.Int64Slice()
-	if wtyp == wire.BytesType {
+	if wtyp == protowire.BytesType {
 		s := *sp
-		b, n := wire.ConsumeBytes(b)
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			var v uint64
@@ -1965,10 +1965,10 @@
 				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 				n = 2
 			} else {
-				v, n = wire.ConsumeVarint(b)
+				v, n = protowire.ConsumeVarint(b)
 			}
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 			s = append(s, int64(v))
 			b = b[n:]
@@ -1977,7 +1977,7 @@
 		out.n = n
 		return out, nil
 	}
-	if wtyp != wire.VarintType {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -1989,10 +1989,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*sp = append(*sp, int64(v))
 	out.n = n
@@ -2014,9 +2014,9 @@
 	}
 	n := 0
 	for _, v := range s {
-		n += wire.SizeVarint(uint64(v))
+		n += protowire.SizeVarint(uint64(v))
 	}
-	return f.tagsize + wire.SizeBytes(n)
+	return f.tagsize + protowire.SizeBytes(n)
 }
 
 // appendInt64PackedSlice encodes a []int64 pointer as a packed repeated Int64.
@@ -2025,14 +2025,14 @@
 	if len(s) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, f.wiretag)
 	n := 0
 	for _, v := range s {
-		n += wire.SizeVarint(uint64(v))
+		n += protowire.SizeVarint(uint64(v))
 	}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for _, v := range s {
-		b = wire.AppendVarint(b, uint64(v))
+		b = protowire.AppendVarint(b, uint64(v))
 	}
 	return b, nil
 }
@@ -2046,19 +2046,19 @@
 
 // sizeInt64Value returns the size of wire encoding a int64 value as a Int64.
 func sizeInt64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + wire.SizeVarint(uint64(v.Int()))
+	return tagsize + protowire.SizeVarint(uint64(v.Int()))
 }
 
 // appendInt64Value encodes a int64 value as a Int64.
 func appendInt64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendVarint(b, uint64(v.Int()))
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, uint64(v.Int()))
 	return b, nil
 }
 
 // consumeInt64Value decodes a int64 value as a Int64.
-func consumeInt64Value(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeInt64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	var v uint64
@@ -2070,10 +2070,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
 	return protoreflect.ValueOfInt64(int64(v)), out, nil
@@ -2091,7 +2091,7 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		size += tagsize + wire.SizeVarint(uint64(v.Int()))
+		size += tagsize + protowire.SizeVarint(uint64(v.Int()))
 	}
 	return size
 }
@@ -2101,19 +2101,19 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
-		b = wire.AppendVarint(b, uint64(v.Int()))
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, uint64(v.Int()))
 	}
 	return b, nil
 }
 
 // consumeInt64SliceValue wire decodes a []int64 value as a repeated Int64.
-func consumeInt64SliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consumeInt64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp == wire.BytesType {
-		b, n := wire.ConsumeBytes(b)
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return protoreflect.Value{}, out, wire.ParseError(n)
+			return protoreflect.Value{}, out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			var v uint64
@@ -2125,10 +2125,10 @@
 				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 				n = 2
 			} else {
-				v, n = wire.ConsumeVarint(b)
+				v, n = protowire.ConsumeVarint(b)
 			}
 			if n < 0 {
-				return protoreflect.Value{}, out, wire.ParseError(n)
+				return protoreflect.Value{}, out, protowire.ParseError(n)
 			}
 			list.Append(protoreflect.ValueOfInt64(int64(v)))
 			b = b[n:]
@@ -2136,7 +2136,7 @@
 		out.n = n
 		return listv, out, nil
 	}
-	if wtyp != wire.VarintType {
+	if wtyp != protowire.VarintType {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	var v uint64
@@ -2148,10 +2148,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	list.Append(protoreflect.ValueOfInt64(int64(v)))
 	out.n = n
@@ -2175,9 +2175,9 @@
 	n := 0
 	for i, llen := 0, llen; i < llen; i++ {
 		v := list.Get(i)
-		n += wire.SizeVarint(uint64(v.Int()))
+		n += protowire.SizeVarint(uint64(v.Int()))
 	}
-	return tagsize + wire.SizeBytes(n)
+	return tagsize + protowire.SizeBytes(n)
 }
 
 // appendInt64PackedSliceValue encodes a []int64 value as a packed repeated Int64.
@@ -2187,16 +2187,16 @@
 	if llen == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, wiretag)
 	n := 0
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		n += wire.SizeVarint(uint64(v.Int()))
+		n += protowire.SizeVarint(uint64(v.Int()))
 	}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, uint64(v.Int()))
+		b = protowire.AppendVarint(b, uint64(v.Int()))
 	}
 	return b, nil
 }
@@ -2211,20 +2211,20 @@
 // sizeSint64 returns the size of wire encoding a int64 pointer as a Sint64.
 func sizeSint64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := *p.Int64()
-	return f.tagsize + wire.SizeVarint(wire.EncodeZigZag(v))
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
 }
 
 // appendSint64 wire encodes a int64 pointer as a Sint64.
 func appendSint64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.Int64()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, wire.EncodeZigZag(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
 	return b, nil
 }
 
 // consumeSint64 wire decodes a int64 pointer as a Sint64.
-func consumeSint64(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeSint64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -2236,12 +2236,12 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
-	*p.Int64() = wire.DecodeZigZag(v)
+	*p.Int64() = protowire.DecodeZigZag(v)
 	out.n = n
 	return out, nil
 }
@@ -2260,7 +2260,7 @@
 	if v == 0 {
 		return 0
 	}
-	return f.tagsize + wire.SizeVarint(wire.EncodeZigZag(v))
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
 }
 
 // appendSint64NoZero wire encodes a int64 pointer as a Sint64.
@@ -2270,8 +2270,8 @@
 	if v == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, wire.EncodeZigZag(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
 	return b, nil
 }
 
@@ -2286,21 +2286,21 @@
 // It panics if the pointer is nil.
 func sizeSint64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := **p.Int64Ptr()
-	return f.tagsize + wire.SizeVarint(wire.EncodeZigZag(v))
+	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
 }
 
 // appendSint64Ptr wire encodes a *int64 pointer as a Sint64.
 // It panics if the pointer is nil.
 func appendSint64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := **p.Int64Ptr()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, wire.EncodeZigZag(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
 	return b, nil
 }
 
 // consumeSint64Ptr wire decodes a *int64 pointer as a Sint64.
-func consumeSint64Ptr(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeSint64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -2312,16 +2312,16 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	vp := p.Int64Ptr()
 	if *vp == nil {
 		*vp = new(int64)
 	}
-	**vp = wire.DecodeZigZag(v)
+	**vp = protowire.DecodeZigZag(v)
 	out.n = n
 	return out, nil
 }
@@ -2337,7 +2337,7 @@
 func sizeSint64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	s := *p.Int64Slice()
 	for _, v := range s {
-		size += f.tagsize + wire.SizeVarint(wire.EncodeZigZag(v))
+		size += f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
 	}
 	return size
 }
@@ -2346,20 +2346,20 @@
 func appendSint64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.Int64Slice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendVarint(b, wire.EncodeZigZag(v))
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
 	}
 	return b, nil
 }
 
 // consumeSint64Slice wire decodes a []int64 pointer as a repeated Sint64.
-func consumeSint64Slice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeSint64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.Int64Slice()
-	if wtyp == wire.BytesType {
+	if wtyp == protowire.BytesType {
 		s := *sp
-		b, n := wire.ConsumeBytes(b)
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			var v uint64
@@ -2371,19 +2371,19 @@
 				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 				n = 2
 			} else {
-				v, n = wire.ConsumeVarint(b)
+				v, n = protowire.ConsumeVarint(b)
 			}
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
-			s = append(s, wire.DecodeZigZag(v))
+			s = append(s, protowire.DecodeZigZag(v))
 			b = b[n:]
 		}
 		*sp = s
 		out.n = n
 		return out, nil
 	}
-	if wtyp != wire.VarintType {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -2395,12 +2395,12 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
-	*sp = append(*sp, wire.DecodeZigZag(v))
+	*sp = append(*sp, protowire.DecodeZigZag(v))
 	out.n = n
 	return out, nil
 }
@@ -2420,9 +2420,9 @@
 	}
 	n := 0
 	for _, v := range s {
-		n += wire.SizeVarint(wire.EncodeZigZag(v))
+		n += protowire.SizeVarint(protowire.EncodeZigZag(v))
 	}
-	return f.tagsize + wire.SizeBytes(n)
+	return f.tagsize + protowire.SizeBytes(n)
 }
 
 // appendSint64PackedSlice encodes a []int64 pointer as a packed repeated Sint64.
@@ -2431,14 +2431,14 @@
 	if len(s) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, f.wiretag)
 	n := 0
 	for _, v := range s {
-		n += wire.SizeVarint(wire.EncodeZigZag(v))
+		n += protowire.SizeVarint(protowire.EncodeZigZag(v))
 	}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for _, v := range s {
-		b = wire.AppendVarint(b, wire.EncodeZigZag(v))
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
 	}
 	return b, nil
 }
@@ -2452,19 +2452,19 @@
 
 // sizeSint64Value returns the size of wire encoding a int64 value as a Sint64.
 func sizeSint64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + wire.SizeVarint(wire.EncodeZigZag(v.Int()))
+	return tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
 }
 
 // appendSint64Value encodes a int64 value as a Sint64.
 func appendSint64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendVarint(b, wire.EncodeZigZag(v.Int()))
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
 	return b, nil
 }
 
 // consumeSint64Value decodes a int64 value as a Sint64.
-func consumeSint64Value(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeSint64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	var v uint64
@@ -2476,13 +2476,13 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
-	return protoreflect.ValueOfInt64(wire.DecodeZigZag(v)), out, nil
+	return protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)), out, nil
 }
 
 var coderSint64Value = valueCoderFuncs{
@@ -2497,7 +2497,7 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		size += tagsize + wire.SizeVarint(wire.EncodeZigZag(v.Int()))
+		size += tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
 	}
 	return size
 }
@@ -2507,19 +2507,19 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
-		b = wire.AppendVarint(b, wire.EncodeZigZag(v.Int()))
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
 	}
 	return b, nil
 }
 
 // consumeSint64SliceValue wire decodes a []int64 value as a repeated Sint64.
-func consumeSint64SliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consumeSint64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp == wire.BytesType {
-		b, n := wire.ConsumeBytes(b)
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return protoreflect.Value{}, out, wire.ParseError(n)
+			return protoreflect.Value{}, out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			var v uint64
@@ -2531,18 +2531,18 @@
 				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 				n = 2
 			} else {
-				v, n = wire.ConsumeVarint(b)
+				v, n = protowire.ConsumeVarint(b)
 			}
 			if n < 0 {
-				return protoreflect.Value{}, out, wire.ParseError(n)
+				return protoreflect.Value{}, out, protowire.ParseError(n)
 			}
-			list.Append(protoreflect.ValueOfInt64(wire.DecodeZigZag(v)))
+			list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
 			b = b[n:]
 		}
 		out.n = n
 		return listv, out, nil
 	}
-	if wtyp != wire.VarintType {
+	if wtyp != protowire.VarintType {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	var v uint64
@@ -2554,12 +2554,12 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
-	list.Append(protoreflect.ValueOfInt64(wire.DecodeZigZag(v)))
+	list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
 	out.n = n
 	return listv, out, nil
 }
@@ -2581,9 +2581,9 @@
 	n := 0
 	for i, llen := 0, llen; i < llen; i++ {
 		v := list.Get(i)
-		n += wire.SizeVarint(wire.EncodeZigZag(v.Int()))
+		n += protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
 	}
-	return tagsize + wire.SizeBytes(n)
+	return tagsize + protowire.SizeBytes(n)
 }
 
 // appendSint64PackedSliceValue encodes a []int64 value as a packed repeated Sint64.
@@ -2593,16 +2593,16 @@
 	if llen == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, wiretag)
 	n := 0
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		n += wire.SizeVarint(wire.EncodeZigZag(v.Int()))
+		n += protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
 	}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wire.EncodeZigZag(v.Int()))
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
 	}
 	return b, nil
 }
@@ -2617,20 +2617,20 @@
 // sizeUint64 returns the size of wire encoding a uint64 pointer as a Uint64.
 func sizeUint64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := *p.Uint64()
-	return f.tagsize + wire.SizeVarint(v)
+	return f.tagsize + protowire.SizeVarint(v)
 }
 
 // appendUint64 wire encodes a uint64 pointer as a Uint64.
 func appendUint64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.Uint64()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, v)
 	return b, nil
 }
 
 // consumeUint64 wire decodes a uint64 pointer as a Uint64.
-func consumeUint64(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeUint64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -2642,10 +2642,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*p.Uint64() = v
 	out.n = n
@@ -2666,7 +2666,7 @@
 	if v == 0 {
 		return 0
 	}
-	return f.tagsize + wire.SizeVarint(v)
+	return f.tagsize + protowire.SizeVarint(v)
 }
 
 // appendUint64NoZero wire encodes a uint64 pointer as a Uint64.
@@ -2676,8 +2676,8 @@
 	if v == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, v)
 	return b, nil
 }
 
@@ -2692,21 +2692,21 @@
 // It panics if the pointer is nil.
 func sizeUint64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := **p.Uint64Ptr()
-	return f.tagsize + wire.SizeVarint(v)
+	return f.tagsize + protowire.SizeVarint(v)
 }
 
 // appendUint64Ptr wire encodes a *uint64 pointer as a Uint64.
 // It panics if the pointer is nil.
 func appendUint64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := **p.Uint64Ptr()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, v)
 	return b, nil
 }
 
 // consumeUint64Ptr wire decodes a *uint64 pointer as a Uint64.
-func consumeUint64Ptr(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeUint64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -2718,10 +2718,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	vp := p.Uint64Ptr()
 	if *vp == nil {
@@ -2743,7 +2743,7 @@
 func sizeUint64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	s := *p.Uint64Slice()
 	for _, v := range s {
-		size += f.tagsize + wire.SizeVarint(v)
+		size += f.tagsize + protowire.SizeVarint(v)
 	}
 	return size
 }
@@ -2752,20 +2752,20 @@
 func appendUint64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.Uint64Slice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendVarint(b, v)
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, v)
 	}
 	return b, nil
 }
 
 // consumeUint64Slice wire decodes a []uint64 pointer as a repeated Uint64.
-func consumeUint64Slice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeUint64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.Uint64Slice()
-	if wtyp == wire.BytesType {
+	if wtyp == protowire.BytesType {
 		s := *sp
-		b, n := wire.ConsumeBytes(b)
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			var v uint64
@@ -2777,10 +2777,10 @@
 				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 				n = 2
 			} else {
-				v, n = wire.ConsumeVarint(b)
+				v, n = protowire.ConsumeVarint(b)
 			}
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 			s = append(s, v)
 			b = b[n:]
@@ -2789,7 +2789,7 @@
 		out.n = n
 		return out, nil
 	}
-	if wtyp != wire.VarintType {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	var v uint64
@@ -2801,10 +2801,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*sp = append(*sp, v)
 	out.n = n
@@ -2826,9 +2826,9 @@
 	}
 	n := 0
 	for _, v := range s {
-		n += wire.SizeVarint(v)
+		n += protowire.SizeVarint(v)
 	}
-	return f.tagsize + wire.SizeBytes(n)
+	return f.tagsize + protowire.SizeBytes(n)
 }
 
 // appendUint64PackedSlice encodes a []uint64 pointer as a packed repeated Uint64.
@@ -2837,14 +2837,14 @@
 	if len(s) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, f.wiretag)
 	n := 0
 	for _, v := range s {
-		n += wire.SizeVarint(v)
+		n += protowire.SizeVarint(v)
 	}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for _, v := range s {
-		b = wire.AppendVarint(b, v)
+		b = protowire.AppendVarint(b, v)
 	}
 	return b, nil
 }
@@ -2858,19 +2858,19 @@
 
 // sizeUint64Value returns the size of wire encoding a uint64 value as a Uint64.
 func sizeUint64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + wire.SizeVarint(v.Uint())
+	return tagsize + protowire.SizeVarint(v.Uint())
 }
 
 // appendUint64Value encodes a uint64 value as a Uint64.
 func appendUint64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendVarint(b, v.Uint())
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, v.Uint())
 	return b, nil
 }
 
 // consumeUint64Value decodes a uint64 value as a Uint64.
-func consumeUint64Value(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeUint64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	var v uint64
@@ -2882,10 +2882,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
 	return protoreflect.ValueOfUint64(v), out, nil
@@ -2903,7 +2903,7 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		size += tagsize + wire.SizeVarint(v.Uint())
+		size += tagsize + protowire.SizeVarint(v.Uint())
 	}
 	return size
 }
@@ -2913,19 +2913,19 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
-		b = wire.AppendVarint(b, v.Uint())
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendVarint(b, v.Uint())
 	}
 	return b, nil
 }
 
 // consumeUint64SliceValue wire decodes a []uint64 value as a repeated Uint64.
-func consumeUint64SliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consumeUint64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp == wire.BytesType {
-		b, n := wire.ConsumeBytes(b)
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return protoreflect.Value{}, out, wire.ParseError(n)
+			return protoreflect.Value{}, out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
 			var v uint64
@@ -2937,10 +2937,10 @@
 				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 				n = 2
 			} else {
-				v, n = wire.ConsumeVarint(b)
+				v, n = protowire.ConsumeVarint(b)
 			}
 			if n < 0 {
-				return protoreflect.Value{}, out, wire.ParseError(n)
+				return protoreflect.Value{}, out, protowire.ParseError(n)
 			}
 			list.Append(protoreflect.ValueOfUint64(v))
 			b = b[n:]
@@ -2948,7 +2948,7 @@
 		out.n = n
 		return listv, out, nil
 	}
-	if wtyp != wire.VarintType {
+	if wtyp != protowire.VarintType {
 		return protoreflect.Value{}, out, errUnknown
 	}
 	var v uint64
@@ -2960,10 +2960,10 @@
 		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
 		n = 2
 	} else {
-		v, n = wire.ConsumeVarint(b)
+		v, n = protowire.ConsumeVarint(b)
 	}
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	list.Append(protoreflect.ValueOfUint64(v))
 	out.n = n
@@ -2987,9 +2987,9 @@
 	n := 0
 	for i, llen := 0, llen; i < llen; i++ {
 		v := list.Get(i)
-		n += wire.SizeVarint(v.Uint())
+		n += protowire.SizeVarint(v.Uint())
 	}
-	return tagsize + wire.SizeBytes(n)
+	return tagsize + protowire.SizeBytes(n)
 }
 
 // appendUint64PackedSliceValue encodes a []uint64 value as a packed repeated Uint64.
@@ -2999,16 +2999,16 @@
 	if llen == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, wiretag)
+	b = protowire.AppendVarint(b, wiretag)
 	n := 0
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		n += wire.SizeVarint(v.Uint())
+		n += protowire.SizeVarint(v.Uint())
 	}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, v.Uint())
+		b = protowire.AppendVarint(b, v.Uint())
 	}
 	return b, nil
 }
@@ -3023,25 +3023,25 @@
 // sizeSfixed32 returns the size of wire encoding a int32 pointer as a Sfixed32.
 func sizeSfixed32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 
-	return f.tagsize + wire.SizeFixed32()
+	return f.tagsize + protowire.SizeFixed32()
 }
 
 // appendSfixed32 wire encodes a int32 pointer as a Sfixed32.
 func appendSfixed32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.Int32()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed32(b, uint32(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, uint32(v))
 	return b, nil
 }
 
 // consumeSfixed32 wire decodes a int32 pointer as a Sfixed32.
-func consumeSfixed32(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed32Type {
+func consumeSfixed32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed32(b)
+	v, n := protowire.ConsumeFixed32(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*p.Int32() = int32(v)
 	out.n = n
@@ -3062,7 +3062,7 @@
 	if v == 0 {
 		return 0
 	}
-	return f.tagsize + wire.SizeFixed32()
+	return f.tagsize + protowire.SizeFixed32()
 }
 
 // appendSfixed32NoZero wire encodes a int32 pointer as a Sfixed32.
@@ -3072,8 +3072,8 @@
 	if v == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed32(b, uint32(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, uint32(v))
 	return b, nil
 }
 
@@ -3087,26 +3087,26 @@
 // sizeSfixed32Ptr returns the size of wire encoding a *int32 pointer as a Sfixed32.
 // It panics if the pointer is nil.
 func sizeSfixed32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	return f.tagsize + wire.SizeFixed32()
+	return f.tagsize + protowire.SizeFixed32()
 }
 
 // appendSfixed32Ptr wire encodes a *int32 pointer as a Sfixed32.
 // It panics if the pointer is nil.
 func appendSfixed32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := **p.Int32Ptr()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed32(b, uint32(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, uint32(v))
 	return b, nil
 }
 
 // consumeSfixed32Ptr wire decodes a *int32 pointer as a Sfixed32.
-func consumeSfixed32Ptr(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed32Type {
+func consumeSfixed32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed32(b)
+	v, n := protowire.ConsumeFixed32(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	vp := p.Int32Ptr()
 	if *vp == nil {
@@ -3127,7 +3127,7 @@
 // sizeSfixed32Slice returns the size of wire encoding a []int32 pointer as a repeated Sfixed32.
 func sizeSfixed32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	s := *p.Int32Slice()
-	size = len(s) * (f.tagsize + wire.SizeFixed32())
+	size = len(s) * (f.tagsize + protowire.SizeFixed32())
 	return size
 }
 
@@ -3135,25 +3135,25 @@
 func appendSfixed32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.Int32Slice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendFixed32(b, uint32(v))
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendFixed32(b, uint32(v))
 	}
 	return b, nil
 }
 
 // consumeSfixed32Slice wire decodes a []int32 pointer as a repeated Sfixed32.
-func consumeSfixed32Slice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeSfixed32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.Int32Slice()
-	if wtyp == wire.BytesType {
+	if wtyp == protowire.BytesType {
 		s := *sp
-		b, n := wire.ConsumeBytes(b)
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
-			v, n := wire.ConsumeFixed32(b)
+			v, n := protowire.ConsumeFixed32(b)
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 			s = append(s, int32(v))
 			b = b[n:]
@@ -3162,12 +3162,12 @@
 		out.n = n
 		return out, nil
 	}
-	if wtyp != wire.Fixed32Type {
+	if wtyp != protowire.Fixed32Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed32(b)
+	v, n := protowire.ConsumeFixed32(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*sp = append(*sp, int32(v))
 	out.n = n
@@ -3187,8 +3187,8 @@
 	if len(s) == 0 {
 		return 0
 	}
-	n := len(s) * wire.SizeFixed32()
-	return f.tagsize + wire.SizeBytes(n)
+	n := len(s) * protowire.SizeFixed32()
+	return f.tagsize + protowire.SizeBytes(n)
 }
 
 // appendSfixed32PackedSlice encodes a []int32 pointer as a packed repeated Sfixed32.
@@ -3197,11 +3197,11 @@
 	if len(s) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	n := len(s) * wire.SizeFixed32()
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := len(s) * protowire.SizeFixed32()
+	b = protowire.AppendVarint(b, uint64(n))
 	for _, v := range s {
-		b = wire.AppendFixed32(b, uint32(v))
+		b = protowire.AppendFixed32(b, uint32(v))
 	}
 	return b, nil
 }
@@ -3215,24 +3215,24 @@
 
 // sizeSfixed32Value returns the size of wire encoding a int32 value as a Sfixed32.
 func sizeSfixed32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + wire.SizeFixed32()
+	return tagsize + protowire.SizeFixed32()
 }
 
 // appendSfixed32Value encodes a int32 value as a Sfixed32.
 func appendSfixed32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendFixed32(b, uint32(v.Int()))
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendFixed32(b, uint32(v.Int()))
 	return b, nil
 }
 
 // consumeSfixed32Value decodes a int32 value as a Sfixed32.
-func consumeSfixed32Value(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed32Type {
+func consumeSfixed32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeFixed32(b)
+	v, n := protowire.ConsumeFixed32(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
 	return protoreflect.ValueOfInt32(int32(v)), out, nil
@@ -3248,7 +3248,7 @@
 // sizeSfixed32SliceValue returns the size of wire encoding a []int32 value as a repeated Sfixed32.
 func sizeSfixed32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
 	list := listv.List()
-	size = list.Len() * (tagsize + wire.SizeFixed32())
+	size = list.Len() * (tagsize + protowire.SizeFixed32())
 	return size
 }
 
@@ -3257,24 +3257,24 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
-		b = wire.AppendFixed32(b, uint32(v.Int()))
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendFixed32(b, uint32(v.Int()))
 	}
 	return b, nil
 }
 
 // consumeSfixed32SliceValue wire decodes a []int32 value as a repeated Sfixed32.
-func consumeSfixed32SliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consumeSfixed32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp == wire.BytesType {
-		b, n := wire.ConsumeBytes(b)
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return protoreflect.Value{}, out, wire.ParseError(n)
+			return protoreflect.Value{}, out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
-			v, n := wire.ConsumeFixed32(b)
+			v, n := protowire.ConsumeFixed32(b)
 			if n < 0 {
-				return protoreflect.Value{}, out, wire.ParseError(n)
+				return protoreflect.Value{}, out, protowire.ParseError(n)
 			}
 			list.Append(protoreflect.ValueOfInt32(int32(v)))
 			b = b[n:]
@@ -3282,12 +3282,12 @@
 		out.n = n
 		return listv, out, nil
 	}
-	if wtyp != wire.Fixed32Type {
+	if wtyp != protowire.Fixed32Type {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeFixed32(b)
+	v, n := protowire.ConsumeFixed32(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	list.Append(protoreflect.ValueOfInt32(int32(v)))
 	out.n = n
@@ -3308,8 +3308,8 @@
 	if llen == 0 {
 		return 0
 	}
-	n := llen * wire.SizeFixed32()
-	return tagsize + wire.SizeBytes(n)
+	n := llen * protowire.SizeFixed32()
+	return tagsize + protowire.SizeBytes(n)
 }
 
 // appendSfixed32PackedSliceValue encodes a []int32 value as a packed repeated Sfixed32.
@@ -3319,12 +3319,12 @@
 	if llen == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, wiretag)
-	n := llen * wire.SizeFixed32()
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, wiretag)
+	n := llen * protowire.SizeFixed32()
+	b = protowire.AppendVarint(b, uint64(n))
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendFixed32(b, uint32(v.Int()))
+		b = protowire.AppendFixed32(b, uint32(v.Int()))
 	}
 	return b, nil
 }
@@ -3339,25 +3339,25 @@
 // sizeFixed32 returns the size of wire encoding a uint32 pointer as a Fixed32.
 func sizeFixed32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 
-	return f.tagsize + wire.SizeFixed32()
+	return f.tagsize + protowire.SizeFixed32()
 }
 
 // appendFixed32 wire encodes a uint32 pointer as a Fixed32.
 func appendFixed32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.Uint32()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed32(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, v)
 	return b, nil
 }
 
 // consumeFixed32 wire decodes a uint32 pointer as a Fixed32.
-func consumeFixed32(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed32Type {
+func consumeFixed32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed32(b)
+	v, n := protowire.ConsumeFixed32(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*p.Uint32() = v
 	out.n = n
@@ -3378,7 +3378,7 @@
 	if v == 0 {
 		return 0
 	}
-	return f.tagsize + wire.SizeFixed32()
+	return f.tagsize + protowire.SizeFixed32()
 }
 
 // appendFixed32NoZero wire encodes a uint32 pointer as a Fixed32.
@@ -3388,8 +3388,8 @@
 	if v == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed32(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, v)
 	return b, nil
 }
 
@@ -3403,26 +3403,26 @@
 // sizeFixed32Ptr returns the size of wire encoding a *uint32 pointer as a Fixed32.
 // It panics if the pointer is nil.
 func sizeFixed32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	return f.tagsize + wire.SizeFixed32()
+	return f.tagsize + protowire.SizeFixed32()
 }
 
 // appendFixed32Ptr wire encodes a *uint32 pointer as a Fixed32.
 // It panics if the pointer is nil.
 func appendFixed32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := **p.Uint32Ptr()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed32(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, v)
 	return b, nil
 }
 
 // consumeFixed32Ptr wire decodes a *uint32 pointer as a Fixed32.
-func consumeFixed32Ptr(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed32Type {
+func consumeFixed32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed32(b)
+	v, n := protowire.ConsumeFixed32(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	vp := p.Uint32Ptr()
 	if *vp == nil {
@@ -3443,7 +3443,7 @@
 // sizeFixed32Slice returns the size of wire encoding a []uint32 pointer as a repeated Fixed32.
 func sizeFixed32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	s := *p.Uint32Slice()
-	size = len(s) * (f.tagsize + wire.SizeFixed32())
+	size = len(s) * (f.tagsize + protowire.SizeFixed32())
 	return size
 }
 
@@ -3451,25 +3451,25 @@
 func appendFixed32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.Uint32Slice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendFixed32(b, v)
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendFixed32(b, v)
 	}
 	return b, nil
 }
 
 // consumeFixed32Slice wire decodes a []uint32 pointer as a repeated Fixed32.
-func consumeFixed32Slice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeFixed32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.Uint32Slice()
-	if wtyp == wire.BytesType {
+	if wtyp == protowire.BytesType {
 		s := *sp
-		b, n := wire.ConsumeBytes(b)
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
-			v, n := wire.ConsumeFixed32(b)
+			v, n := protowire.ConsumeFixed32(b)
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 			s = append(s, v)
 			b = b[n:]
@@ -3478,12 +3478,12 @@
 		out.n = n
 		return out, nil
 	}
-	if wtyp != wire.Fixed32Type {
+	if wtyp != protowire.Fixed32Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed32(b)
+	v, n := protowire.ConsumeFixed32(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*sp = append(*sp, v)
 	out.n = n
@@ -3503,8 +3503,8 @@
 	if len(s) == 0 {
 		return 0
 	}
-	n := len(s) * wire.SizeFixed32()
-	return f.tagsize + wire.SizeBytes(n)
+	n := len(s) * protowire.SizeFixed32()
+	return f.tagsize + protowire.SizeBytes(n)
 }
 
 // appendFixed32PackedSlice encodes a []uint32 pointer as a packed repeated Fixed32.
@@ -3513,11 +3513,11 @@
 	if len(s) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	n := len(s) * wire.SizeFixed32()
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := len(s) * protowire.SizeFixed32()
+	b = protowire.AppendVarint(b, uint64(n))
 	for _, v := range s {
-		b = wire.AppendFixed32(b, v)
+		b = protowire.AppendFixed32(b, v)
 	}
 	return b, nil
 }
@@ -3531,24 +3531,24 @@
 
 // sizeFixed32Value returns the size of wire encoding a uint32 value as a Fixed32.
 func sizeFixed32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + wire.SizeFixed32()
+	return tagsize + protowire.SizeFixed32()
 }
 
 // appendFixed32Value encodes a uint32 value as a Fixed32.
 func appendFixed32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendFixed32(b, uint32(v.Uint()))
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendFixed32(b, uint32(v.Uint()))
 	return b, nil
 }
 
 // consumeFixed32Value decodes a uint32 value as a Fixed32.
-func consumeFixed32Value(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed32Type {
+func consumeFixed32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeFixed32(b)
+	v, n := protowire.ConsumeFixed32(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
 	return protoreflect.ValueOfUint32(uint32(v)), out, nil
@@ -3564,7 +3564,7 @@
 // sizeFixed32SliceValue returns the size of wire encoding a []uint32 value as a repeated Fixed32.
 func sizeFixed32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
 	list := listv.List()
-	size = list.Len() * (tagsize + wire.SizeFixed32())
+	size = list.Len() * (tagsize + protowire.SizeFixed32())
 	return size
 }
 
@@ -3573,24 +3573,24 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
-		b = wire.AppendFixed32(b, uint32(v.Uint()))
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendFixed32(b, uint32(v.Uint()))
 	}
 	return b, nil
 }
 
 // consumeFixed32SliceValue wire decodes a []uint32 value as a repeated Fixed32.
-func consumeFixed32SliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consumeFixed32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp == wire.BytesType {
-		b, n := wire.ConsumeBytes(b)
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return protoreflect.Value{}, out, wire.ParseError(n)
+			return protoreflect.Value{}, out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
-			v, n := wire.ConsumeFixed32(b)
+			v, n := protowire.ConsumeFixed32(b)
 			if n < 0 {
-				return protoreflect.Value{}, out, wire.ParseError(n)
+				return protoreflect.Value{}, out, protowire.ParseError(n)
 			}
 			list.Append(protoreflect.ValueOfUint32(uint32(v)))
 			b = b[n:]
@@ -3598,12 +3598,12 @@
 		out.n = n
 		return listv, out, nil
 	}
-	if wtyp != wire.Fixed32Type {
+	if wtyp != protowire.Fixed32Type {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeFixed32(b)
+	v, n := protowire.ConsumeFixed32(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	list.Append(protoreflect.ValueOfUint32(uint32(v)))
 	out.n = n
@@ -3624,8 +3624,8 @@
 	if llen == 0 {
 		return 0
 	}
-	n := llen * wire.SizeFixed32()
-	return tagsize + wire.SizeBytes(n)
+	n := llen * protowire.SizeFixed32()
+	return tagsize + protowire.SizeBytes(n)
 }
 
 // appendFixed32PackedSliceValue encodes a []uint32 value as a packed repeated Fixed32.
@@ -3635,12 +3635,12 @@
 	if llen == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, wiretag)
-	n := llen * wire.SizeFixed32()
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, wiretag)
+	n := llen * protowire.SizeFixed32()
+	b = protowire.AppendVarint(b, uint64(n))
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendFixed32(b, uint32(v.Uint()))
+		b = protowire.AppendFixed32(b, uint32(v.Uint()))
 	}
 	return b, nil
 }
@@ -3655,25 +3655,25 @@
 // sizeFloat returns the size of wire encoding a float32 pointer as a Float.
 func sizeFloat(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 
-	return f.tagsize + wire.SizeFixed32()
+	return f.tagsize + protowire.SizeFixed32()
 }
 
 // appendFloat wire encodes a float32 pointer as a Float.
 func appendFloat(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.Float32()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed32(b, math.Float32bits(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, math.Float32bits(v))
 	return b, nil
 }
 
 // consumeFloat wire decodes a float32 pointer as a Float.
-func consumeFloat(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed32Type {
+func consumeFloat(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed32(b)
+	v, n := protowire.ConsumeFixed32(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*p.Float32() = math.Float32frombits(v)
 	out.n = n
@@ -3694,7 +3694,7 @@
 	if v == 0 && !math.Signbit(float64(v)) {
 		return 0
 	}
-	return f.tagsize + wire.SizeFixed32()
+	return f.tagsize + protowire.SizeFixed32()
 }
 
 // appendFloatNoZero wire encodes a float32 pointer as a Float.
@@ -3704,8 +3704,8 @@
 	if v == 0 && !math.Signbit(float64(v)) {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed32(b, math.Float32bits(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, math.Float32bits(v))
 	return b, nil
 }
 
@@ -3719,26 +3719,26 @@
 // sizeFloatPtr returns the size of wire encoding a *float32 pointer as a Float.
 // It panics if the pointer is nil.
 func sizeFloatPtr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	return f.tagsize + wire.SizeFixed32()
+	return f.tagsize + protowire.SizeFixed32()
 }
 
 // appendFloatPtr wire encodes a *float32 pointer as a Float.
 // It panics if the pointer is nil.
 func appendFloatPtr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := **p.Float32Ptr()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed32(b, math.Float32bits(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed32(b, math.Float32bits(v))
 	return b, nil
 }
 
 // consumeFloatPtr wire decodes a *float32 pointer as a Float.
-func consumeFloatPtr(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed32Type {
+func consumeFloatPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed32(b)
+	v, n := protowire.ConsumeFixed32(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	vp := p.Float32Ptr()
 	if *vp == nil {
@@ -3759,7 +3759,7 @@
 // sizeFloatSlice returns the size of wire encoding a []float32 pointer as a repeated Float.
 func sizeFloatSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	s := *p.Float32Slice()
-	size = len(s) * (f.tagsize + wire.SizeFixed32())
+	size = len(s) * (f.tagsize + protowire.SizeFixed32())
 	return size
 }
 
@@ -3767,25 +3767,25 @@
 func appendFloatSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.Float32Slice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendFixed32(b, math.Float32bits(v))
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendFixed32(b, math.Float32bits(v))
 	}
 	return b, nil
 }
 
 // consumeFloatSlice wire decodes a []float32 pointer as a repeated Float.
-func consumeFloatSlice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeFloatSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.Float32Slice()
-	if wtyp == wire.BytesType {
+	if wtyp == protowire.BytesType {
 		s := *sp
-		b, n := wire.ConsumeBytes(b)
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
-			v, n := wire.ConsumeFixed32(b)
+			v, n := protowire.ConsumeFixed32(b)
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 			s = append(s, math.Float32frombits(v))
 			b = b[n:]
@@ -3794,12 +3794,12 @@
 		out.n = n
 		return out, nil
 	}
-	if wtyp != wire.Fixed32Type {
+	if wtyp != protowire.Fixed32Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed32(b)
+	v, n := protowire.ConsumeFixed32(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*sp = append(*sp, math.Float32frombits(v))
 	out.n = n
@@ -3819,8 +3819,8 @@
 	if len(s) == 0 {
 		return 0
 	}
-	n := len(s) * wire.SizeFixed32()
-	return f.tagsize + wire.SizeBytes(n)
+	n := len(s) * protowire.SizeFixed32()
+	return f.tagsize + protowire.SizeBytes(n)
 }
 
 // appendFloatPackedSlice encodes a []float32 pointer as a packed repeated Float.
@@ -3829,11 +3829,11 @@
 	if len(s) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	n := len(s) * wire.SizeFixed32()
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := len(s) * protowire.SizeFixed32()
+	b = protowire.AppendVarint(b, uint64(n))
 	for _, v := range s {
-		b = wire.AppendFixed32(b, math.Float32bits(v))
+		b = protowire.AppendFixed32(b, math.Float32bits(v))
 	}
 	return b, nil
 }
@@ -3847,24 +3847,24 @@
 
 // sizeFloatValue returns the size of wire encoding a float32 value as a Float.
 func sizeFloatValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + wire.SizeFixed32()
+	return tagsize + protowire.SizeFixed32()
 }
 
 // appendFloatValue encodes a float32 value as a Float.
 func appendFloatValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
 	return b, nil
 }
 
 // consumeFloatValue decodes a float32 value as a Float.
-func consumeFloatValue(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed32Type {
+func consumeFloatValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed32Type {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeFixed32(b)
+	v, n := protowire.ConsumeFixed32(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
 	return protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))), out, nil
@@ -3880,7 +3880,7 @@
 // sizeFloatSliceValue returns the size of wire encoding a []float32 value as a repeated Float.
 func sizeFloatSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
 	list := listv.List()
-	size = list.Len() * (tagsize + wire.SizeFixed32())
+	size = list.Len() * (tagsize + protowire.SizeFixed32())
 	return size
 }
 
@@ -3889,24 +3889,24 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
-		b = wire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
 	}
 	return b, nil
 }
 
 // consumeFloatSliceValue wire decodes a []float32 value as a repeated Float.
-func consumeFloatSliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consumeFloatSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp == wire.BytesType {
-		b, n := wire.ConsumeBytes(b)
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return protoreflect.Value{}, out, wire.ParseError(n)
+			return protoreflect.Value{}, out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
-			v, n := wire.ConsumeFixed32(b)
+			v, n := protowire.ConsumeFixed32(b)
 			if n < 0 {
-				return protoreflect.Value{}, out, wire.ParseError(n)
+				return protoreflect.Value{}, out, protowire.ParseError(n)
 			}
 			list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
 			b = b[n:]
@@ -3914,12 +3914,12 @@
 		out.n = n
 		return listv, out, nil
 	}
-	if wtyp != wire.Fixed32Type {
+	if wtyp != protowire.Fixed32Type {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeFixed32(b)
+	v, n := protowire.ConsumeFixed32(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
 	out.n = n
@@ -3940,8 +3940,8 @@
 	if llen == 0 {
 		return 0
 	}
-	n := llen * wire.SizeFixed32()
-	return tagsize + wire.SizeBytes(n)
+	n := llen * protowire.SizeFixed32()
+	return tagsize + protowire.SizeBytes(n)
 }
 
 // appendFloatPackedSliceValue encodes a []float32 value as a packed repeated Float.
@@ -3951,12 +3951,12 @@
 	if llen == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, wiretag)
-	n := llen * wire.SizeFixed32()
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, wiretag)
+	n := llen * protowire.SizeFixed32()
+	b = protowire.AppendVarint(b, uint64(n))
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
+		b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
 	}
 	return b, nil
 }
@@ -3971,25 +3971,25 @@
 // sizeSfixed64 returns the size of wire encoding a int64 pointer as a Sfixed64.
 func sizeSfixed64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 
-	return f.tagsize + wire.SizeFixed64()
+	return f.tagsize + protowire.SizeFixed64()
 }
 
 // appendSfixed64 wire encodes a int64 pointer as a Sfixed64.
 func appendSfixed64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.Int64()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed64(b, uint64(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, uint64(v))
 	return b, nil
 }
 
 // consumeSfixed64 wire decodes a int64 pointer as a Sfixed64.
-func consumeSfixed64(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed64Type {
+func consumeSfixed64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed64(b)
+	v, n := protowire.ConsumeFixed64(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*p.Int64() = int64(v)
 	out.n = n
@@ -4010,7 +4010,7 @@
 	if v == 0 {
 		return 0
 	}
-	return f.tagsize + wire.SizeFixed64()
+	return f.tagsize + protowire.SizeFixed64()
 }
 
 // appendSfixed64NoZero wire encodes a int64 pointer as a Sfixed64.
@@ -4020,8 +4020,8 @@
 	if v == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed64(b, uint64(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, uint64(v))
 	return b, nil
 }
 
@@ -4035,26 +4035,26 @@
 // sizeSfixed64Ptr returns the size of wire encoding a *int64 pointer as a Sfixed64.
 // It panics if the pointer is nil.
 func sizeSfixed64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	return f.tagsize + wire.SizeFixed64()
+	return f.tagsize + protowire.SizeFixed64()
 }
 
 // appendSfixed64Ptr wire encodes a *int64 pointer as a Sfixed64.
 // It panics if the pointer is nil.
 func appendSfixed64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := **p.Int64Ptr()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed64(b, uint64(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, uint64(v))
 	return b, nil
 }
 
 // consumeSfixed64Ptr wire decodes a *int64 pointer as a Sfixed64.
-func consumeSfixed64Ptr(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed64Type {
+func consumeSfixed64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed64(b)
+	v, n := protowire.ConsumeFixed64(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	vp := p.Int64Ptr()
 	if *vp == nil {
@@ -4075,7 +4075,7 @@
 // sizeSfixed64Slice returns the size of wire encoding a []int64 pointer as a repeated Sfixed64.
 func sizeSfixed64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	s := *p.Int64Slice()
-	size = len(s) * (f.tagsize + wire.SizeFixed64())
+	size = len(s) * (f.tagsize + protowire.SizeFixed64())
 	return size
 }
 
@@ -4083,25 +4083,25 @@
 func appendSfixed64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.Int64Slice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendFixed64(b, uint64(v))
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendFixed64(b, uint64(v))
 	}
 	return b, nil
 }
 
 // consumeSfixed64Slice wire decodes a []int64 pointer as a repeated Sfixed64.
-func consumeSfixed64Slice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeSfixed64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.Int64Slice()
-	if wtyp == wire.BytesType {
+	if wtyp == protowire.BytesType {
 		s := *sp
-		b, n := wire.ConsumeBytes(b)
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
-			v, n := wire.ConsumeFixed64(b)
+			v, n := protowire.ConsumeFixed64(b)
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 			s = append(s, int64(v))
 			b = b[n:]
@@ -4110,12 +4110,12 @@
 		out.n = n
 		return out, nil
 	}
-	if wtyp != wire.Fixed64Type {
+	if wtyp != protowire.Fixed64Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed64(b)
+	v, n := protowire.ConsumeFixed64(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*sp = append(*sp, int64(v))
 	out.n = n
@@ -4135,8 +4135,8 @@
 	if len(s) == 0 {
 		return 0
 	}
-	n := len(s) * wire.SizeFixed64()
-	return f.tagsize + wire.SizeBytes(n)
+	n := len(s) * protowire.SizeFixed64()
+	return f.tagsize + protowire.SizeBytes(n)
 }
 
 // appendSfixed64PackedSlice encodes a []int64 pointer as a packed repeated Sfixed64.
@@ -4145,11 +4145,11 @@
 	if len(s) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	n := len(s) * wire.SizeFixed64()
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := len(s) * protowire.SizeFixed64()
+	b = protowire.AppendVarint(b, uint64(n))
 	for _, v := range s {
-		b = wire.AppendFixed64(b, uint64(v))
+		b = protowire.AppendFixed64(b, uint64(v))
 	}
 	return b, nil
 }
@@ -4163,24 +4163,24 @@
 
 // sizeSfixed64Value returns the size of wire encoding a int64 value as a Sfixed64.
 func sizeSfixed64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + wire.SizeFixed64()
+	return tagsize + protowire.SizeFixed64()
 }
 
 // appendSfixed64Value encodes a int64 value as a Sfixed64.
 func appendSfixed64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendFixed64(b, uint64(v.Int()))
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendFixed64(b, uint64(v.Int()))
 	return b, nil
 }
 
 // consumeSfixed64Value decodes a int64 value as a Sfixed64.
-func consumeSfixed64Value(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed64Type {
+func consumeSfixed64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeFixed64(b)
+	v, n := protowire.ConsumeFixed64(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
 	return protoreflect.ValueOfInt64(int64(v)), out, nil
@@ -4196,7 +4196,7 @@
 // sizeSfixed64SliceValue returns the size of wire encoding a []int64 value as a repeated Sfixed64.
 func sizeSfixed64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
 	list := listv.List()
-	size = list.Len() * (tagsize + wire.SizeFixed64())
+	size = list.Len() * (tagsize + protowire.SizeFixed64())
 	return size
 }
 
@@ -4205,24 +4205,24 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
-		b = wire.AppendFixed64(b, uint64(v.Int()))
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendFixed64(b, uint64(v.Int()))
 	}
 	return b, nil
 }
 
 // consumeSfixed64SliceValue wire decodes a []int64 value as a repeated Sfixed64.
-func consumeSfixed64SliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consumeSfixed64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp == wire.BytesType {
-		b, n := wire.ConsumeBytes(b)
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return protoreflect.Value{}, out, wire.ParseError(n)
+			return protoreflect.Value{}, out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
-			v, n := wire.ConsumeFixed64(b)
+			v, n := protowire.ConsumeFixed64(b)
 			if n < 0 {
-				return protoreflect.Value{}, out, wire.ParseError(n)
+				return protoreflect.Value{}, out, protowire.ParseError(n)
 			}
 			list.Append(protoreflect.ValueOfInt64(int64(v)))
 			b = b[n:]
@@ -4230,12 +4230,12 @@
 		out.n = n
 		return listv, out, nil
 	}
-	if wtyp != wire.Fixed64Type {
+	if wtyp != protowire.Fixed64Type {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeFixed64(b)
+	v, n := protowire.ConsumeFixed64(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	list.Append(protoreflect.ValueOfInt64(int64(v)))
 	out.n = n
@@ -4256,8 +4256,8 @@
 	if llen == 0 {
 		return 0
 	}
-	n := llen * wire.SizeFixed64()
-	return tagsize + wire.SizeBytes(n)
+	n := llen * protowire.SizeFixed64()
+	return tagsize + protowire.SizeBytes(n)
 }
 
 // appendSfixed64PackedSliceValue encodes a []int64 value as a packed repeated Sfixed64.
@@ -4267,12 +4267,12 @@
 	if llen == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, wiretag)
-	n := llen * wire.SizeFixed64()
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, wiretag)
+	n := llen * protowire.SizeFixed64()
+	b = protowire.AppendVarint(b, uint64(n))
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendFixed64(b, uint64(v.Int()))
+		b = protowire.AppendFixed64(b, uint64(v.Int()))
 	}
 	return b, nil
 }
@@ -4287,25 +4287,25 @@
 // sizeFixed64 returns the size of wire encoding a uint64 pointer as a Fixed64.
 func sizeFixed64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 
-	return f.tagsize + wire.SizeFixed64()
+	return f.tagsize + protowire.SizeFixed64()
 }
 
 // appendFixed64 wire encodes a uint64 pointer as a Fixed64.
 func appendFixed64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.Uint64()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed64(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, v)
 	return b, nil
 }
 
 // consumeFixed64 wire decodes a uint64 pointer as a Fixed64.
-func consumeFixed64(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed64Type {
+func consumeFixed64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed64(b)
+	v, n := protowire.ConsumeFixed64(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*p.Uint64() = v
 	out.n = n
@@ -4326,7 +4326,7 @@
 	if v == 0 {
 		return 0
 	}
-	return f.tagsize + wire.SizeFixed64()
+	return f.tagsize + protowire.SizeFixed64()
 }
 
 // appendFixed64NoZero wire encodes a uint64 pointer as a Fixed64.
@@ -4336,8 +4336,8 @@
 	if v == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed64(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, v)
 	return b, nil
 }
 
@@ -4351,26 +4351,26 @@
 // sizeFixed64Ptr returns the size of wire encoding a *uint64 pointer as a Fixed64.
 // It panics if the pointer is nil.
 func sizeFixed64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	return f.tagsize + wire.SizeFixed64()
+	return f.tagsize + protowire.SizeFixed64()
 }
 
 // appendFixed64Ptr wire encodes a *uint64 pointer as a Fixed64.
 // It panics if the pointer is nil.
 func appendFixed64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := **p.Uint64Ptr()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed64(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, v)
 	return b, nil
 }
 
 // consumeFixed64Ptr wire decodes a *uint64 pointer as a Fixed64.
-func consumeFixed64Ptr(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed64Type {
+func consumeFixed64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed64(b)
+	v, n := protowire.ConsumeFixed64(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	vp := p.Uint64Ptr()
 	if *vp == nil {
@@ -4391,7 +4391,7 @@
 // sizeFixed64Slice returns the size of wire encoding a []uint64 pointer as a repeated Fixed64.
 func sizeFixed64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	s := *p.Uint64Slice()
-	size = len(s) * (f.tagsize + wire.SizeFixed64())
+	size = len(s) * (f.tagsize + protowire.SizeFixed64())
 	return size
 }
 
@@ -4399,25 +4399,25 @@
 func appendFixed64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.Uint64Slice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendFixed64(b, v)
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendFixed64(b, v)
 	}
 	return b, nil
 }
 
 // consumeFixed64Slice wire decodes a []uint64 pointer as a repeated Fixed64.
-func consumeFixed64Slice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeFixed64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.Uint64Slice()
-	if wtyp == wire.BytesType {
+	if wtyp == protowire.BytesType {
 		s := *sp
-		b, n := wire.ConsumeBytes(b)
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
-			v, n := wire.ConsumeFixed64(b)
+			v, n := protowire.ConsumeFixed64(b)
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 			s = append(s, v)
 			b = b[n:]
@@ -4426,12 +4426,12 @@
 		out.n = n
 		return out, nil
 	}
-	if wtyp != wire.Fixed64Type {
+	if wtyp != protowire.Fixed64Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed64(b)
+	v, n := protowire.ConsumeFixed64(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*sp = append(*sp, v)
 	out.n = n
@@ -4451,8 +4451,8 @@
 	if len(s) == 0 {
 		return 0
 	}
-	n := len(s) * wire.SizeFixed64()
-	return f.tagsize + wire.SizeBytes(n)
+	n := len(s) * protowire.SizeFixed64()
+	return f.tagsize + protowire.SizeBytes(n)
 }
 
 // appendFixed64PackedSlice encodes a []uint64 pointer as a packed repeated Fixed64.
@@ -4461,11 +4461,11 @@
 	if len(s) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	n := len(s) * wire.SizeFixed64()
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := len(s) * protowire.SizeFixed64()
+	b = protowire.AppendVarint(b, uint64(n))
 	for _, v := range s {
-		b = wire.AppendFixed64(b, v)
+		b = protowire.AppendFixed64(b, v)
 	}
 	return b, nil
 }
@@ -4479,24 +4479,24 @@
 
 // sizeFixed64Value returns the size of wire encoding a uint64 value as a Fixed64.
 func sizeFixed64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + wire.SizeFixed64()
+	return tagsize + protowire.SizeFixed64()
 }
 
 // appendFixed64Value encodes a uint64 value as a Fixed64.
 func appendFixed64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendFixed64(b, v.Uint())
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendFixed64(b, v.Uint())
 	return b, nil
 }
 
 // consumeFixed64Value decodes a uint64 value as a Fixed64.
-func consumeFixed64Value(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed64Type {
+func consumeFixed64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeFixed64(b)
+	v, n := protowire.ConsumeFixed64(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
 	return protoreflect.ValueOfUint64(v), out, nil
@@ -4512,7 +4512,7 @@
 // sizeFixed64SliceValue returns the size of wire encoding a []uint64 value as a repeated Fixed64.
 func sizeFixed64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
 	list := listv.List()
-	size = list.Len() * (tagsize + wire.SizeFixed64())
+	size = list.Len() * (tagsize + protowire.SizeFixed64())
 	return size
 }
 
@@ -4521,24 +4521,24 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
-		b = wire.AppendFixed64(b, v.Uint())
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendFixed64(b, v.Uint())
 	}
 	return b, nil
 }
 
 // consumeFixed64SliceValue wire decodes a []uint64 value as a repeated Fixed64.
-func consumeFixed64SliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consumeFixed64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp == wire.BytesType {
-		b, n := wire.ConsumeBytes(b)
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return protoreflect.Value{}, out, wire.ParseError(n)
+			return protoreflect.Value{}, out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
-			v, n := wire.ConsumeFixed64(b)
+			v, n := protowire.ConsumeFixed64(b)
 			if n < 0 {
-				return protoreflect.Value{}, out, wire.ParseError(n)
+				return protoreflect.Value{}, out, protowire.ParseError(n)
 			}
 			list.Append(protoreflect.ValueOfUint64(v))
 			b = b[n:]
@@ -4546,12 +4546,12 @@
 		out.n = n
 		return listv, out, nil
 	}
-	if wtyp != wire.Fixed64Type {
+	if wtyp != protowire.Fixed64Type {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeFixed64(b)
+	v, n := protowire.ConsumeFixed64(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	list.Append(protoreflect.ValueOfUint64(v))
 	out.n = n
@@ -4572,8 +4572,8 @@
 	if llen == 0 {
 		return 0
 	}
-	n := llen * wire.SizeFixed64()
-	return tagsize + wire.SizeBytes(n)
+	n := llen * protowire.SizeFixed64()
+	return tagsize + protowire.SizeBytes(n)
 }
 
 // appendFixed64PackedSliceValue encodes a []uint64 value as a packed repeated Fixed64.
@@ -4583,12 +4583,12 @@
 	if llen == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, wiretag)
-	n := llen * wire.SizeFixed64()
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, wiretag)
+	n := llen * protowire.SizeFixed64()
+	b = protowire.AppendVarint(b, uint64(n))
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendFixed64(b, v.Uint())
+		b = protowire.AppendFixed64(b, v.Uint())
 	}
 	return b, nil
 }
@@ -4603,25 +4603,25 @@
 // sizeDouble returns the size of wire encoding a float64 pointer as a Double.
 func sizeDouble(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 
-	return f.tagsize + wire.SizeFixed64()
+	return f.tagsize + protowire.SizeFixed64()
 }
 
 // appendDouble wire encodes a float64 pointer as a Double.
 func appendDouble(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.Float64()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed64(b, math.Float64bits(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, math.Float64bits(v))
 	return b, nil
 }
 
 // consumeDouble wire decodes a float64 pointer as a Double.
-func consumeDouble(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed64Type {
+func consumeDouble(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed64(b)
+	v, n := protowire.ConsumeFixed64(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*p.Float64() = math.Float64frombits(v)
 	out.n = n
@@ -4642,7 +4642,7 @@
 	if v == 0 && !math.Signbit(float64(v)) {
 		return 0
 	}
-	return f.tagsize + wire.SizeFixed64()
+	return f.tagsize + protowire.SizeFixed64()
 }
 
 // appendDoubleNoZero wire encodes a float64 pointer as a Double.
@@ -4652,8 +4652,8 @@
 	if v == 0 && !math.Signbit(float64(v)) {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed64(b, math.Float64bits(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, math.Float64bits(v))
 	return b, nil
 }
 
@@ -4667,26 +4667,26 @@
 // sizeDoublePtr returns the size of wire encoding a *float64 pointer as a Double.
 // It panics if the pointer is nil.
 func sizeDoublePtr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	return f.tagsize + wire.SizeFixed64()
+	return f.tagsize + protowire.SizeFixed64()
 }
 
 // appendDoublePtr wire encodes a *float64 pointer as a Double.
 // It panics if the pointer is nil.
 func appendDoublePtr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := **p.Float64Ptr()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendFixed64(b, math.Float64bits(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendFixed64(b, math.Float64bits(v))
 	return b, nil
 }
 
 // consumeDoublePtr wire decodes a *float64 pointer as a Double.
-func consumeDoublePtr(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed64Type {
+func consumeDoublePtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed64(b)
+	v, n := protowire.ConsumeFixed64(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	vp := p.Float64Ptr()
 	if *vp == nil {
@@ -4707,7 +4707,7 @@
 // sizeDoubleSlice returns the size of wire encoding a []float64 pointer as a repeated Double.
 func sizeDoubleSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	s := *p.Float64Slice()
-	size = len(s) * (f.tagsize + wire.SizeFixed64())
+	size = len(s) * (f.tagsize + protowire.SizeFixed64())
 	return size
 }
 
@@ -4715,25 +4715,25 @@
 func appendDoubleSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.Float64Slice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendFixed64(b, math.Float64bits(v))
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendFixed64(b, math.Float64bits(v))
 	}
 	return b, nil
 }
 
 // consumeDoubleSlice wire decodes a []float64 pointer as a repeated Double.
-func consumeDoubleSlice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeDoubleSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.Float64Slice()
-	if wtyp == wire.BytesType {
+	if wtyp == protowire.BytesType {
 		s := *sp
-		b, n := wire.ConsumeBytes(b)
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
-			v, n := wire.ConsumeFixed64(b)
+			v, n := protowire.ConsumeFixed64(b)
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 			s = append(s, math.Float64frombits(v))
 			b = b[n:]
@@ -4742,12 +4742,12 @@
 		out.n = n
 		return out, nil
 	}
-	if wtyp != wire.Fixed64Type {
+	if wtyp != protowire.Fixed64Type {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeFixed64(b)
+	v, n := protowire.ConsumeFixed64(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*sp = append(*sp, math.Float64frombits(v))
 	out.n = n
@@ -4767,8 +4767,8 @@
 	if len(s) == 0 {
 		return 0
 	}
-	n := len(s) * wire.SizeFixed64()
-	return f.tagsize + wire.SizeBytes(n)
+	n := len(s) * protowire.SizeFixed64()
+	return f.tagsize + protowire.SizeBytes(n)
 }
 
 // appendDoublePackedSlice encodes a []float64 pointer as a packed repeated Double.
@@ -4777,11 +4777,11 @@
 	if len(s) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	n := len(s) * wire.SizeFixed64()
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, f.wiretag)
+	n := len(s) * protowire.SizeFixed64()
+	b = protowire.AppendVarint(b, uint64(n))
 	for _, v := range s {
-		b = wire.AppendFixed64(b, math.Float64bits(v))
+		b = protowire.AppendFixed64(b, math.Float64bits(v))
 	}
 	return b, nil
 }
@@ -4795,24 +4795,24 @@
 
 // sizeDoubleValue returns the size of wire encoding a float64 value as a Double.
 func sizeDoubleValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + wire.SizeFixed64()
+	return tagsize + protowire.SizeFixed64()
 }
 
 // appendDoubleValue encodes a float64 value as a Double.
 func appendDoubleValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendFixed64(b, math.Float64bits(v.Float()))
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
 	return b, nil
 }
 
 // consumeDoubleValue decodes a float64 value as a Double.
-func consumeDoubleValue(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.Fixed64Type {
+func consumeDoubleValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.Fixed64Type {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeFixed64(b)
+	v, n := protowire.ConsumeFixed64(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
 	return protoreflect.ValueOfFloat64(math.Float64frombits(v)), out, nil
@@ -4828,7 +4828,7 @@
 // sizeDoubleSliceValue returns the size of wire encoding a []float64 value as a repeated Double.
 func sizeDoubleSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
 	list := listv.List()
-	size = list.Len() * (tagsize + wire.SizeFixed64())
+	size = list.Len() * (tagsize + protowire.SizeFixed64())
 	return size
 }
 
@@ -4837,24 +4837,24 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
-		b = wire.AppendFixed64(b, math.Float64bits(v.Float()))
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
 	}
 	return b, nil
 }
 
 // consumeDoubleSliceValue wire decodes a []float64 value as a repeated Double.
-func consumeDoubleSliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consumeDoubleSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp == wire.BytesType {
-		b, n := wire.ConsumeBytes(b)
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return protoreflect.Value{}, out, wire.ParseError(n)
+			return protoreflect.Value{}, out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
-			v, n := wire.ConsumeFixed64(b)
+			v, n := protowire.ConsumeFixed64(b)
 			if n < 0 {
-				return protoreflect.Value{}, out, wire.ParseError(n)
+				return protoreflect.Value{}, out, protowire.ParseError(n)
 			}
 			list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
 			b = b[n:]
@@ -4862,12 +4862,12 @@
 		out.n = n
 		return listv, out, nil
 	}
-	if wtyp != wire.Fixed64Type {
+	if wtyp != protowire.Fixed64Type {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeFixed64(b)
+	v, n := protowire.ConsumeFixed64(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
 	out.n = n
@@ -4888,8 +4888,8 @@
 	if llen == 0 {
 		return 0
 	}
-	n := llen * wire.SizeFixed64()
-	return tagsize + wire.SizeBytes(n)
+	n := llen * protowire.SizeFixed64()
+	return tagsize + protowire.SizeBytes(n)
 }
 
 // appendDoublePackedSliceValue encodes a []float64 value as a packed repeated Double.
@@ -4899,12 +4899,12 @@
 	if llen == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, wiretag)
-	n := llen * wire.SizeFixed64()
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, wiretag)
+	n := llen * protowire.SizeFixed64()
+	b = protowire.AppendVarint(b, uint64(n))
 	for i := 0; i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendFixed64(b, math.Float64bits(v.Float()))
+		b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
 	}
 	return b, nil
 }
@@ -4919,25 +4919,25 @@
 // sizeString returns the size of wire encoding a string pointer as a String.
 func sizeString(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := *p.String()
-	return f.tagsize + wire.SizeBytes(len(v))
+	return f.tagsize + protowire.SizeBytes(len(v))
 }
 
 // appendString wire encodes a string pointer as a String.
 func appendString(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.String()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendString(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendString(b, v)
 	return b, nil
 }
 
 // consumeString wire decodes a string pointer as a String.
-func consumeString(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.BytesType {
+func consumeString(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeString(b)
+	v, n := protowire.ConsumeString(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*p.String() = v
 	out.n = n
@@ -4954,8 +4954,8 @@
 // appendStringValidateUTF8 wire encodes a string pointer as a String.
 func appendStringValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.String()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendString(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendString(b, v)
 	if !utf8.ValidString(v) {
 		return b, errInvalidUTF8{}
 	}
@@ -4963,13 +4963,13 @@
 }
 
 // consumeStringValidateUTF8 wire decodes a string pointer as a String.
-func consumeStringValidateUTF8(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.BytesType {
+func consumeStringValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeString(b)
+	v, n := protowire.ConsumeString(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	if !utf8.ValidString(v) {
 		return out, errInvalidUTF8{}
@@ -4993,7 +4993,7 @@
 	if len(v) == 0 {
 		return 0
 	}
-	return f.tagsize + wire.SizeBytes(len(v))
+	return f.tagsize + protowire.SizeBytes(len(v))
 }
 
 // appendStringNoZero wire encodes a string pointer as a String.
@@ -5003,8 +5003,8 @@
 	if len(v) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendString(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendString(b, v)
 	return b, nil
 }
 
@@ -5022,8 +5022,8 @@
 	if len(v) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendString(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendString(b, v)
 	if !utf8.ValidString(v) {
 		return b, errInvalidUTF8{}
 	}
@@ -5041,26 +5041,26 @@
 // It panics if the pointer is nil.
 func sizeStringPtr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := **p.StringPtr()
-	return f.tagsize + wire.SizeBytes(len(v))
+	return f.tagsize + protowire.SizeBytes(len(v))
 }
 
 // appendStringPtr wire encodes a *string pointer as a String.
 // It panics if the pointer is nil.
 func appendStringPtr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := **p.StringPtr()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendString(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendString(b, v)
 	return b, nil
 }
 
 // consumeStringPtr wire decodes a *string pointer as a String.
-func consumeStringPtr(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.BytesType {
+func consumeStringPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeString(b)
+	v, n := protowire.ConsumeString(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	vp := p.StringPtr()
 	if *vp == nil {
@@ -5082,7 +5082,7 @@
 func sizeStringSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	s := *p.StringSlice()
 	for _, v := range s {
-		size += f.tagsize + wire.SizeBytes(len(v))
+		size += f.tagsize + protowire.SizeBytes(len(v))
 	}
 	return size
 }
@@ -5091,21 +5091,21 @@
 func appendStringSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.StringSlice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendString(b, v)
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendString(b, v)
 	}
 	return b, nil
 }
 
 // consumeStringSlice wire decodes a []string pointer as a repeated String.
-func consumeStringSlice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeStringSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.StringSlice()
-	if wtyp != wire.BytesType {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeString(b)
+	v, n := protowire.ConsumeString(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*sp = append(*sp, v)
 	out.n = n
@@ -5123,8 +5123,8 @@
 func appendStringSliceValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.StringSlice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendString(b, v)
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendString(b, v)
 		if !utf8.ValidString(v) {
 			return b, errInvalidUTF8{}
 		}
@@ -5133,14 +5133,14 @@
 }
 
 // consumeStringSliceValidateUTF8 wire decodes a []string pointer as a repeated String.
-func consumeStringSliceValidateUTF8(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeStringSliceValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.StringSlice()
-	if wtyp != wire.BytesType {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeString(b)
+	v, n := protowire.ConsumeString(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	if !utf8.ValidString(v) {
 		return out, errInvalidUTF8{}
@@ -5159,24 +5159,24 @@
 
 // sizeStringValue returns the size of wire encoding a string value as a String.
 func sizeStringValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + wire.SizeBytes(len(v.String()))
+	return tagsize + protowire.SizeBytes(len(v.String()))
 }
 
 // appendStringValue encodes a string value as a String.
 func appendStringValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendString(b, v.String())
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendString(b, v.String())
 	return b, nil
 }
 
 // consumeStringValue decodes a string value as a String.
-func consumeStringValue(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.BytesType {
+func consumeStringValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeString(b)
+	v, n := protowire.ConsumeString(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
 	return protoreflect.ValueOfString(string(v)), out, nil
@@ -5191,8 +5191,8 @@
 
 // appendStringValueValidateUTF8 encodes a string value as a String.
 func appendStringValueValidateUTF8(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendString(b, v.String())
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendString(b, v.String())
 	if !utf8.ValidString(v.String()) {
 		return b, errInvalidUTF8{}
 	}
@@ -5200,13 +5200,13 @@
 }
 
 // consumeStringValueValidateUTF8 decodes a string value as a String.
-func consumeStringValueValidateUTF8(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.BytesType {
+func consumeStringValueValidateUTF8(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeString(b)
+	v, n := protowire.ConsumeString(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	if !utf8.ValidString(v) {
 		return protoreflect.Value{}, out, errInvalidUTF8{}
@@ -5227,7 +5227,7 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		size += tagsize + wire.SizeBytes(len(v.String()))
+		size += tagsize + protowire.SizeBytes(len(v.String()))
 	}
 	return size
 }
@@ -5237,21 +5237,21 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
-		b = wire.AppendString(b, v.String())
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendString(b, v.String())
 	}
 	return b, nil
 }
 
 // consumeStringSliceValue wire decodes a []string value as a repeated String.
-func consumeStringSliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consumeStringSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp != wire.BytesType {
+	if wtyp != protowire.BytesType {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeString(b)
+	v, n := protowire.ConsumeString(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	list.Append(protoreflect.ValueOfString(string(v)))
 	out.n = n
@@ -5268,25 +5268,25 @@
 // sizeBytes returns the size of wire encoding a []byte pointer as a Bytes.
 func sizeBytes(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := *p.Bytes()
-	return f.tagsize + wire.SizeBytes(len(v))
+	return f.tagsize + protowire.SizeBytes(len(v))
 }
 
 // appendBytes wire encodes a []byte pointer as a Bytes.
 func appendBytes(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.Bytes()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendBytes(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendBytes(b, v)
 	return b, nil
 }
 
 // consumeBytes wire decodes a []byte pointer as a Bytes.
-func consumeBytes(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.BytesType {
+func consumeBytes(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeBytes(b)
+	v, n := protowire.ConsumeBytes(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*p.Bytes() = append(emptyBuf[:], v...)
 	out.n = n
@@ -5303,8 +5303,8 @@
 // appendBytesValidateUTF8 wire encodes a []byte pointer as a Bytes.
 func appendBytesValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	v := *p.Bytes()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendBytes(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendBytes(b, v)
 	if !utf8.Valid(v) {
 		return b, errInvalidUTF8{}
 	}
@@ -5312,13 +5312,13 @@
 }
 
 // consumeBytesValidateUTF8 wire decodes a []byte pointer as a Bytes.
-func consumeBytesValidateUTF8(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.BytesType {
+func consumeBytesValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeBytes(b)
+	v, n := protowire.ConsumeBytes(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	if !utf8.Valid(v) {
 		return out, errInvalidUTF8{}
@@ -5342,7 +5342,7 @@
 	if len(v) == 0 {
 		return 0
 	}
-	return f.tagsize + wire.SizeBytes(len(v))
+	return f.tagsize + protowire.SizeBytes(len(v))
 }
 
 // appendBytesNoZero wire encodes a []byte pointer as a Bytes.
@@ -5352,20 +5352,20 @@
 	if len(v) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendBytes(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendBytes(b, v)
 	return b, nil
 }
 
 // consumeBytesNoZero wire decodes a []byte pointer as a Bytes.
 // The zero value is not decoded.
-func consumeBytesNoZero(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.BytesType {
+func consumeBytesNoZero(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeBytes(b)
+	v, n := protowire.ConsumeBytes(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*p.Bytes() = append(([]byte)(nil), v...)
 	out.n = n
@@ -5386,8 +5386,8 @@
 	if len(v) == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendBytes(b, v)
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendBytes(b, v)
 	if !utf8.Valid(v) {
 		return b, errInvalidUTF8{}
 	}
@@ -5395,13 +5395,13 @@
 }
 
 // consumeBytesNoZeroValidateUTF8 wire decodes a []byte pointer as a Bytes.
-func consumeBytesNoZeroValidateUTF8(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.BytesType {
+func consumeBytesNoZeroValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeBytes(b)
+	v, n := protowire.ConsumeBytes(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	if !utf8.Valid(v) {
 		return out, errInvalidUTF8{}
@@ -5422,7 +5422,7 @@
 func sizeBytesSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	s := *p.BytesSlice()
 	for _, v := range s {
-		size += f.tagsize + wire.SizeBytes(len(v))
+		size += f.tagsize + protowire.SizeBytes(len(v))
 	}
 	return size
 }
@@ -5431,21 +5431,21 @@
 func appendBytesSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.BytesSlice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendBytes(b, v)
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendBytes(b, v)
 	}
 	return b, nil
 }
 
 // consumeBytesSlice wire decodes a [][]byte pointer as a repeated Bytes.
-func consumeBytesSlice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeBytesSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.BytesSlice()
-	if wtyp != wire.BytesType {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeBytes(b)
+	v, n := protowire.ConsumeBytes(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	*sp = append(*sp, append(emptyBuf[:], v...))
 	out.n = n
@@ -5463,8 +5463,8 @@
 func appendBytesSliceValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
 	s := *p.BytesSlice()
 	for _, v := range s {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendBytes(b, v)
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendBytes(b, v)
 		if !utf8.Valid(v) {
 			return b, errInvalidUTF8{}
 		}
@@ -5473,14 +5473,14 @@
 }
 
 // consumeBytesSliceValidateUTF8 wire decodes a [][]byte pointer as a repeated Bytes.
-func consumeBytesSliceValidateUTF8(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeBytesSliceValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
 	sp := p.BytesSlice()
-	if wtyp != wire.BytesType {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeBytes(b)
+	v, n := protowire.ConsumeBytes(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	if !utf8.Valid(v) {
 		return out, errInvalidUTF8{}
@@ -5499,24 +5499,24 @@
 
 // sizeBytesValue returns the size of wire encoding a []byte value as a Bytes.
 func sizeBytesValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + wire.SizeBytes(len(v.Bytes()))
+	return tagsize + protowire.SizeBytes(len(v.Bytes()))
 }
 
 // appendBytesValue encodes a []byte value as a Bytes.
 func appendBytesValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = wire.AppendVarint(b, wiretag)
-	b = wire.AppendBytes(b, v.Bytes())
+	b = protowire.AppendVarint(b, wiretag)
+	b = protowire.AppendBytes(b, v.Bytes())
 	return b, nil
 }
 
 // consumeBytesValue decodes a []byte value as a Bytes.
-func consumeBytesValue(b []byte, _ protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != wire.BytesType {
+func consumeBytesValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeBytes(b)
+	v, n := protowire.ConsumeBytes(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	out.n = n
 	return protoreflect.ValueOfBytes(append(emptyBuf[:], v...)), out, nil
@@ -5534,7 +5534,7 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		size += tagsize + wire.SizeBytes(len(v.Bytes()))
+		size += tagsize + protowire.SizeBytes(len(v.Bytes()))
 	}
 	return size
 }
@@ -5544,21 +5544,21 @@
 	list := listv.List()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		v := list.Get(i)
-		b = wire.AppendVarint(b, wiretag)
-		b = wire.AppendBytes(b, v.Bytes())
+		b = protowire.AppendVarint(b, wiretag)
+		b = protowire.AppendBytes(b, v.Bytes())
 	}
 	return b, nil
 }
 
 // consumeBytesSliceValue wire decodes a [][]byte value as a repeated Bytes.
-func consumeBytesSliceValue(b []byte, listv protoreflect.Value, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
+func consumeBytesSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
 	list := listv.List()
-	if wtyp != wire.BytesType {
+	if wtyp != protowire.BytesType {
 		return protoreflect.Value{}, out, errUnknown
 	}
-	v, n := wire.ConsumeBytes(b)
+	v, n := protowire.ConsumeBytes(b)
 	if n < 0 {
-		return protoreflect.Value{}, out, wire.ParseError(n)
+		return protoreflect.Value{}, out, protowire.ParseError(n)
 	}
 	list.Append(protoreflect.ValueOfBytes(append(emptyBuf[:], v...)))
 	out.n = n
@@ -5575,23 +5575,23 @@
 // We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices.
 var emptyBuf [0]byte
 
-var wireTypes = map[protoreflect.Kind]wire.Type{
-	protoreflect.BoolKind:     wire.VarintType,
-	protoreflect.EnumKind:     wire.VarintType,
-	protoreflect.Int32Kind:    wire.VarintType,
-	protoreflect.Sint32Kind:   wire.VarintType,
-	protoreflect.Uint32Kind:   wire.VarintType,
-	protoreflect.Int64Kind:    wire.VarintType,
-	protoreflect.Sint64Kind:   wire.VarintType,
-	protoreflect.Uint64Kind:   wire.VarintType,
-	protoreflect.Sfixed32Kind: wire.Fixed32Type,
-	protoreflect.Fixed32Kind:  wire.Fixed32Type,
-	protoreflect.FloatKind:    wire.Fixed32Type,
-	protoreflect.Sfixed64Kind: wire.Fixed64Type,
-	protoreflect.Fixed64Kind:  wire.Fixed64Type,
-	protoreflect.DoubleKind:   wire.Fixed64Type,
-	protoreflect.StringKind:   wire.BytesType,
-	protoreflect.BytesKind:    wire.BytesType,
-	protoreflect.MessageKind:  wire.BytesType,
-	protoreflect.GroupKind:    wire.StartGroupType,
+var wireTypes = map[protoreflect.Kind]protowire.Type{
+	protoreflect.BoolKind:     protowire.VarintType,
+	protoreflect.EnumKind:     protowire.VarintType,
+	protoreflect.Int32Kind:    protowire.VarintType,
+	protoreflect.Sint32Kind:   protowire.VarintType,
+	protoreflect.Uint32Kind:   protowire.VarintType,
+	protoreflect.Int64Kind:    protowire.VarintType,
+	protoreflect.Sint64Kind:   protowire.VarintType,
+	protoreflect.Uint64Kind:   protowire.VarintType,
+	protoreflect.Sfixed32Kind: protowire.Fixed32Type,
+	protoreflect.Fixed32Kind:  protowire.Fixed32Type,
+	protoreflect.FloatKind:    protowire.Fixed32Type,
+	protoreflect.Sfixed64Kind: protowire.Fixed64Type,
+	protoreflect.Fixed64Kind:  protowire.Fixed64Type,
+	protoreflect.DoubleKind:   protowire.Fixed64Type,
+	protoreflect.StringKind:   protowire.BytesType,
+	protoreflect.BytesKind:    protowire.BytesType,
+	protoreflect.MessageKind:  protowire.BytesType,
+	protoreflect.GroupKind:    protowire.StartGroupType,
 }
diff --git a/internal/impl/codec_map.go b/internal/impl/codec_map.go
index dd5f8c7..35a67c2 100644
--- a/internal/impl/codec_map.go
+++ b/internal/impl/codec_map.go
@@ -9,7 +9,7 @@
 	"reflect"
 	"sort"
 
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	pref "google.golang.org/protobuf/reflect/protoreflect"
 )
 
@@ -28,8 +28,8 @@
 	// TODO: Consider generating specialized map coders.
 	keyField := fd.MapKey()
 	valField := fd.MapValue()
-	keyWiretag := wire.EncodeTag(1, wireTypes[keyField.Kind()])
-	valWiretag := wire.EncodeTag(2, wireTypes[valField.Kind()])
+	keyWiretag := protowire.EncodeTag(1, wireTypes[keyField.Kind()])
+	valWiretag := protowire.EncodeTag(2, wireTypes[valField.Kind()])
 	keyFuncs := encoderFuncsForValue(keyField)
 	valFuncs := encoderFuncsForValue(valField)
 	conv := newMapConverter(ft, fd)
@@ -55,7 +55,7 @@
 		marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
 			return appendMap(b, p.AsValueOf(ft).Elem(), mapi, f, opts)
 		},
-		unmarshal: func(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
+		unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
 			mp := p.AsValueOf(ft)
 			if mp.Elem().IsNil() {
 				mp.Elem().Set(reflect.MakeMap(mapi.goType))
@@ -104,31 +104,31 @@
 		} else {
 			p := pointerOfValue(iter.Value())
 			valSize += mapValTagSize
-			valSize += wire.SizeBytes(f.mi.sizePointer(p, opts))
+			valSize += protowire.SizeBytes(f.mi.sizePointer(p, opts))
 		}
-		n += f.tagsize + wire.SizeBytes(keySize+valSize)
+		n += f.tagsize + protowire.SizeBytes(keySize+valSize)
 	}
 	return n
 }
 
-func consumeMap(b []byte, mapv reflect.Value, wtyp wire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.BytesType {
+func consumeMap(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	b, n := wire.ConsumeBytes(b)
+	b, n := protowire.ConsumeBytes(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	var (
 		key = mapi.keyZero
 		val = mapi.conv.valConv.New()
 	)
 	for len(b) > 0 {
-		num, wtyp, n := wire.ConsumeTag(b)
+		num, wtyp, n := protowire.ConsumeTag(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
-		if num > wire.MaxValidNumber {
+		if num > protowire.MaxValidNumber {
 			return out, errors.New("invalid field number")
 		}
 		b = b[n:]
@@ -154,9 +154,9 @@
 			n = o.n
 		}
 		if err == errUnknown {
-			n = wire.ConsumeFieldValue(num, wtyp, b)
+			n = protowire.ConsumeFieldValue(num, wtyp, b)
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 		} else if err != nil {
 			return out, err
@@ -168,24 +168,24 @@
 	return out, nil
 }
 
-func consumeMapOfMessage(b []byte, mapv reflect.Value, wtyp wire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.BytesType {
+func consumeMapOfMessage(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.BytesType {
 		return out, errUnknown
 	}
-	b, n := wire.ConsumeBytes(b)
+	b, n := protowire.ConsumeBytes(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	var (
 		key = mapi.keyZero
 		val = reflect.New(f.mi.GoReflectType.Elem())
 	)
 	for len(b) > 0 {
-		num, wtyp, n := wire.ConsumeTag(b)
+		num, wtyp, n := protowire.ConsumeTag(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
-		if num > wire.MaxValidNumber {
+		if num > protowire.MaxValidNumber {
 			return out, errors.New("invalid field number")
 		}
 		b = b[n:]
@@ -201,13 +201,13 @@
 			key = v
 			n = o.n
 		case 2:
-			if wtyp != wire.BytesType {
+			if wtyp != protowire.BytesType {
 				break
 			}
 			var v []byte
-			v, n = wire.ConsumeBytes(b)
+			v, n = protowire.ConsumeBytes(b)
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 			var o unmarshalOutput
 			o, err = f.mi.unmarshalPointer(v, pointerOfValue(val), 0, opts)
@@ -218,9 +218,9 @@
 			}
 		}
 		if err == errUnknown {
-			n = wire.ConsumeFieldValue(num, wtyp, b)
+			n = protowire.ConsumeFieldValue(num, wtyp, b)
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 		} else if err != nil {
 			return out, err
@@ -239,7 +239,7 @@
 		size := 0
 		size += mapi.keyFuncs.size(key.Value(), mapKeyTagSize, opts)
 		size += mapi.valFuncs.size(val, mapValTagSize, opts)
-		b = wire.AppendVarint(b, uint64(size))
+		b = protowire.AppendVarint(b, uint64(size))
 		b, err := mapi.keyFuncs.marshal(b, key.Value(), mapi.keyWiretag, opts)
 		if err != nil {
 			return nil, err
@@ -251,14 +251,14 @@
 		valSize := f.mi.sizePointer(val, opts)
 		size := 0
 		size += mapi.keyFuncs.size(key.Value(), mapKeyTagSize, opts)
-		size += mapValTagSize + wire.SizeBytes(valSize)
-		b = wire.AppendVarint(b, uint64(size))
+		size += mapValTagSize + protowire.SizeBytes(valSize)
+		b = protowire.AppendVarint(b, uint64(size))
 		b, err := mapi.keyFuncs.marshal(b, key.Value(), mapi.keyWiretag, opts)
 		if err != nil {
 			return nil, err
 		}
-		b = wire.AppendVarint(b, mapi.valWiretag)
-		b = wire.AppendVarint(b, uint64(valSize))
+		b = protowire.AppendVarint(b, mapi.valWiretag)
+		b = protowire.AppendVarint(b, uint64(valSize))
 		return f.mi.marshalAppendPointer(b, val, opts)
 	}
 }
@@ -273,7 +273,7 @@
 	iter := mapRange(mapv)
 	for iter.Next() {
 		var err error
-		b = wire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, f.wiretag)
 		b, err = appendMapItem(b, iter.Key(), iter.Value(), mapi, f, opts)
 		if err != nil {
 			return b, err
@@ -302,7 +302,7 @@
 	})
 	for _, key := range keys {
 		var err error
-		b = wire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, f.wiretag)
 		b, err = appendMapItem(b, key, mapv.MapIndex(key), mapi, f, opts)
 		if err != nil {
 			return b, err
diff --git a/internal/impl/codec_message.go b/internal/impl/codec_message.go
index a86468a..370ec65 100644
--- a/internal/impl/codec_message.go
+++ b/internal/impl/codec_message.go
@@ -9,8 +9,8 @@
 	"reflect"
 	"sort"
 
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/encoding/wire"
 	"google.golang.org/protobuf/internal/fieldsort"
 	pref "google.golang.org/protobuf/reflect/protoreflect"
 	piface "google.golang.org/protobuf/runtime/protoiface"
@@ -24,7 +24,7 @@
 
 	orderedCoderFields []*coderFieldInfo
 	denseCoderFields   []*coderFieldInfo
-	coderFields        map[wire.Number]*coderFieldInfo
+	coderFields        map[protowire.Number]*coderFieldInfo
 	sizecacheOffset    offset
 	unknownOffset      offset
 	extensionOffset    offset
@@ -51,7 +51,7 @@
 	mi.unknownOffset = si.unknownOffset
 	mi.extensionOffset = si.extensionOffset
 
-	mi.coderFields = make(map[wire.Number]*coderFieldInfo)
+	mi.coderFields = make(map[protowire.Number]*coderFieldInfo)
 	fields := mi.Desc.Fields()
 	for i := 0; i < fields.Len(); i++ {
 		fd := fields.Get(i)
@@ -63,9 +63,9 @@
 		ft := fs.Type
 		var wiretag uint64
 		if !fd.IsPacked() {
-			wiretag = wire.EncodeTag(fd.Number(), wireTypes[fd.Kind()])
+			wiretag = protowire.EncodeTag(fd.Number(), wireTypes[fd.Kind()])
 		} else {
-			wiretag = wire.EncodeTag(fd.Number(), wire.BytesType)
+			wiretag = protowire.EncodeTag(fd.Number(), protowire.BytesType)
 		}
 		var fieldOffset offset
 		var funcs pointerCoderFuncs
@@ -85,7 +85,7 @@
 			offset:     fieldOffset,
 			wiretag:    wiretag,
 			ft:         ft,
-			tagsize:    wire.SizeVarint(wiretag),
+			tagsize:    protowire.SizeVarint(wiretag),
 			funcs:      funcs,
 			mi:         childMessage,
 			validation: newFieldValidationInfo(mi, si, fd, ft),
diff --git a/internal/impl/codec_messageset.go b/internal/impl/codec_messageset.go
index 432cb49..cfb68e1 100644
--- a/internal/impl/codec_messageset.go
+++ b/internal/impl/codec_messageset.go
@@ -7,8 +7,8 @@
 import (
 	"sort"
 
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/encoding/wire"
 	"google.golang.org/protobuf/internal/errors"
 	"google.golang.org/protobuf/internal/flags"
 )
@@ -24,9 +24,9 @@
 		if xi.funcs.size == nil {
 			continue
 		}
-		num, _ := wire.DecodeTag(xi.wiretag)
+		num, _ := protowire.DecodeTag(xi.wiretag)
 		size += messageset.SizeField(num)
-		size += xi.funcs.size(x.Value(), wire.SizeTag(messageset.FieldMessage), opts)
+		size += xi.funcs.size(x.Value(), protowire.SizeTag(messageset.FieldMessage), opts)
 	}
 
 	unknown := *p.Apply(mi.unknownOffset).Bytes()
@@ -80,9 +80,9 @@
 
 func marshalMessageSetField(mi *MessageInfo, b []byte, x ExtensionField, opts marshalOptions) ([]byte, error) {
 	xi := getExtensionFieldInfo(x.Type())
-	num, _ := wire.DecodeTag(xi.wiretag)
+	num, _ := protowire.DecodeTag(xi.wiretag)
 	b = messageset.AppendFieldStart(b, num)
-	b, err := xi.funcs.marshal(b, x.Value(), wire.EncodeTag(messageset.FieldMessage, wire.BytesType), opts)
+	b, err := xi.funcs.marshal(b, x.Value(), protowire.EncodeTag(messageset.FieldMessage, protowire.BytesType), opts)
 	if err != nil {
 		return b, err
 	}
@@ -102,10 +102,10 @@
 	ext := *ep
 	unknown := p.Apply(mi.unknownOffset).Bytes()
 	initialized := true
-	err = messageset.Unmarshal(b, true, func(num wire.Number, v []byte) error {
-		o, err := mi.unmarshalExtension(v, num, wire.BytesType, ext, opts)
+	err = messageset.Unmarshal(b, true, func(num protowire.Number, v []byte) error {
+		o, err := mi.unmarshalExtension(v, num, protowire.BytesType, ext, opts)
 		if err == errUnknown {
-			*unknown = wire.AppendTag(*unknown, num, wire.BytesType)
+			*unknown = protowire.AppendTag(*unknown, num, protowire.BytesType)
 			*unknown = append(*unknown, v...)
 			return nil
 		}
diff --git a/internal/impl/codec_reflect.go b/internal/impl/codec_reflect.go
index 85811b0..86f7dc3 100644
--- a/internal/impl/codec_reflect.go
+++ b/internal/impl/codec_reflect.go
@@ -9,28 +9,28 @@
 import (
 	"reflect"
 
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 )
 
 func sizeEnum(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
 	v := p.v.Elem().Int()
-	return f.tagsize + wire.SizeVarint(uint64(v))
+	return f.tagsize + protowire.SizeVarint(uint64(v))
 }
 
 func appendEnum(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
 	v := p.v.Elem().Int()
-	b = wire.AppendVarint(b, f.wiretag)
-	b = wire.AppendVarint(b, uint64(v))
+	b = protowire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, uint64(v))
 	return b, nil
 }
 
-func consumeEnum(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeEnum(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeVarint(b)
+	v, n := protowire.ConsumeVarint(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	p.v.Elem().SetInt(int64(v))
 	out.n = n
@@ -83,8 +83,8 @@
 	return appendEnum(b, pointer{p.v.Elem()}, f, opts)
 }
 
-func consumeEnumPtr(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != wire.VarintType {
+func consumeEnumPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
 	if p.v.Elem().IsNil() {
@@ -111,7 +111,7 @@
 func sizeEnumSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
 	s := p.v.Elem()
 	for i, llen := 0, s.Len(); i < llen; i++ {
-		size += wire.SizeVarint(uint64(s.Index(i).Int())) + f.tagsize
+		size += protowire.SizeVarint(uint64(s.Index(i).Int())) + f.tagsize
 	}
 	return size
 }
@@ -119,23 +119,23 @@
 func appendEnumSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
 	s := p.v.Elem()
 	for i, llen := 0, s.Len(); i < llen; i++ {
-		b = wire.AppendVarint(b, f.wiretag)
-		b = wire.AppendVarint(b, uint64(s.Index(i).Int()))
+		b = protowire.AppendVarint(b, f.wiretag)
+		b = protowire.AppendVarint(b, uint64(s.Index(i).Int()))
 	}
 	return b, nil
 }
 
-func consumeEnumSlice(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
+func consumeEnumSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
 	s := p.v.Elem()
-	if wtyp == wire.BytesType {
-		b, n := wire.ConsumeBytes(b)
+	if wtyp == protowire.BytesType {
+		b, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return out, wire.ParseError(n)
+			return out, protowire.ParseError(n)
 		}
 		for len(b) > 0 {
-			v, n := wire.ConsumeVarint(b)
+			v, n := protowire.ConsumeVarint(b)
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 			rv := reflect.New(s.Type().Elem()).Elem()
 			rv.SetInt(int64(v))
@@ -145,12 +145,12 @@
 		out.n = n
 		return out, nil
 	}
-	if wtyp != wire.VarintType {
+	if wtyp != protowire.VarintType {
 		return out, errUnknown
 	}
-	v, n := wire.ConsumeVarint(b)
+	v, n := protowire.ConsumeVarint(b)
 	if n < 0 {
-		return out, wire.ParseError(n)
+		return out, protowire.ParseError(n)
 	}
 	rv := reflect.New(s.Type().Elem()).Elem()
 	rv.SetInt(int64(v))
@@ -178,9 +178,9 @@
 	}
 	n := 0
 	for i := 0; i < llen; i++ {
-		n += wire.SizeVarint(uint64(s.Index(i).Int()))
+		n += protowire.SizeVarint(uint64(s.Index(i).Int()))
 	}
-	return f.tagsize + wire.SizeBytes(n)
+	return f.tagsize + protowire.SizeBytes(n)
 }
 
 func appendEnumPackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
@@ -189,14 +189,14 @@
 	if llen == 0 {
 		return b, nil
 	}
-	b = wire.AppendVarint(b, f.wiretag)
+	b = protowire.AppendVarint(b, f.wiretag)
 	n := 0
 	for i := 0; i < llen; i++ {
-		n += wire.SizeVarint(uint64(s.Index(i).Int()))
+		n += protowire.SizeVarint(uint64(s.Index(i).Int()))
 	}
-	b = wire.AppendVarint(b, uint64(n))
+	b = protowire.AppendVarint(b, uint64(n))
 	for i := 0; i < llen; i++ {
-		b = wire.AppendVarint(b, uint64(s.Index(i).Int()))
+		b = protowire.AppendVarint(b, uint64(s.Index(i).Int()))
 	}
 	return b, nil
 }
diff --git a/internal/impl/codec_tables.go b/internal/impl/codec_tables.go
index ef30356..c934c8d 100644
--- a/internal/impl/codec_tables.go
+++ b/internal/impl/codec_tables.go
@@ -8,7 +8,7 @@
 	"fmt"
 	"reflect"
 
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/strs"
 	pref "google.golang.org/protobuf/reflect/protoreflect"
 )
@@ -18,7 +18,7 @@
 	mi        *MessageInfo
 	size      func(p pointer, f *coderFieldInfo, opts marshalOptions) int
 	marshal   func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error)
-	unmarshal func(b []byte, p pointer, wtyp wire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error)
+	unmarshal func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error)
 	isInit    func(p pointer, f *coderFieldInfo) error
 	merge     func(dst, src pointer, f *coderFieldInfo, opts mergeOptions)
 }
@@ -27,7 +27,7 @@
 type valueCoderFuncs struct {
 	size      func(v pref.Value, tagsize int, opts marshalOptions) int
 	marshal   func(b []byte, v pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error)
-	unmarshal func(b []byte, v pref.Value, num wire.Number, wtyp wire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error)
+	unmarshal func(b []byte, v pref.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error)
 	isInit    func(v pref.Value) error
 	merge     func(dst, src pref.Value, opts mergeOptions) pref.Value
 }
diff --git a/internal/impl/decode.go b/internal/impl/decode.go
index 5a19f23..85ba1d3 100644
--- a/internal/impl/decode.go
+++ b/internal/impl/decode.go
@@ -7,7 +7,7 @@
 import (
 	"math/bits"
 
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/errors"
 	"google.golang.org/protobuf/internal/flags"
 	"google.golang.org/protobuf/proto"
@@ -78,7 +78,7 @@
 // This is a sentinel error which should never be visible to the user.
 var errUnknown = errors.New("unknown")
 
-func (mi *MessageInfo) unmarshalPointer(b []byte, p pointer, groupTag wire.Number, opts unmarshalOptions) (out unmarshalOutput, err error) {
+func (mi *MessageInfo) unmarshalPointer(b []byte, p pointer, groupTag protowire.Number, opts unmarshalOptions) (out unmarshalOutput, err error) {
 	mi.init()
 	if flags.ProtoLegacy && mi.isMessageSet {
 		return unmarshalMessageSet(mi, b, p, opts)
@@ -98,21 +98,21 @@
 			b = b[2:]
 		} else {
 			var n int
-			tag, n = wire.ConsumeVarint(b)
+			tag, n = protowire.ConsumeVarint(b)
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 			b = b[n:]
 		}
-		var num wire.Number
-		if n := tag >> 3; n < uint64(wire.MinValidNumber) || n > uint64(wire.MaxValidNumber) {
+		var num protowire.Number
+		if n := tag >> 3; n < uint64(protowire.MinValidNumber) || n > uint64(protowire.MaxValidNumber) {
 			return out, errors.New("invalid field number")
 		} else {
-			num = wire.Number(n)
+			num = protowire.Number(n)
 		}
-		wtyp := wire.Type(tag & 7)
+		wtyp := protowire.Type(tag & 7)
 
-		if wtyp == wire.EndGroupType {
+		if wtyp == protowire.EndGroupType {
 			if num != groupTag {
 				return out, errors.New("mismatching end group marker")
 			}
@@ -168,13 +168,13 @@
 			if err != errUnknown {
 				return out, err
 			}
-			n = wire.ConsumeFieldValue(num, wtyp, b)
+			n = protowire.ConsumeFieldValue(num, wtyp, b)
 			if n < 0 {
-				return out, wire.ParseError(n)
+				return out, protowire.ParseError(n)
 			}
 			if !opts.DiscardUnknown() && mi.unknownOffset.IsValid() {
 				u := p.Apply(mi.unknownOffset).Bytes()
-				*u = wire.AppendTag(*u, num, wtyp)
+				*u = protowire.AppendTag(*u, num, wtyp)
 				*u = append(*u, b[:n]...)
 			}
 		}
@@ -193,7 +193,7 @@
 	return out, nil
 }
 
-func (mi *MessageInfo) unmarshalExtension(b []byte, num wire.Number, wtyp wire.Type, exts map[int32]ExtensionField, opts unmarshalOptions) (out unmarshalOutput, err error) {
+func (mi *MessageInfo) unmarshalExtension(b []byte, num protowire.Number, wtyp protowire.Type, exts map[int32]ExtensionField, opts unmarshalOptions) (out unmarshalOutput, err error) {
 	x := exts[int32(num)]
 	xt := x.Type()
 	if xt == nil {
@@ -245,17 +245,17 @@
 	return out, nil
 }
 
-func skipExtension(b []byte, xi *extensionFieldInfo, num wire.Number, wtyp wire.Type, opts unmarshalOptions) (out unmarshalOutput, _ ValidationStatus) {
+func skipExtension(b []byte, xi *extensionFieldInfo, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, _ ValidationStatus) {
 	if xi.validation.mi == nil {
 		return out, ValidationUnknown
 	}
 	xi.validation.mi.init()
 	switch xi.validation.typ {
 	case validationTypeMessage:
-		if wtyp != wire.BytesType {
+		if wtyp != protowire.BytesType {
 			return out, ValidationUnknown
 		}
-		v, n := wire.ConsumeBytes(b)
+		v, n := protowire.ConsumeBytes(b)
 		if n < 0 {
 			return out, ValidationUnknown
 		}
@@ -263,7 +263,7 @@
 		out.n = n
 		return out, st
 	case validationTypeGroup:
-		if wtyp != wire.StartGroupType {
+		if wtyp != protowire.StartGroupType {
 			return out, ValidationUnknown
 		}
 		out, st := xi.validation.mi.validate(b, num, opts)
diff --git a/internal/impl/validate.go b/internal/impl/validate.go
index c0148ab..39d62fd 100644
--- a/internal/impl/validate.go
+++ b/internal/impl/validate.go
@@ -11,8 +11,8 @@
 	"reflect"
 	"unicode/utf8"
 
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/encoding/wire"
 	"google.golang.org/protobuf/internal/flags"
 	"google.golang.org/protobuf/internal/strs"
 	pref "google.golang.org/protobuf/reflect/protoreflect"
@@ -163,11 +163,11 @@
 			}
 		default:
 			switch wireTypes[fd.Kind()] {
-			case wire.VarintType:
+			case protowire.VarintType:
 				vi.typ = validationTypeRepeatedVarint
-			case wire.Fixed32Type:
+			case protowire.Fixed32Type:
 				vi.typ = validationTypeRepeatedFixed32
-			case wire.Fixed64Type:
+			case protowire.Fixed64Type:
 				vi.typ = validationTypeRepeatedFixed64
 			}
 		}
@@ -207,13 +207,13 @@
 			}
 		default:
 			switch wireTypes[fd.Kind()] {
-			case wire.VarintType:
+			case protowire.VarintType:
 				vi.typ = validationTypeVarint
-			case wire.Fixed32Type:
+			case protowire.Fixed32Type:
 				vi.typ = validationTypeFixed32
-			case wire.Fixed64Type:
+			case protowire.Fixed64Type:
 				vi.typ = validationTypeFixed64
-			case wire.BytesType:
+			case protowire.BytesType:
 				vi.typ = validationTypeBytes
 			}
 		}
@@ -221,12 +221,12 @@
 	return vi
 }
 
-func (mi *MessageInfo) validate(b []byte, groupTag wire.Number, opts unmarshalOptions) (out unmarshalOutput, result ValidationStatus) {
+func (mi *MessageInfo) validate(b []byte, groupTag protowire.Number, opts unmarshalOptions) (out unmarshalOutput, result ValidationStatus) {
 	mi.init()
 	type validationState struct {
 		typ              validationType
 		keyType, valType validationType
-		endGroup         wire.Number
+		endGroup         protowire.Number
 		mi               *MessageInfo
 		tail             []byte
 		requiredMask     uint64
@@ -258,21 +258,21 @@
 				b = b[2:]
 			} else {
 				var n int
-				tag, n = wire.ConsumeVarint(b)
+				tag, n = protowire.ConsumeVarint(b)
 				if n < 0 {
 					return out, ValidationInvalid
 				}
 				b = b[n:]
 			}
-			var num wire.Number
-			if n := tag >> 3; n < uint64(wire.MinValidNumber) || n > uint64(wire.MaxValidNumber) {
+			var num protowire.Number
+			if n := tag >> 3; n < uint64(protowire.MinValidNumber) || n > uint64(protowire.MaxValidNumber) {
 				return out, ValidationInvalid
 			} else {
-				num = wire.Number(n)
+				num = protowire.Number(n)
 			}
-			wtyp := wire.Type(tag & 7)
+			wtyp := protowire.Type(tag & 7)
 
-			if wtyp == wire.EndGroupType {
+			if wtyp == protowire.EndGroupType {
 				if st.endGroup == num {
 					goto PopState
 				}
@@ -348,15 +348,15 @@
 				ok := false
 				switch vi.typ {
 				case validationTypeVarint:
-					ok = wtyp == wire.VarintType
+					ok = wtyp == protowire.VarintType
 				case validationTypeFixed32:
-					ok = wtyp == wire.Fixed32Type
+					ok = wtyp == protowire.Fixed32Type
 				case validationTypeFixed64:
-					ok = wtyp == wire.Fixed64Type
+					ok = wtyp == protowire.Fixed64Type
 				case validationTypeBytes, validationTypeUTF8String, validationTypeMessage:
-					ok = wtyp == wire.BytesType
+					ok = wtyp == protowire.BytesType
 				case validationTypeGroup:
-					ok = wtyp == wire.StartGroupType
+					ok = wtyp == protowire.StartGroupType
 				}
 				if ok {
 					st.requiredMask |= vi.requiredBit
@@ -364,7 +364,7 @@
 			}
 
 			switch wtyp {
-			case wire.VarintType:
+			case protowire.VarintType:
 				if len(b) >= 10 {
 					switch {
 					case b[0] < 0x80:
@@ -417,7 +417,7 @@
 					}
 				}
 				continue State
-			case wire.BytesType:
+			case protowire.BytesType:
 				var size uint64
 				if len(b) >= 1 && b[0] < 0x80 {
 					size = uint64(b[0])
@@ -427,7 +427,7 @@
 					b = b[2:]
 				} else {
 					var n int
-					size, n = wire.ConsumeVarint(b)
+					size, n = protowire.ConsumeVarint(b)
 					if n < 0 {
 						return out, ValidationInvalid
 					}
@@ -461,7 +461,7 @@
 				case validationTypeRepeatedVarint:
 					// Packed field.
 					for len(v) > 0 {
-						_, n := wire.ConsumeVarint(v)
+						_, n := protowire.ConsumeVarint(v)
 						if n < 0 {
 							return out, ValidationInvalid
 						}
@@ -482,17 +482,17 @@
 						return out, ValidationInvalid
 					}
 				}
-			case wire.Fixed32Type:
+			case protowire.Fixed32Type:
 				if len(b) < 4 {
 					return out, ValidationInvalid
 				}
 				b = b[4:]
-			case wire.Fixed64Type:
+			case protowire.Fixed64Type:
 				if len(b) < 8 {
 					return out, ValidationInvalid
 				}
 				b = b[8:]
-			case wire.StartGroupType:
+			case protowire.StartGroupType:
 				switch {
 				case vi.typ == validationTypeGroup:
 					if vi.mi == nil {
@@ -530,7 +530,7 @@
 						continue State
 					}
 				default:
-					n := wire.ConsumeFieldValue(num, wtyp, b)
+					n := protowire.ConsumeFieldValue(num, wtyp, b)
 					if n < 0 {
 						return out, ValidationInvalid
 					}
diff --git a/proto/decode.go b/proto/decode.go
index 536491b..1282147 100644
--- a/proto/decode.go
+++ b/proto/decode.go
@@ -5,8 +5,8 @@
 package proto
 
 import (
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/encoding/wire"
 	"google.golang.org/protobuf/internal/errors"
 	"google.golang.org/protobuf/internal/flags"
 	"google.golang.org/protobuf/internal/pragma"
@@ -110,11 +110,11 @@
 	fields := md.Fields()
 	for len(b) > 0 {
 		// Parse the tag (field number and wire type).
-		num, wtyp, tagLen := wire.ConsumeTag(b)
+		num, wtyp, tagLen := protowire.ConsumeTag(b)
 		if tagLen < 0 {
-			return wire.ParseError(tagLen)
+			return protowire.ParseError(tagLen)
 		}
-		if num > wire.MaxValidNumber {
+		if num > protowire.MaxValidNumber {
 			return errors.New("invalid field number")
 		}
 
@@ -153,9 +153,9 @@
 			if err != errUnknown {
 				return err
 			}
-			valLen = wire.ConsumeFieldValue(num, wtyp, b[tagLen:])
+			valLen = protowire.ConsumeFieldValue(num, wtyp, b[tagLen:])
 			if valLen < 0 {
-				return wire.ParseError(valLen)
+				return protowire.ParseError(valLen)
 			}
 			if !o.DiscardUnknown {
 				m.SetUnknown(append(m.GetUnknown(), b[:tagLen+valLen]...))
@@ -166,7 +166,7 @@
 	return nil
 }
 
-func (o UnmarshalOptions) unmarshalSingular(b []byte, wtyp wire.Type, m protoreflect.Message, fd protoreflect.FieldDescriptor) (n int, err error) {
+func (o UnmarshalOptions) unmarshalSingular(b []byte, wtyp protowire.Type, m protoreflect.Message, fd protoreflect.FieldDescriptor) (n int, err error) {
 	v, n, err := o.unmarshalScalar(b, wtyp, fd)
 	if err != nil {
 		return 0, err
@@ -184,13 +184,13 @@
 	return n, nil
 }
 
-func (o UnmarshalOptions) unmarshalMap(b []byte, wtyp wire.Type, mapv protoreflect.Map, fd protoreflect.FieldDescriptor) (n int, err error) {
-	if wtyp != wire.BytesType {
+func (o UnmarshalOptions) unmarshalMap(b []byte, wtyp protowire.Type, mapv protoreflect.Map, fd protoreflect.FieldDescriptor) (n int, err error) {
+	if wtyp != protowire.BytesType {
 		return 0, errUnknown
 	}
-	b, n = wire.ConsumeBytes(b)
+	b, n = protowire.ConsumeBytes(b)
 	if n < 0 {
-		return 0, wire.ParseError(n)
+		return 0, protowire.ParseError(n)
 	}
 	var (
 		keyField = fd.MapKey()
@@ -207,11 +207,11 @@
 	// Map entries are represented as a two-element message with fields
 	// containing the key and value.
 	for len(b) > 0 {
-		num, wtyp, n := wire.ConsumeTag(b)
+		num, wtyp, n := protowire.ConsumeTag(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
-		if num > wire.MaxValidNumber {
+		if num > protowire.MaxValidNumber {
 			return 0, errors.New("invalid field number")
 		}
 		b = b[n:]
@@ -240,9 +240,9 @@
 			haveVal = true
 		}
 		if err == errUnknown {
-			n = wire.ConsumeFieldValue(num, wtyp, b)
+			n = protowire.ConsumeFieldValue(num, wtyp, b)
 			if n < 0 {
-				return 0, wire.ParseError(n)
+				return 0, protowire.ParseError(n)
 			}
 		} else if err != nil {
 			return 0, err
diff --git a/proto/decode_gen.go b/proto/decode_gen.go
index b850fb4..d6dc904 100644
--- a/proto/decode_gen.go
+++ b/proto/decode_gen.go
@@ -10,7 +10,7 @@
 	"math"
 	"unicode/utf8"
 
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/errors"
 	"google.golang.org/protobuf/internal/strs"
 	"google.golang.org/protobuf/reflect/protoreflect"
@@ -19,171 +19,171 @@
 // unmarshalScalar decodes a value of the given kind.
 //
 // Message values are decoded into a []byte which aliases the input data.
-func (o UnmarshalOptions) unmarshalScalar(b []byte, wtyp wire.Type, fd protoreflect.FieldDescriptor) (val protoreflect.Value, n int, err error) {
+func (o UnmarshalOptions) unmarshalScalar(b []byte, wtyp protowire.Type, fd protoreflect.FieldDescriptor) (val protoreflect.Value, n int, err error) {
 	switch fd.Kind() {
 	case protoreflect.BoolKind:
-		if wtyp != wire.VarintType {
+		if wtyp != protowire.VarintType {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeVarint(b)
+		v, n := protowire.ConsumeVarint(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
-		return protoreflect.ValueOfBool(wire.DecodeBool(v)), n, nil
+		return protoreflect.ValueOfBool(protowire.DecodeBool(v)), n, nil
 	case protoreflect.EnumKind:
-		if wtyp != wire.VarintType {
+		if wtyp != protowire.VarintType {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeVarint(b)
+		v, n := protowire.ConsumeVarint(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
 		return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)), n, nil
 	case protoreflect.Int32Kind:
-		if wtyp != wire.VarintType {
+		if wtyp != protowire.VarintType {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeVarint(b)
+		v, n := protowire.ConsumeVarint(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
 		return protoreflect.ValueOfInt32(int32(v)), n, nil
 	case protoreflect.Sint32Kind:
-		if wtyp != wire.VarintType {
+		if wtyp != protowire.VarintType {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeVarint(b)
+		v, n := protowire.ConsumeVarint(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
-		return protoreflect.ValueOfInt32(int32(wire.DecodeZigZag(v & math.MaxUint32))), n, nil
+		return protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))), n, nil
 	case protoreflect.Uint32Kind:
-		if wtyp != wire.VarintType {
+		if wtyp != protowire.VarintType {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeVarint(b)
+		v, n := protowire.ConsumeVarint(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
 		return protoreflect.ValueOfUint32(uint32(v)), n, nil
 	case protoreflect.Int64Kind:
-		if wtyp != wire.VarintType {
+		if wtyp != protowire.VarintType {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeVarint(b)
+		v, n := protowire.ConsumeVarint(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
 		return protoreflect.ValueOfInt64(int64(v)), n, nil
 	case protoreflect.Sint64Kind:
-		if wtyp != wire.VarintType {
+		if wtyp != protowire.VarintType {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeVarint(b)
+		v, n := protowire.ConsumeVarint(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
-		return protoreflect.ValueOfInt64(wire.DecodeZigZag(v)), n, nil
+		return protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)), n, nil
 	case protoreflect.Uint64Kind:
-		if wtyp != wire.VarintType {
+		if wtyp != protowire.VarintType {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeVarint(b)
+		v, n := protowire.ConsumeVarint(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
 		return protoreflect.ValueOfUint64(v), n, nil
 	case protoreflect.Sfixed32Kind:
-		if wtyp != wire.Fixed32Type {
+		if wtyp != protowire.Fixed32Type {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeFixed32(b)
+		v, n := protowire.ConsumeFixed32(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
 		return protoreflect.ValueOfInt32(int32(v)), n, nil
 	case protoreflect.Fixed32Kind:
-		if wtyp != wire.Fixed32Type {
+		if wtyp != protowire.Fixed32Type {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeFixed32(b)
+		v, n := protowire.ConsumeFixed32(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
 		return protoreflect.ValueOfUint32(uint32(v)), n, nil
 	case protoreflect.FloatKind:
-		if wtyp != wire.Fixed32Type {
+		if wtyp != protowire.Fixed32Type {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeFixed32(b)
+		v, n := protowire.ConsumeFixed32(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
 		return protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))), n, nil
 	case protoreflect.Sfixed64Kind:
-		if wtyp != wire.Fixed64Type {
+		if wtyp != protowire.Fixed64Type {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeFixed64(b)
+		v, n := protowire.ConsumeFixed64(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
 		return protoreflect.ValueOfInt64(int64(v)), n, nil
 	case protoreflect.Fixed64Kind:
-		if wtyp != wire.Fixed64Type {
+		if wtyp != protowire.Fixed64Type {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeFixed64(b)
+		v, n := protowire.ConsumeFixed64(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
 		return protoreflect.ValueOfUint64(v), n, nil
 	case protoreflect.DoubleKind:
-		if wtyp != wire.Fixed64Type {
+		if wtyp != protowire.Fixed64Type {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeFixed64(b)
+		v, n := protowire.ConsumeFixed64(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
 		return protoreflect.ValueOfFloat64(math.Float64frombits(v)), n, nil
 	case protoreflect.StringKind:
-		if wtyp != wire.BytesType {
+		if wtyp != protowire.BytesType {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeBytes(b)
+		v, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
 		if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
 			return protoreflect.Value{}, 0, errors.InvalidUTF8(string(fd.FullName()))
 		}
 		return protoreflect.ValueOfString(string(v)), n, nil
 	case protoreflect.BytesKind:
-		if wtyp != wire.BytesType {
+		if wtyp != protowire.BytesType {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeBytes(b)
+		v, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
 		return protoreflect.ValueOfBytes(append(emptyBuf[:], v...)), n, nil
 	case protoreflect.MessageKind:
-		if wtyp != wire.BytesType {
+		if wtyp != protowire.BytesType {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeBytes(b)
+		v, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
 		return protoreflect.ValueOfBytes(v), n, nil
 	case protoreflect.GroupKind:
-		if wtyp != wire.StartGroupType {
+		if wtyp != protowire.StartGroupType {
 			return val, 0, errUnknown
 		}
-		v, n := wire.ConsumeGroup(fd.Number(), b)
+		v, n := protowire.ConsumeGroup(fd.Number(), b)
 		if n < 0 {
-			return val, 0, wire.ParseError(n)
+			return val, 0, protowire.ParseError(n)
 		}
 		return protoreflect.ValueOfBytes(v), n, nil
 	default:
@@ -191,365 +191,365 @@
 	}
 }
 
-func (o UnmarshalOptions) unmarshalList(b []byte, wtyp wire.Type, list protoreflect.List, fd protoreflect.FieldDescriptor) (n int, err error) {
+func (o UnmarshalOptions) unmarshalList(b []byte, wtyp protowire.Type, list protoreflect.List, fd protoreflect.FieldDescriptor) (n int, err error) {
 	switch fd.Kind() {
 	case protoreflect.BoolKind:
-		if wtyp == wire.BytesType {
-			buf, n := wire.ConsumeBytes(b)
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
 			if n < 0 {
-				return 0, wire.ParseError(n)
+				return 0, protowire.ParseError(n)
 			}
 			for len(buf) > 0 {
-				v, n := wire.ConsumeVarint(buf)
+				v, n := protowire.ConsumeVarint(buf)
 				if n < 0 {
-					return 0, wire.ParseError(n)
+					return 0, protowire.ParseError(n)
 				}
 				buf = buf[n:]
-				list.Append(protoreflect.ValueOfBool(wire.DecodeBool(v)))
+				list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
 			}
 			return n, nil
 		}
-		if wtyp != wire.VarintType {
+		if wtyp != protowire.VarintType {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeVarint(b)
+		v, n := protowire.ConsumeVarint(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
-		list.Append(protoreflect.ValueOfBool(wire.DecodeBool(v)))
+		list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
 		return n, nil
 	case protoreflect.EnumKind:
-		if wtyp == wire.BytesType {
-			buf, n := wire.ConsumeBytes(b)
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
 			if n < 0 {
-				return 0, wire.ParseError(n)
+				return 0, protowire.ParseError(n)
 			}
 			for len(buf) > 0 {
-				v, n := wire.ConsumeVarint(buf)
+				v, n := protowire.ConsumeVarint(buf)
 				if n < 0 {
-					return 0, wire.ParseError(n)
+					return 0, protowire.ParseError(n)
 				}
 				buf = buf[n:]
 				list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
 			}
 			return n, nil
 		}
-		if wtyp != wire.VarintType {
+		if wtyp != protowire.VarintType {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeVarint(b)
+		v, n := protowire.ConsumeVarint(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
 		list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
 		return n, nil
 	case protoreflect.Int32Kind:
-		if wtyp == wire.BytesType {
-			buf, n := wire.ConsumeBytes(b)
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
 			if n < 0 {
-				return 0, wire.ParseError(n)
+				return 0, protowire.ParseError(n)
 			}
 			for len(buf) > 0 {
-				v, n := wire.ConsumeVarint(buf)
+				v, n := protowire.ConsumeVarint(buf)
 				if n < 0 {
-					return 0, wire.ParseError(n)
+					return 0, protowire.ParseError(n)
 				}
 				buf = buf[n:]
 				list.Append(protoreflect.ValueOfInt32(int32(v)))
 			}
 			return n, nil
 		}
-		if wtyp != wire.VarintType {
+		if wtyp != protowire.VarintType {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeVarint(b)
+		v, n := protowire.ConsumeVarint(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
 		list.Append(protoreflect.ValueOfInt32(int32(v)))
 		return n, nil
 	case protoreflect.Sint32Kind:
-		if wtyp == wire.BytesType {
-			buf, n := wire.ConsumeBytes(b)
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
 			if n < 0 {
-				return 0, wire.ParseError(n)
+				return 0, protowire.ParseError(n)
 			}
 			for len(buf) > 0 {
-				v, n := wire.ConsumeVarint(buf)
+				v, n := protowire.ConsumeVarint(buf)
 				if n < 0 {
-					return 0, wire.ParseError(n)
+					return 0, protowire.ParseError(n)
 				}
 				buf = buf[n:]
-				list.Append(protoreflect.ValueOfInt32(int32(wire.DecodeZigZag(v & math.MaxUint32))))
+				list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
 			}
 			return n, nil
 		}
-		if wtyp != wire.VarintType {
+		if wtyp != protowire.VarintType {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeVarint(b)
+		v, n := protowire.ConsumeVarint(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
-		list.Append(protoreflect.ValueOfInt32(int32(wire.DecodeZigZag(v & math.MaxUint32))))
+		list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
 		return n, nil
 	case protoreflect.Uint32Kind:
-		if wtyp == wire.BytesType {
-			buf, n := wire.ConsumeBytes(b)
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
 			if n < 0 {
-				return 0, wire.ParseError(n)
+				return 0, protowire.ParseError(n)
 			}
 			for len(buf) > 0 {
-				v, n := wire.ConsumeVarint(buf)
+				v, n := protowire.ConsumeVarint(buf)
 				if n < 0 {
-					return 0, wire.ParseError(n)
+					return 0, protowire.ParseError(n)
 				}
 				buf = buf[n:]
 				list.Append(protoreflect.ValueOfUint32(uint32(v)))
 			}
 			return n, nil
 		}
-		if wtyp != wire.VarintType {
+		if wtyp != protowire.VarintType {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeVarint(b)
+		v, n := protowire.ConsumeVarint(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
 		list.Append(protoreflect.ValueOfUint32(uint32(v)))
 		return n, nil
 	case protoreflect.Int64Kind:
-		if wtyp == wire.BytesType {
-			buf, n := wire.ConsumeBytes(b)
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
 			if n < 0 {
-				return 0, wire.ParseError(n)
+				return 0, protowire.ParseError(n)
 			}
 			for len(buf) > 0 {
-				v, n := wire.ConsumeVarint(buf)
+				v, n := protowire.ConsumeVarint(buf)
 				if n < 0 {
-					return 0, wire.ParseError(n)
+					return 0, protowire.ParseError(n)
 				}
 				buf = buf[n:]
 				list.Append(protoreflect.ValueOfInt64(int64(v)))
 			}
 			return n, nil
 		}
-		if wtyp != wire.VarintType {
+		if wtyp != protowire.VarintType {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeVarint(b)
+		v, n := protowire.ConsumeVarint(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
 		list.Append(protoreflect.ValueOfInt64(int64(v)))
 		return n, nil
 	case protoreflect.Sint64Kind:
-		if wtyp == wire.BytesType {
-			buf, n := wire.ConsumeBytes(b)
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
 			if n < 0 {
-				return 0, wire.ParseError(n)
+				return 0, protowire.ParseError(n)
 			}
 			for len(buf) > 0 {
-				v, n := wire.ConsumeVarint(buf)
+				v, n := protowire.ConsumeVarint(buf)
 				if n < 0 {
-					return 0, wire.ParseError(n)
+					return 0, protowire.ParseError(n)
 				}
 				buf = buf[n:]
-				list.Append(protoreflect.ValueOfInt64(wire.DecodeZigZag(v)))
+				list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
 			}
 			return n, nil
 		}
-		if wtyp != wire.VarintType {
+		if wtyp != protowire.VarintType {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeVarint(b)
+		v, n := protowire.ConsumeVarint(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
-		list.Append(protoreflect.ValueOfInt64(wire.DecodeZigZag(v)))
+		list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
 		return n, nil
 	case protoreflect.Uint64Kind:
-		if wtyp == wire.BytesType {
-			buf, n := wire.ConsumeBytes(b)
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
 			if n < 0 {
-				return 0, wire.ParseError(n)
+				return 0, protowire.ParseError(n)
 			}
 			for len(buf) > 0 {
-				v, n := wire.ConsumeVarint(buf)
+				v, n := protowire.ConsumeVarint(buf)
 				if n < 0 {
-					return 0, wire.ParseError(n)
+					return 0, protowire.ParseError(n)
 				}
 				buf = buf[n:]
 				list.Append(protoreflect.ValueOfUint64(v))
 			}
 			return n, nil
 		}
-		if wtyp != wire.VarintType {
+		if wtyp != protowire.VarintType {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeVarint(b)
+		v, n := protowire.ConsumeVarint(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
 		list.Append(protoreflect.ValueOfUint64(v))
 		return n, nil
 	case protoreflect.Sfixed32Kind:
-		if wtyp == wire.BytesType {
-			buf, n := wire.ConsumeBytes(b)
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
 			if n < 0 {
-				return 0, wire.ParseError(n)
+				return 0, protowire.ParseError(n)
 			}
 			for len(buf) > 0 {
-				v, n := wire.ConsumeFixed32(buf)
+				v, n := protowire.ConsumeFixed32(buf)
 				if n < 0 {
-					return 0, wire.ParseError(n)
+					return 0, protowire.ParseError(n)
 				}
 				buf = buf[n:]
 				list.Append(protoreflect.ValueOfInt32(int32(v)))
 			}
 			return n, nil
 		}
-		if wtyp != wire.Fixed32Type {
+		if wtyp != protowire.Fixed32Type {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeFixed32(b)
+		v, n := protowire.ConsumeFixed32(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
 		list.Append(protoreflect.ValueOfInt32(int32(v)))
 		return n, nil
 	case protoreflect.Fixed32Kind:
-		if wtyp == wire.BytesType {
-			buf, n := wire.ConsumeBytes(b)
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
 			if n < 0 {
-				return 0, wire.ParseError(n)
+				return 0, protowire.ParseError(n)
 			}
 			for len(buf) > 0 {
-				v, n := wire.ConsumeFixed32(buf)
+				v, n := protowire.ConsumeFixed32(buf)
 				if n < 0 {
-					return 0, wire.ParseError(n)
+					return 0, protowire.ParseError(n)
 				}
 				buf = buf[n:]
 				list.Append(protoreflect.ValueOfUint32(uint32(v)))
 			}
 			return n, nil
 		}
-		if wtyp != wire.Fixed32Type {
+		if wtyp != protowire.Fixed32Type {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeFixed32(b)
+		v, n := protowire.ConsumeFixed32(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
 		list.Append(protoreflect.ValueOfUint32(uint32(v)))
 		return n, nil
 	case protoreflect.FloatKind:
-		if wtyp == wire.BytesType {
-			buf, n := wire.ConsumeBytes(b)
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
 			if n < 0 {
-				return 0, wire.ParseError(n)
+				return 0, protowire.ParseError(n)
 			}
 			for len(buf) > 0 {
-				v, n := wire.ConsumeFixed32(buf)
+				v, n := protowire.ConsumeFixed32(buf)
 				if n < 0 {
-					return 0, wire.ParseError(n)
+					return 0, protowire.ParseError(n)
 				}
 				buf = buf[n:]
 				list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
 			}
 			return n, nil
 		}
-		if wtyp != wire.Fixed32Type {
+		if wtyp != protowire.Fixed32Type {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeFixed32(b)
+		v, n := protowire.ConsumeFixed32(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
 		list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
 		return n, nil
 	case protoreflect.Sfixed64Kind:
-		if wtyp == wire.BytesType {
-			buf, n := wire.ConsumeBytes(b)
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
 			if n < 0 {
-				return 0, wire.ParseError(n)
+				return 0, protowire.ParseError(n)
 			}
 			for len(buf) > 0 {
-				v, n := wire.ConsumeFixed64(buf)
+				v, n := protowire.ConsumeFixed64(buf)
 				if n < 0 {
-					return 0, wire.ParseError(n)
+					return 0, protowire.ParseError(n)
 				}
 				buf = buf[n:]
 				list.Append(protoreflect.ValueOfInt64(int64(v)))
 			}
 			return n, nil
 		}
-		if wtyp != wire.Fixed64Type {
+		if wtyp != protowire.Fixed64Type {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeFixed64(b)
+		v, n := protowire.ConsumeFixed64(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
 		list.Append(protoreflect.ValueOfInt64(int64(v)))
 		return n, nil
 	case protoreflect.Fixed64Kind:
-		if wtyp == wire.BytesType {
-			buf, n := wire.ConsumeBytes(b)
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
 			if n < 0 {
-				return 0, wire.ParseError(n)
+				return 0, protowire.ParseError(n)
 			}
 			for len(buf) > 0 {
-				v, n := wire.ConsumeFixed64(buf)
+				v, n := protowire.ConsumeFixed64(buf)
 				if n < 0 {
-					return 0, wire.ParseError(n)
+					return 0, protowire.ParseError(n)
 				}
 				buf = buf[n:]
 				list.Append(protoreflect.ValueOfUint64(v))
 			}
 			return n, nil
 		}
-		if wtyp != wire.Fixed64Type {
+		if wtyp != protowire.Fixed64Type {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeFixed64(b)
+		v, n := protowire.ConsumeFixed64(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
 		list.Append(protoreflect.ValueOfUint64(v))
 		return n, nil
 	case protoreflect.DoubleKind:
-		if wtyp == wire.BytesType {
-			buf, n := wire.ConsumeBytes(b)
+		if wtyp == protowire.BytesType {
+			buf, n := protowire.ConsumeBytes(b)
 			if n < 0 {
-				return 0, wire.ParseError(n)
+				return 0, protowire.ParseError(n)
 			}
 			for len(buf) > 0 {
-				v, n := wire.ConsumeFixed64(buf)
+				v, n := protowire.ConsumeFixed64(buf)
 				if n < 0 {
-					return 0, wire.ParseError(n)
+					return 0, protowire.ParseError(n)
 				}
 				buf = buf[n:]
 				list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
 			}
 			return n, nil
 		}
-		if wtyp != wire.Fixed64Type {
+		if wtyp != protowire.Fixed64Type {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeFixed64(b)
+		v, n := protowire.ConsumeFixed64(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
 		list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
 		return n, nil
 	case protoreflect.StringKind:
-		if wtyp != wire.BytesType {
+		if wtyp != protowire.BytesType {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeBytes(b)
+		v, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
 		if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
 			return 0, errors.InvalidUTF8(string(fd.FullName()))
@@ -557,22 +557,22 @@
 		list.Append(protoreflect.ValueOfString(string(v)))
 		return n, nil
 	case protoreflect.BytesKind:
-		if wtyp != wire.BytesType {
+		if wtyp != protowire.BytesType {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeBytes(b)
+		v, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
 		list.Append(protoreflect.ValueOfBytes(append(emptyBuf[:], v...)))
 		return n, nil
 	case protoreflect.MessageKind:
-		if wtyp != wire.BytesType {
+		if wtyp != protowire.BytesType {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeBytes(b)
+		v, n := protowire.ConsumeBytes(b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
 		m := list.NewElement()
 		if err := o.unmarshalMessage(v, m.Message()); err != nil {
@@ -581,12 +581,12 @@
 		list.Append(m)
 		return n, nil
 	case protoreflect.GroupKind:
-		if wtyp != wire.StartGroupType {
+		if wtyp != protowire.StartGroupType {
 			return 0, errUnknown
 		}
-		v, n := wire.ConsumeGroup(fd.Number(), b)
+		v, n := protowire.ConsumeGroup(fd.Number(), b)
 		if n < 0 {
-			return 0, wire.ParseError(n)
+			return 0, protowire.ParseError(n)
 		}
 		m := list.NewElement()
 		if err := o.unmarshalMessage(v, m.Message()); err != nil {
diff --git a/proto/encode.go b/proto/encode.go
index 999aa7b..fa738a1 100644
--- a/proto/encode.go
+++ b/proto/encode.go
@@ -7,8 +7,8 @@
 import (
 	"sort"
 
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/encoding/wire"
 	"google.golang.org/protobuf/internal/fieldsort"
 	"google.golang.org/protobuf/internal/mapsort"
 	"google.golang.org/protobuf/internal/pragma"
@@ -219,14 +219,14 @@
 	case fd.IsMap():
 		return o.marshalMap(b, fd, value.Map())
 	default:
-		b = wire.AppendTag(b, fd.Number(), wireTypes[fd.Kind()])
+		b = protowire.AppendTag(b, fd.Number(), wireTypes[fd.Kind()])
 		return o.marshalSingular(b, fd, value)
 	}
 }
 
 func (o MarshalOptions) marshalList(b []byte, fd protoreflect.FieldDescriptor, list protoreflect.List) ([]byte, error) {
 	if fd.IsPacked() && list.Len() > 0 {
-		b = wire.AppendTag(b, fd.Number(), wire.BytesType)
+		b = protowire.AppendTag(b, fd.Number(), protowire.BytesType)
 		b, pos := appendSpeculativeLength(b)
 		for i, llen := 0, list.Len(); i < llen; i++ {
 			var err error
@@ -242,7 +242,7 @@
 	kind := fd.Kind()
 	for i, llen := 0, list.Len(); i < llen; i++ {
 		var err error
-		b = wire.AppendTag(b, fd.Number(), wireTypes[kind])
+		b = protowire.AppendTag(b, fd.Number(), wireTypes[kind])
 		b, err = o.marshalSingular(b, fd, list.Get(i))
 		if err != nil {
 			return b, err
@@ -256,7 +256,7 @@
 	valf := fd.MapValue()
 	var err error
 	o.rangeMap(mapv, keyf.Kind(), func(key protoreflect.MapKey, value protoreflect.Value) bool {
-		b = wire.AppendTag(b, fd.Number(), wire.BytesType)
+		b = protowire.AppendTag(b, fd.Number(), protowire.BytesType)
 		var pos int
 		b, pos = appendSpeculativeLength(b)
 
@@ -295,7 +295,7 @@
 
 func finishSpeculativeLength(b []byte, pos int) []byte {
 	mlen := len(b) - pos - speculativeLength
-	msiz := wire.SizeVarint(uint64(mlen))
+	msiz := protowire.SizeVarint(uint64(mlen))
 	if msiz != speculativeLength {
 		for i := 0; i < msiz-speculativeLength; i++ {
 			b = append(b, 0)
@@ -303,6 +303,6 @@
 		copy(b[pos+msiz:], b[pos+speculativeLength:])
 		b = b[:pos+msiz+mlen]
 	}
-	wire.AppendVarint(b[:pos], uint64(mlen))
+	protowire.AppendVarint(b[:pos], uint64(mlen))
 	return b
 }
diff --git a/proto/encode_gen.go b/proto/encode_gen.go
index 1b54088..185dacf 100644
--- a/proto/encode_gen.go
+++ b/proto/encode_gen.go
@@ -10,70 +10,70 @@
 	"math"
 	"unicode/utf8"
 
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/errors"
 	"google.golang.org/protobuf/internal/strs"
 	"google.golang.org/protobuf/reflect/protoreflect"
 )
 
-var wireTypes = map[protoreflect.Kind]wire.Type{
-	protoreflect.BoolKind:     wire.VarintType,
-	protoreflect.EnumKind:     wire.VarintType,
-	protoreflect.Int32Kind:    wire.VarintType,
-	protoreflect.Sint32Kind:   wire.VarintType,
-	protoreflect.Uint32Kind:   wire.VarintType,
-	protoreflect.Int64Kind:    wire.VarintType,
-	protoreflect.Sint64Kind:   wire.VarintType,
-	protoreflect.Uint64Kind:   wire.VarintType,
-	protoreflect.Sfixed32Kind: wire.Fixed32Type,
-	protoreflect.Fixed32Kind:  wire.Fixed32Type,
-	protoreflect.FloatKind:    wire.Fixed32Type,
-	protoreflect.Sfixed64Kind: wire.Fixed64Type,
-	protoreflect.Fixed64Kind:  wire.Fixed64Type,
-	protoreflect.DoubleKind:   wire.Fixed64Type,
-	protoreflect.StringKind:   wire.BytesType,
-	protoreflect.BytesKind:    wire.BytesType,
-	protoreflect.MessageKind:  wire.BytesType,
-	protoreflect.GroupKind:    wire.StartGroupType,
+var wireTypes = map[protoreflect.Kind]protowire.Type{
+	protoreflect.BoolKind:     protowire.VarintType,
+	protoreflect.EnumKind:     protowire.VarintType,
+	protoreflect.Int32Kind:    protowire.VarintType,
+	protoreflect.Sint32Kind:   protowire.VarintType,
+	protoreflect.Uint32Kind:   protowire.VarintType,
+	protoreflect.Int64Kind:    protowire.VarintType,
+	protoreflect.Sint64Kind:   protowire.VarintType,
+	protoreflect.Uint64Kind:   protowire.VarintType,
+	protoreflect.Sfixed32Kind: protowire.Fixed32Type,
+	protoreflect.Fixed32Kind:  protowire.Fixed32Type,
+	protoreflect.FloatKind:    protowire.Fixed32Type,
+	protoreflect.Sfixed64Kind: protowire.Fixed64Type,
+	protoreflect.Fixed64Kind:  protowire.Fixed64Type,
+	protoreflect.DoubleKind:   protowire.Fixed64Type,
+	protoreflect.StringKind:   protowire.BytesType,
+	protoreflect.BytesKind:    protowire.BytesType,
+	protoreflect.MessageKind:  protowire.BytesType,
+	protoreflect.GroupKind:    protowire.StartGroupType,
 }
 
 func (o MarshalOptions) marshalSingular(b []byte, fd protoreflect.FieldDescriptor, v protoreflect.Value) ([]byte, error) {
 	switch fd.Kind() {
 	case protoreflect.BoolKind:
-		b = wire.AppendVarint(b, wire.EncodeBool(v.Bool()))
+		b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
 	case protoreflect.EnumKind:
-		b = wire.AppendVarint(b, uint64(v.Enum()))
+		b = protowire.AppendVarint(b, uint64(v.Enum()))
 	case protoreflect.Int32Kind:
-		b = wire.AppendVarint(b, uint64(int32(v.Int())))
+		b = protowire.AppendVarint(b, uint64(int32(v.Int())))
 	case protoreflect.Sint32Kind:
-		b = wire.AppendVarint(b, wire.EncodeZigZag(int64(int32(v.Int()))))
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
 	case protoreflect.Uint32Kind:
-		b = wire.AppendVarint(b, uint64(uint32(v.Uint())))
+		b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
 	case protoreflect.Int64Kind:
-		b = wire.AppendVarint(b, uint64(v.Int()))
+		b = protowire.AppendVarint(b, uint64(v.Int()))
 	case protoreflect.Sint64Kind:
-		b = wire.AppendVarint(b, wire.EncodeZigZag(v.Int()))
+		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
 	case protoreflect.Uint64Kind:
-		b = wire.AppendVarint(b, v.Uint())
+		b = protowire.AppendVarint(b, v.Uint())
 	case protoreflect.Sfixed32Kind:
-		b = wire.AppendFixed32(b, uint32(v.Int()))
+		b = protowire.AppendFixed32(b, uint32(v.Int()))
 	case protoreflect.Fixed32Kind:
-		b = wire.AppendFixed32(b, uint32(v.Uint()))
+		b = protowire.AppendFixed32(b, uint32(v.Uint()))
 	case protoreflect.FloatKind:
-		b = wire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
+		b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
 	case protoreflect.Sfixed64Kind:
-		b = wire.AppendFixed64(b, uint64(v.Int()))
+		b = protowire.AppendFixed64(b, uint64(v.Int()))
 	case protoreflect.Fixed64Kind:
-		b = wire.AppendFixed64(b, v.Uint())
+		b = protowire.AppendFixed64(b, v.Uint())
 	case protoreflect.DoubleKind:
-		b = wire.AppendFixed64(b, math.Float64bits(v.Float()))
+		b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
 	case protoreflect.StringKind:
 		if strs.EnforceUTF8(fd) && !utf8.ValidString(v.String()) {
 			return b, errors.InvalidUTF8(string(fd.FullName()))
 		}
-		b = wire.AppendString(b, v.String())
+		b = protowire.AppendString(b, v.String())
 	case protoreflect.BytesKind:
-		b = wire.AppendBytes(b, v.Bytes())
+		b = protowire.AppendBytes(b, v.Bytes())
 	case protoreflect.MessageKind:
 		var pos int
 		var err error
@@ -89,7 +89,7 @@
 		if err != nil {
 			return b, err
 		}
-		b = wire.AppendVarint(b, wire.EncodeTag(fd.Number(), wire.EndGroupType))
+		b = protowire.AppendVarint(b, protowire.EncodeTag(fd.Number(), protowire.EndGroupType))
 	default:
 		return b, errors.New("invalid kind %v", fd.Kind())
 	}
diff --git a/proto/encode_test.go b/proto/encode_test.go
index 80e8f5d..d8aabd9 100644
--- a/proto/encode_test.go
+++ b/proto/encode_test.go
@@ -14,7 +14,7 @@
 	"github.com/google/go-cmp/cmp"
 
 	"google.golang.org/protobuf/encoding/prototext"
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/proto"
 	pref "google.golang.org/protobuf/reflect/protoreflect"
 
@@ -212,9 +212,9 @@
 	}
 	var got []pref.FieldNumber
 	for len(b) > 0 {
-		num, _, n := wire.ConsumeField(b)
+		num, _, n := protowire.ConsumeField(b)
 		if n < 0 {
-			t.Fatal(wire.ParseError(n))
+			t.Fatal(protowire.ParseError(n))
 		}
 		b = b[n:]
 		got = append(got, num)
diff --git a/proto/equal.go b/proto/equal.go
index d314232..10902bd 100644
--- a/proto/equal.go
+++ b/proto/equal.go
@@ -9,7 +9,7 @@
 	"math"
 	"reflect"
 
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	pref "google.golang.org/protobuf/reflect/protoreflect"
 )
 
@@ -141,12 +141,12 @@
 	mx := make(map[pref.FieldNumber]pref.RawFields)
 	my := make(map[pref.FieldNumber]pref.RawFields)
 	for len(x) > 0 {
-		fnum, _, n := wire.ConsumeField(x)
+		fnum, _, n := protowire.ConsumeField(x)
 		mx[fnum] = append(mx[fnum], x[:n]...)
 		x = x[n:]
 	}
 	for len(y) > 0 {
-		fnum, _, n := wire.ConsumeField(y)
+		fnum, _, n := protowire.ConsumeField(y)
 		my[fnum] = append(my[fnum], y[:n]...)
 		y = y[n:]
 	}
diff --git a/proto/messageset.go b/proto/messageset.go
index 6d0a0c2..b6b3de5 100644
--- a/proto/messageset.go
+++ b/proto/messageset.go
@@ -5,8 +5,8 @@
 package proto
 
 import (
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/encoding/wire"
 	"google.golang.org/protobuf/internal/errors"
 	"google.golang.org/protobuf/internal/flags"
 	"google.golang.org/protobuf/reflect/protoreflect"
@@ -16,8 +16,8 @@
 func sizeMessageSet(m protoreflect.Message) (size int) {
 	m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
 		size += messageset.SizeField(fd.Number())
-		size += wire.SizeTag(messageset.FieldMessage)
-		size += wire.SizeBytes(sizeMessage(v.Message()))
+		size += protowire.SizeTag(messageset.FieldMessage)
+		size += protowire.SizeBytes(sizeMessage(v.Message()))
 		return true
 	})
 	size += messageset.SizeUnknown(m.GetUnknown())
@@ -41,8 +41,8 @@
 
 func marshalMessageSetField(b []byte, fd protoreflect.FieldDescriptor, value protoreflect.Value, o MarshalOptions) ([]byte, error) {
 	b = messageset.AppendFieldStart(b, fd.Number())
-	b = wire.AppendTag(b, messageset.FieldMessage, wire.BytesType)
-	b = wire.AppendVarint(b, uint64(o.Size(value.Message().Interface())))
+	b = protowire.AppendTag(b, messageset.FieldMessage, protowire.BytesType)
+	b = protowire.AppendVarint(b, uint64(o.Size(value.Message().Interface())))
 	b, err := o.marshalMessage(b, value.Message())
 	if err != nil {
 		return b, err
@@ -55,12 +55,12 @@
 	if !flags.ProtoLegacy {
 		return errors.New("no support for message_set_wire_format")
 	}
-	return messageset.Unmarshal(b, false, func(num wire.Number, v []byte) error {
+	return messageset.Unmarshal(b, false, func(num protowire.Number, v []byte) error {
 		err := unmarshalMessageSetField(m, num, v, o)
 		if err == errUnknown {
 			unknown := m.GetUnknown()
-			unknown = wire.AppendTag(unknown, num, wire.BytesType)
-			unknown = wire.AppendBytes(unknown, v)
+			unknown = protowire.AppendTag(unknown, num, protowire.BytesType)
+			unknown = protowire.AppendBytes(unknown, v)
 			m.SetUnknown(unknown)
 			return nil
 		}
@@ -68,7 +68,7 @@
 	})
 }
 
-func unmarshalMessageSetField(m protoreflect.Message, num wire.Number, v []byte, o UnmarshalOptions) error {
+func unmarshalMessageSetField(m protoreflect.Message, num protowire.Number, v []byte, o UnmarshalOptions) error {
 	md := m.Descriptor()
 	if !md.ExtensionRanges().Has(num) {
 		return errUnknown
diff --git a/proto/messageset_test.go b/proto/messageset_test.go
index 1eedcc9..1418f4a 100644
--- a/proto/messageset_test.go
+++ b/proto/messageset_test.go
@@ -5,8 +5,8 @@
 package proto_test
 
 import (
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/encoding/pack"
-	"google.golang.org/protobuf/internal/encoding/wire"
 	"google.golang.org/protobuf/internal/flags"
 	"google.golang.org/protobuf/proto"
 
@@ -192,7 +192,7 @@
 		wire: pack.Message{
 			pack.Tag{1, pack.BytesType}, pack.LengthPrefix(pack.Message{
 				pack.Tag{1, pack.StartGroupType},
-				pack.Tag{2, pack.VarintType}, pack.Varint(wire.MaxValidNumber + 1),
+				pack.Tag{2, pack.VarintType}, pack.Varint(protowire.MaxValidNumber + 1),
 				pack.Tag{3, pack.BytesType}, pack.LengthPrefix(pack.Message{}),
 				pack.Tag{1, pack.EndGroupType},
 			}),
@@ -204,7 +204,7 @@
 			m := &messagesetpb.MessageSetContainer{MessageSet: &messagesetpb.MessageSet{}}
 			m.MessageSet.ProtoReflect().SetUnknown(
 				pack.Message{
-					pack.Tag{wire.MaxValidNumber + 2, pack.BytesType}, pack.LengthPrefix{},
+					pack.Tag{protowire.MaxValidNumber + 2, pack.BytesType}, pack.LengthPrefix{},
 				}.Marshal(),
 			)
 			return m
@@ -212,7 +212,7 @@
 		wire: pack.Message{
 			pack.Tag{1, pack.BytesType}, pack.LengthPrefix(pack.Message{
 				pack.Tag{1, pack.StartGroupType},
-				pack.Tag{2, pack.VarintType}, pack.Varint(wire.MaxValidNumber + 2),
+				pack.Tag{2, pack.VarintType}, pack.Varint(protowire.MaxValidNumber + 2),
 				pack.Tag{3, pack.BytesType}, pack.LengthPrefix(pack.Message{}),
 				pack.Tag{1, pack.EndGroupType},
 			}),
diff --git a/proto/size.go b/proto/size.go
index 32620a9..a4e72bd 100644
--- a/proto/size.go
+++ b/proto/size.go
@@ -5,8 +5,8 @@
 package proto
 
 import (
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/encoding/wire"
 	"google.golang.org/protobuf/reflect/protoreflect"
 	"google.golang.org/protobuf/runtime/protoiface"
 )
@@ -60,29 +60,29 @@
 	case fd.IsMap():
 		return sizeMap(num, fd, value.Map())
 	default:
-		return wire.SizeTag(num) + sizeSingular(num, fd.Kind(), value)
+		return protowire.SizeTag(num) + sizeSingular(num, fd.Kind(), value)
 	}
 }
 
-func sizeList(num wire.Number, fd protoreflect.FieldDescriptor, list protoreflect.List) (size int) {
+func sizeList(num protowire.Number, fd protoreflect.FieldDescriptor, list protoreflect.List) (size int) {
 	if fd.IsPacked() && list.Len() > 0 {
 		content := 0
 		for i, llen := 0, list.Len(); i < llen; i++ {
 			content += sizeSingular(num, fd.Kind(), list.Get(i))
 		}
-		return wire.SizeTag(num) + wire.SizeBytes(content)
+		return protowire.SizeTag(num) + protowire.SizeBytes(content)
 	}
 
 	for i, llen := 0, list.Len(); i < llen; i++ {
-		size += wire.SizeTag(num) + sizeSingular(num, fd.Kind(), list.Get(i))
+		size += protowire.SizeTag(num) + sizeSingular(num, fd.Kind(), list.Get(i))
 	}
 	return size
 }
 
-func sizeMap(num wire.Number, fd protoreflect.FieldDescriptor, mapv protoreflect.Map) (size int) {
+func sizeMap(num protowire.Number, fd protoreflect.FieldDescriptor, mapv protoreflect.Map) (size int) {
 	mapv.Range(func(key protoreflect.MapKey, value protoreflect.Value) bool {
-		size += wire.SizeTag(num)
-		size += wire.SizeBytes(sizeField(fd.MapKey(), key.Value()) + sizeField(fd.MapValue(), value))
+		size += protowire.SizeTag(num)
+		size += protowire.SizeBytes(sizeField(fd.MapKey(), key.Value()) + sizeField(fd.MapValue(), value))
 		return true
 	})
 	return size
diff --git a/proto/size_gen.go b/proto/size_gen.go
index 576e2c6..1118460 100644
--- a/proto/size_gen.go
+++ b/proto/size_gen.go
@@ -7,48 +7,48 @@
 package proto
 
 import (
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/reflect/protoreflect"
 )
 
-func sizeSingular(num wire.Number, kind protoreflect.Kind, v protoreflect.Value) int {
+func sizeSingular(num protowire.Number, kind protoreflect.Kind, v protoreflect.Value) int {
 	switch kind {
 	case protoreflect.BoolKind:
-		return wire.SizeVarint(wire.EncodeBool(v.Bool()))
+		return protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
 	case protoreflect.EnumKind:
-		return wire.SizeVarint(uint64(v.Enum()))
+		return protowire.SizeVarint(uint64(v.Enum()))
 	case protoreflect.Int32Kind:
-		return wire.SizeVarint(uint64(int32(v.Int())))
+		return protowire.SizeVarint(uint64(int32(v.Int())))
 	case protoreflect.Sint32Kind:
-		return wire.SizeVarint(wire.EncodeZigZag(int64(int32(v.Int()))))
+		return protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
 	case protoreflect.Uint32Kind:
-		return wire.SizeVarint(uint64(uint32(v.Uint())))
+		return protowire.SizeVarint(uint64(uint32(v.Uint())))
 	case protoreflect.Int64Kind:
-		return wire.SizeVarint(uint64(v.Int()))
+		return protowire.SizeVarint(uint64(v.Int()))
 	case protoreflect.Sint64Kind:
-		return wire.SizeVarint(wire.EncodeZigZag(v.Int()))
+		return protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
 	case protoreflect.Uint64Kind:
-		return wire.SizeVarint(v.Uint())
+		return protowire.SizeVarint(v.Uint())
 	case protoreflect.Sfixed32Kind:
-		return wire.SizeFixed32()
+		return protowire.SizeFixed32()
 	case protoreflect.Fixed32Kind:
-		return wire.SizeFixed32()
+		return protowire.SizeFixed32()
 	case protoreflect.FloatKind:
-		return wire.SizeFixed32()
+		return protowire.SizeFixed32()
 	case protoreflect.Sfixed64Kind:
-		return wire.SizeFixed64()
+		return protowire.SizeFixed64()
 	case protoreflect.Fixed64Kind:
-		return wire.SizeFixed64()
+		return protowire.SizeFixed64()
 	case protoreflect.DoubleKind:
-		return wire.SizeFixed64()
+		return protowire.SizeFixed64()
 	case protoreflect.StringKind:
-		return wire.SizeBytes(len(v.String()))
+		return protowire.SizeBytes(len(v.String()))
 	case protoreflect.BytesKind:
-		return wire.SizeBytes(len(v.Bytes()))
+		return protowire.SizeBytes(len(v.Bytes()))
 	case protoreflect.MessageKind:
-		return wire.SizeBytes(sizeMessage(v.Message()))
+		return protowire.SizeBytes(sizeMessage(v.Message()))
 	case protoreflect.GroupKind:
-		return wire.SizeGroup(num, sizeMessage(v.Message()))
+		return protowire.SizeGroup(num, sizeMessage(v.Message()))
 	default:
 		return 0
 	}
diff --git a/proto/testmessages_test.go b/proto/testmessages_test.go
index b0f568f..680faf6 100644
--- a/proto/testmessages_test.go
+++ b/proto/testmessages_test.go
@@ -5,8 +5,8 @@
 package proto_test
 
 import (
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/encoding/pack"
-	"google.golang.org/protobuf/internal/encoding/wire"
 	"google.golang.org/protobuf/internal/impl"
 	"google.golang.org/protobuf/internal/protobuild"
 	"google.golang.org/protobuf/proto"
@@ -1674,7 +1674,7 @@
 			(*testpb.TestAllExtensions)(nil),
 		},
 		wire: pack.Message{
-			pack.Tag{wire.MaxValidNumber + 1, pack.VarintType}, pack.Varint(0),
+			pack.Tag{protowire.MaxValidNumber + 1, pack.VarintType}, pack.Varint(0),
 		}.Marshal(),
 	},
 	{
diff --git a/reflect/protodesc/desc_validate.go b/reflect/protodesc/desc_validate.go
index cf172a2..2a2bf75 100644
--- a/reflect/protodesc/desc_validate.go
+++ b/reflect/protodesc/desc_validate.go
@@ -8,7 +8,7 @@
 	"strings"
 	"unicode"
 
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/errors"
 	"google.golang.org/protobuf/internal/filedesc"
 	"google.golang.org/protobuf/internal/flags"
@@ -210,7 +210,7 @@
 		// may have a field number higher than normal. This check only verifies
 		// that the number is not negative or reserved. We check again later
 		// if we know that the extendee is definitely not a MessageSet.
-		if n := x.Number(); n < 0 || (wire.FirstReservedNumber <= n && n <= wire.LastReservedNumber) {
+		if n := x.Number(); n < 0 || (protowire.FirstReservedNumber <= n && n <= protowire.LastReservedNumber) {
 			return errors.New("extension field %q has an invalid number: %d", x.FullName(), x.Number())
 		}
 		if !x.Cardinality().IsValid() || x.Cardinality() == protoreflect.Required {
diff --git a/reflect/protoreflect/proto.go b/reflect/protoreflect/proto.go
index eb5d289..1b89bed 100644
--- a/reflect/protoreflect/proto.go
+++ b/reflect/protoreflect/proto.go
@@ -130,7 +130,7 @@
 	"regexp"
 	"strings"
 
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/pragma"
 )
 
@@ -366,7 +366,7 @@
 }
 
 // FieldNumber is the field number in a message.
-type FieldNumber = wire.Number
+type FieldNumber = protowire.Number
 
 // FieldNumbers represent a list of field numbers.
 type FieldNumbers interface {
diff --git a/reflect/protoreflect/value.go b/reflect/protoreflect/value.go
index 2149446..a352ed9 100644
--- a/reflect/protoreflect/value.go
+++ b/reflect/protoreflect/value.go
@@ -4,7 +4,7 @@
 
 package protoreflect
 
-import "google.golang.org/protobuf/internal/encoding/wire"
+import "google.golang.org/protobuf/encoding/protowire"
 
 // Enum is a reflection interface for a concrete enum value,
 // which provides type information and a getter for the enum number.
@@ -165,7 +165,7 @@
 // IsValid reports whether b is syntactically correct wire format.
 func (b RawFields) IsValid() bool {
 	for len(b) > 0 {
-		_, _, n := wire.ConsumeField(b)
+		_, _, n := protowire.ConsumeField(b)
 		if n < 0 {
 			return false
 		}
diff --git a/testing/protocmp/format.go b/testing/protocmp/format.go
index f329357..2be6903 100644
--- a/testing/protocmp/format.go
+++ b/testing/protocmp/format.go
@@ -12,8 +12,8 @@
 	"strconv"
 	"strings"
 
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/internal/detrand"
-	"google.golang.org/protobuf/internal/encoding/wire"
 	"google.golang.org/protobuf/reflect/protoreflect"
 )
 
@@ -134,8 +134,8 @@
 func transformRawFields(b protoreflect.RawFields) interface{} {
 	var vs []interface{}
 	for len(b) > 0 {
-		num, typ, n := wire.ConsumeTag(b)
-		m := wire.ConsumeFieldValue(num, typ, b[n:])
+		num, typ, n := protowire.ConsumeTag(b)
+		m := protowire.ConsumeFieldValue(num, typ, b[n:])
 		vs = append(vs, transformRawField(typ, b[n:][:m]))
 		b = b[n+m:]
 	}
@@ -145,28 +145,28 @@
 	return vs
 }
 
-func transformRawField(typ wire.Type, b protoreflect.RawFields) interface{} {
+func transformRawField(typ protowire.Type, b protoreflect.RawFields) interface{} {
 	switch typ {
-	case wire.VarintType:
-		v, _ := wire.ConsumeVarint(b)
+	case protowire.VarintType:
+		v, _ := protowire.ConsumeVarint(b)
 		return v
-	case wire.Fixed32Type:
-		v, _ := wire.ConsumeFixed32(b)
+	case protowire.Fixed32Type:
+		v, _ := protowire.ConsumeFixed32(b)
 		return v
-	case wire.Fixed64Type:
-		v, _ := wire.ConsumeFixed64(b)
+	case protowire.Fixed64Type:
+		v, _ := protowire.ConsumeFixed64(b)
 		return v
-	case wire.BytesType:
-		v, _ := wire.ConsumeBytes(b)
+	case protowire.BytesType:
+		v, _ := protowire.ConsumeBytes(b)
 		return v
-	case wire.StartGroupType:
+	case protowire.StartGroupType:
 		v := Message{}
 		for {
-			num2, typ2, n := wire.ConsumeTag(b)
-			if typ2 == wire.EndGroupType {
+			num2, typ2, n := protowire.ConsumeTag(b)
+			if typ2 == protowire.EndGroupType {
 				return v
 			}
-			m := wire.ConsumeFieldValue(num2, typ2, b[n:])
+			m := protowire.ConsumeFieldValue(num2, typ2, b[n:])
 			s := strconv.Itoa(int(num2))
 			b2, _ := v[s].(protoreflect.RawFields)
 			v[s] = append(b2, b[:n+m]...)
diff --git a/testing/protocmp/xform.go b/testing/protocmp/xform.go
index 8f26aa7..53dd8e6 100644
--- a/testing/protocmp/xform.go
+++ b/testing/protocmp/xform.go
@@ -16,7 +16,7 @@
 
 	"github.com/google/go-cmp/cmp"
 
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/reflect/protoreflect"
 	"google.golang.org/protobuf/reflect/protoregistry"
@@ -238,7 +238,7 @@
 
 	// Handle unknown fields.
 	for b := m.GetUnknown(); len(b) > 0; {
-		num, _, n := wire.ConsumeField(b)
+		num, _, n := protowire.ConsumeField(b)
 		s := strconv.Itoa(int(num))
 		b2, _ := mx[s].(protoreflect.RawFields)
 		mx[s] = append(b2, b[:n]...)
diff --git a/testing/prototest/prototest.go b/testing/prototest/prototest.go
index 4fccb70..55a61ae 100644
--- a/testing/prototest/prototest.go
+++ b/testing/prototest/prototest.go
@@ -14,7 +14,7 @@
 	"testing"
 
 	"google.golang.org/protobuf/encoding/prototext"
-	"google.golang.org/protobuf/internal/encoding/wire"
+	"google.golang.org/protobuf/encoding/protowire"
 	"google.golang.org/protobuf/proto"
 	pref "google.golang.org/protobuf/reflect/protoreflect"
 	"google.golang.org/protobuf/reflect/protoregistry"
@@ -488,8 +488,8 @@
 // testUnknown tests the behavior of unknown fields.
 func testUnknown(t testing.TB, m pref.Message) {
 	var b []byte
-	b = wire.AppendTag(b, 1000, wire.VarintType)
-	b = wire.AppendVarint(b, 1001)
+	b = protowire.AppendTag(b, 1000, protowire.VarintType)
+	b = protowire.AppendVarint(b, 1001)
 	m.SetUnknown(pref.RawFields(b))
 	if got, want := []byte(m.GetUnknown()), b; !bytes.Equal(got, want) {
 		t.Errorf("after setting unknown fields:\nGetUnknown() = %v, want %v", got, want)