You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@pulsar.apache.org by zi...@apache.org on 2022/12/15 10:29:56 UTC

[pulsar-client-go] branch master updated: Use protocolbuffers instead of gogo (#895)

This is an automated email from the ASF dual-hosted git repository.

zixuan pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/pulsar-client-go.git


The following commit(s) were added to refs/heads/master by this push:
     new 504e589  Use protocolbuffers instead of gogo (#895)
504e589 is described below

commit 504e589c438d35a6165f48148778b84565da8d7e
Author: Zixuan Liu <no...@gmail.com>
AuthorDate: Thu Dec 15 18:29:50 2022 +0800

    Use protocolbuffers instead of gogo (#895)
    
    * Use protocolbuffers instead of gogo
    
    Signed-off-by: Zixuan Liu <no...@gmail.com>
    
    * Improve
    
    Signed-off-by: Zixuan Liu <no...@gmail.com>
---
 go.mod                                       |     3 +-
 go.sum                                       |     2 -
 integration-tests/pb/build.sh                |     4 +-
 integration-tests/pb/hello.pb.go             |   180 +-
 integration-tests/pb/hello.proto             |     2 +
 pulsar/consumer_partition.go                 |     2 +-
 pulsar/consumer_test.go                      |     2 +-
 pulsar/helper.go                             |     2 +-
 pulsar/impl_message.go                       |     2 +-
 pulsar/internal/batch_builder.go             |     2 +-
 pulsar/internal/commands.go                  |    10 +-
 pulsar/internal/connection.go                |     6 +-
 pulsar/internal/connection_reader.go         |     2 +-
 pulsar/internal/lookup_service.go            |     2 +-
 pulsar/internal/lookup_service_test.go       |     2 +-
 pulsar/internal/pulsar_proto/PulsarApi.pb.go | 34242 ++++++-------------------
 pulsar/internal/pulsar_proto/PulsarApi.proto |     1 +
 pulsar/internal/pulsar_proto/README.md       |    12 +-
 pulsar/internal/rpc_client.go                |     2 +-
 pulsar/internal/utils.go                     |    11 +
 pulsar/producer_partition.go                 |    14 +-
 pulsar/schema.go                             |     2 +-
 22 files changed, 7348 insertions(+), 27159 deletions(-)

diff --git a/go.mod b/go.mod
index 3c2945a..712a80a 100644
--- a/go.mod
+++ b/go.mod
@@ -8,9 +8,7 @@ require (
 	github.com/DataDog/zstd v1.5.0
 	github.com/bmizerany/perks v0.0.0-20141205001514-d9a9656a3a4b
 	github.com/davecgh/go-spew v1.1.1
-	github.com/gogo/protobuf v1.3.2
 	github.com/golang-jwt/jwt v3.2.1+incompatible
-	github.com/golang/protobuf v1.5.2
 	github.com/google/uuid v1.1.2
 	github.com/klauspost/compress v1.14.4
 	github.com/linkedin/goavro/v2 v2.9.8
@@ -27,4 +25,5 @@ require (
 	go.uber.org/atomic v1.7.0
 	golang.org/x/mod v0.5.1
 	golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602
+	google.golang.org/protobuf v1.26.0
 )
diff --git a/go.sum b/go.sum
index faa0746..9ebceff 100644
--- a/go.sum
+++ b/go.sum
@@ -118,7 +118,6 @@ github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 h1:ZpnhV/YsD2/4cESfV5+
 github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2/go.mod h1:bBOAhwG1umN6/6ZUMtDFBMQR8jRg9O75tm9K00oMsK4=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
 github.com/golang-jwt/jwt v3.2.1+incompatible h1:73Z+4BJcrTC+KczS6WvTPvRGOp1WmfEP4Q1lOd9Z/+c=
 github.com/golang-jwt/jwt v3.2.1+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
@@ -419,7 +418,6 @@ golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.2 h1:Gz96sIWK3OalVv/I/qNygP42zyoKp3xptRVCWRFEBvo=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.5.1 h1:OJxoQ/rynoF0dcCdI7cLPktw/hR2cueqYfjm43oqK38=
 golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
diff --git a/integration-tests/pb/build.sh b/integration-tests/pb/build.sh
index 3987795..32c0b08 100755
--- a/integration-tests/pb/build.sh
+++ b/integration-tests/pb/build.sh
@@ -18,6 +18,4 @@
 # under the License.
 #
 
-pkg=pb
-protoc --go_out=import_path=${pkg}:. hello.proto
-
+protoc --go_out=. --go_opt=paths=source_relative hello.proto
diff --git a/integration-tests/pb/hello.pb.go b/integration-tests/pb/hello.pb.go
index 7cdf086..7884dfa 100644
--- a/integration-tests/pb/hello.pb.go
+++ b/integration-tests/pb/hello.pb.go
@@ -1,4 +1,4 @@
-//
+//*
 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
@@ -15,86 +15,154 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-//
 
 // Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.28.1
+// 	protoc        v3.21.9
 // source: hello.proto
 
 package pb
 
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
 
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
 
 type Test struct {
-	Num                  int32    `protobuf:"varint,1,opt,name=num,proto3" json:"num,omitempty"`
-	Msf                  string   `protobuf:"bytes,2,opt,name=msf,proto3" json:"msf,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 
-func (m *Test) Reset()         { *m = Test{} }
-func (m *Test) String() string { return proto.CompactTextString(m) }
-func (*Test) ProtoMessage()    {}
-func (*Test) Descriptor() ([]byte, []int) {
-	return fileDescriptor_hello_38c7a10202078446, []int{0}
-}
-func (m *Test) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Test.Unmarshal(m, b)
+	Num int32  `protobuf:"varint,1,opt,name=num,proto3" json:"num,omitempty"`
+	Msf string `protobuf:"bytes,2,opt,name=msf,proto3" json:"msf,omitempty"`
 }
-func (m *Test) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Test.Marshal(b, m, deterministic)
-}
-func (dst *Test) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Test.Merge(dst, src)
+
+func (x *Test) Reset() {
+	*x = Test{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_hello_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *Test) XXX_Size() int {
-	return xxx_messageInfo_Test.Size(m)
+
+func (x *Test) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *Test) XXX_DiscardUnknown() {
-	xxx_messageInfo_Test.DiscardUnknown(m)
+
+func (*Test) ProtoMessage() {}
+
+func (x *Test) ProtoReflect() protoreflect.Message {
+	mi := &file_hello_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_Test proto.InternalMessageInfo
+// Deprecated: Use Test.ProtoReflect.Descriptor instead.
+func (*Test) Descriptor() ([]byte, []int) {
+	return file_hello_proto_rawDescGZIP(), []int{0}
+}
 
-func (m *Test) GetNum() int32 {
-	if m != nil {
-		return m.Num
+func (x *Test) GetNum() int32 {
+	if x != nil {
+		return x.Num
 	}
 	return 0
 }
 
-func (m *Test) GetMsf() string {
-	if m != nil {
-		return m.Msf
+func (x *Test) GetMsf() string {
+	if x != nil {
+		return x.Msf
 	}
 	return ""
 }
 
-func init() {
-	proto.RegisterType((*Test)(nil), "prototest.Test")
+var File_hello_proto protoreflect.FileDescriptor
+
+var file_hello_proto_rawDesc = []byte{
+	0x0a, 0x0b, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x09, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2a, 0x0a, 0x04, 0x54, 0x65, 0x73, 0x74,
+	0x12, 0x10, 0x0a, 0x03, 0x6e, 0x75, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6e,
+	0x75, 0x6d, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x73, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x03, 0x6d, 0x73, 0x66, 0x42, 0x06, 0x5a, 0x04, 0x2e, 0x2f, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x33,
 }
 
-func init() { proto.RegisterFile("hello.proto", fileDescriptor_hello_38c7a10202078446) }
+var (
+	file_hello_proto_rawDescOnce sync.Once
+	file_hello_proto_rawDescData = file_hello_proto_rawDesc
+)
+
+func file_hello_proto_rawDescGZIP() []byte {
+	file_hello_proto_rawDescOnce.Do(func() {
+		file_hello_proto_rawDescData = protoimpl.X.CompressGZIP(file_hello_proto_rawDescData)
+	})
+	return file_hello_proto_rawDescData
+}
 
-var fileDescriptor_hello_38c7a10202078446 = []byte{
-	// 87 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xce, 0x48, 0xcd, 0xc9,
-	0xc9, 0xd7, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x04, 0x53, 0x25, 0xa9, 0xc5, 0x25, 0x4a,
-	0x5a, 0x5c, 0x2c, 0x21, 0xa9, 0xc5, 0x25, 0x42, 0x02, 0x5c, 0xcc, 0x79, 0xa5, 0xb9, 0x12, 0x8c,
-	0x0a, 0x8c, 0x1a, 0xac, 0x41, 0x20, 0x26, 0x48, 0x24, 0xb7, 0x38, 0x4d, 0x82, 0x49, 0x81, 0x51,
-	0x83, 0x33, 0x08, 0xc4, 0x4c, 0x62, 0x03, 0x6b, 0x33, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0xc5,
-	0x3d, 0x96, 0x7b, 0x4c, 0x00, 0x00, 0x00,
+var file_hello_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_hello_proto_goTypes = []interface{}{
+	(*Test)(nil), // 0: prototest.Test
+}
+var file_hello_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_hello_proto_init() }
+func file_hello_proto_init() {
+	if File_hello_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_hello_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Test); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_hello_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_hello_proto_goTypes,
+		DependencyIndexes: file_hello_proto_depIdxs,
+		MessageInfos:      file_hello_proto_msgTypes,
+	}.Build()
+	File_hello_proto = out.File
+	file_hello_proto_rawDesc = nil
+	file_hello_proto_goTypes = nil
+	file_hello_proto_depIdxs = nil
 }
diff --git a/integration-tests/pb/hello.proto b/integration-tests/pb/hello.proto
index 547e273..3a67c3b 100644
--- a/integration-tests/pb/hello.proto
+++ b/integration-tests/pb/hello.proto
@@ -19,6 +19,8 @@
 syntax = "proto3";
 package prototest;
 
+option go_package = "./pb";
+
 message Test {
     int32 num = 1;
     string msf = 2;
diff --git a/pulsar/consumer_partition.go b/pulsar/consumer_partition.go
index 46f13d8..4215b69 100644
--- a/pulsar/consumer_partition.go
+++ b/pulsar/consumer_partition.go
@@ -28,7 +28,7 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/gogo/protobuf/proto"
+	"google.golang.org/protobuf/proto"
 
 	"github.com/apache/pulsar-client-go/pulsar/crypto"
 	"github.com/apache/pulsar-client-go/pulsar/internal"
diff --git a/pulsar/consumer_test.go b/pulsar/consumer_test.go
index 58a524a..7a7f118 100644
--- a/pulsar/consumer_test.go
+++ b/pulsar/consumer_test.go
@@ -34,10 +34,10 @@ import (
 	"github.com/apache/pulsar-client-go/pulsar/internal"
 	pb "github.com/apache/pulsar-client-go/pulsar/internal/pulsar_proto"
 	plog "github.com/apache/pulsar-client-go/pulsar/log"
-	"github.com/gogo/protobuf/proto"
 	"github.com/google/uuid"
 	"github.com/pierrec/lz4"
 	"github.com/stretchr/testify/assert"
+	"google.golang.org/protobuf/proto"
 )
 
 var (
diff --git a/pulsar/helper.go b/pulsar/helper.go
index fb42cb5..5c68731 100644
--- a/pulsar/helper.go
+++ b/pulsar/helper.go
@@ -22,7 +22,7 @@ import (
 
 	pkgerrors "github.com/pkg/errors"
 
-	"github.com/gogo/protobuf/proto"
+	"google.golang.org/protobuf/proto"
 
 	"github.com/apache/pulsar-client-go/pulsar/internal"
 	pb "github.com/apache/pulsar-client-go/pulsar/internal/pulsar_proto"
diff --git a/pulsar/impl_message.go b/pulsar/impl_message.go
index 11ecb40..3a7feee 100644
--- a/pulsar/impl_message.go
+++ b/pulsar/impl_message.go
@@ -26,7 +26,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/gogo/protobuf/proto"
+	"google.golang.org/protobuf/proto"
 
 	pb "github.com/apache/pulsar-client-go/pulsar/internal/pulsar_proto"
 )
diff --git a/pulsar/internal/batch_builder.go b/pulsar/internal/batch_builder.go
index ca19a3e..649aba4 100644
--- a/pulsar/internal/batch_builder.go
+++ b/pulsar/internal/batch_builder.go
@@ -21,7 +21,7 @@ import (
 	"bytes"
 	"time"
 
-	"github.com/gogo/protobuf/proto"
+	"google.golang.org/protobuf/proto"
 
 	"github.com/apache/pulsar-client-go/pulsar/internal/compression"
 	"github.com/apache/pulsar-client-go/pulsar/internal/crypto"
diff --git a/pulsar/internal/commands.go b/pulsar/internal/commands.go
index c28593c..70acf39 100644
--- a/pulsar/internal/commands.go
+++ b/pulsar/internal/commands.go
@@ -22,7 +22,7 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/gogo/protobuf/proto"
+	"google.golang.org/protobuf/proto"
 
 	"github.com/apache/pulsar-client-go/pulsar/internal/compression"
 	"github.com/apache/pulsar-client-go/pulsar/internal/crypto"
@@ -226,11 +226,11 @@ func baseCommand(cmdType pb.BaseCommand_Type, msg proto.Message) *pb.BaseCommand
 }
 
 func addSingleMessageToBatch(wb Buffer, smm *pb.SingleMessageMetadata, payload []byte) {
-	metadataSize := uint32(smm.Size())
+	metadataSize := uint32(proto.Size(smm))
 	wb.WriteUint32(metadataSize)
 
 	wb.ResizeIfNeeded(metadataSize)
-	_, err := smm.MarshalToSizedBuffer(wb.WritableSlice()[:metadataSize])
+	err := MarshalToSizedBuffer(smm, wb.WritableSlice()[:metadataSize])
 	if err != nil {
 		panic(fmt.Sprintf("Protobuf serialization error: %v", err))
 	}
@@ -282,7 +282,7 @@ func serializeMessage(wb Buffer,
 	// Write cmd
 	wb.WriteUint32(cmdSize)
 	wb.ResizeIfNeeded(cmdSize)
-	_, err = cmdSend.MarshalToSizedBuffer(wb.WritableSlice()[:cmdSize])
+	err = MarshalToSizedBuffer(cmdSend, wb.WritableSlice()[:cmdSize])
 	if err != nil {
 		panic(fmt.Sprintf("Protobuf error when serializing cmdSend: %v", err))
 	}
@@ -297,7 +297,7 @@ func serializeMessage(wb Buffer,
 	metadataStartIdx := wb.WriterIndex()
 	wb.WriteUint32(msgMetadataSize)
 	wb.ResizeIfNeeded(msgMetadataSize)
-	_, err = msgMetadata.MarshalToSizedBuffer(wb.WritableSlice()[:msgMetadataSize])
+	err = MarshalToSizedBuffer(msgMetadata, wb.WritableSlice()[:msgMetadataSize])
 	if err != nil {
 		panic(fmt.Sprintf("Protobuf error when serializing msgMetadata: %v", err))
 	}
diff --git a/pulsar/internal/connection.go b/pulsar/internal/connection.go
index fc97455..00a9521 100644
--- a/pulsar/internal/connection.go
+++ b/pulsar/internal/connection.go
@@ -29,7 +29,7 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/gogo/protobuf/proto"
+	"google.golang.org/protobuf/proto"
 
 	"github.com/apache/pulsar-client-go/pulsar/internal/auth"
 	pb "github.com/apache/pulsar-client-go/pulsar/internal/pulsar_proto"
@@ -488,7 +488,7 @@ func (c *connection) internalWriteData(data Buffer) {
 func (c *connection) writeCommand(cmd *pb.BaseCommand) {
 	// Wire format
 	// [FRAME_SIZE] [CMD_SIZE][CMD]
-	cmdSize := uint32(cmd.Size())
+	cmdSize := uint32(proto.Size(cmd))
 	frameSize := cmdSize + 4
 
 	c.writeBufferLock.Lock()
@@ -499,7 +499,7 @@ func (c *connection) writeCommand(cmd *pb.BaseCommand) {
 
 	c.writeBuffer.WriteUint32(cmdSize)
 	c.writeBuffer.ResizeIfNeeded(cmdSize)
-	_, err := cmd.MarshalToSizedBuffer(c.writeBuffer.WritableSlice()[:cmdSize])
+	err := MarshalToSizedBuffer(cmd, c.writeBuffer.WritableSlice()[:cmdSize])
 	if err != nil {
 		c.log.WithError(err).Error("Protobuf serialization error")
 		panic("Protobuf serialization error")
diff --git a/pulsar/internal/connection_reader.go b/pulsar/internal/connection_reader.go
index 97078c5..c451562 100644
--- a/pulsar/internal/connection_reader.go
+++ b/pulsar/internal/connection_reader.go
@@ -23,7 +23,7 @@ import (
 	"io"
 
 	pb "github.com/apache/pulsar-client-go/pulsar/internal/pulsar_proto"
-	"github.com/gogo/protobuf/proto"
+	"google.golang.org/protobuf/proto"
 )
 
 type connectionReader struct {
diff --git a/pulsar/internal/lookup_service.go b/pulsar/internal/lookup_service.go
index 24d73db..e30bec1 100644
--- a/pulsar/internal/lookup_service.go
+++ b/pulsar/internal/lookup_service.go
@@ -22,7 +22,7 @@ import (
 	"fmt"
 	"net/url"
 
-	"github.com/gogo/protobuf/proto"
+	"google.golang.org/protobuf/proto"
 
 	pb "github.com/apache/pulsar-client-go/pulsar/internal/pulsar_proto"
 	"github.com/apache/pulsar-client-go/pulsar/log"
diff --git a/pulsar/internal/lookup_service_test.go b/pulsar/internal/lookup_service_test.go
index 2d07496..9c55e9f 100644
--- a/pulsar/internal/lookup_service_test.go
+++ b/pulsar/internal/lookup_service_test.go
@@ -25,10 +25,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/gogo/protobuf/proto"
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/stretchr/testify/assert"
+	"google.golang.org/protobuf/proto"
 
 	pb "github.com/apache/pulsar-client-go/pulsar/internal/pulsar_proto"
 	"github.com/apache/pulsar-client-go/pulsar/log"
diff --git a/pulsar/internal/pulsar_proto/PulsarApi.pb.go b/pulsar/internal/pulsar_proto/PulsarApi.pb.go
index a0e45c7..c8e6ad9 100644
--- a/pulsar/internal/pulsar_proto/PulsarApi.pb.go
+++ b/pulsar/internal/pulsar_proto/PulsarApi.pb.go
@@ -1,28 +1,42 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
+//*
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.28.1
+// 	protoc        v3.21.9
 // source: PulsarApi.proto
 
-package pulsar_proto
+package proto
 
 import (
-	encoding_binary "encoding/binary"
-	fmt "fmt"
-	github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
-	proto "github.com/gogo/protobuf/proto"
-	io "io"
-	math "math"
-	math_bits "math/bits"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
 )
 
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
 
 type CompressionType int32
 
@@ -34,21 +48,23 @@ const (
 	CompressionType_SNAPPY CompressionType = 4
 )
 
-var CompressionType_name = map[int32]string{
-	0: "NONE",
-	1: "LZ4",
-	2: "ZLIB",
-	3: "ZSTD",
-	4: "SNAPPY",
-}
-
-var CompressionType_value = map[string]int32{
-	"NONE":   0,
-	"LZ4":    1,
-	"ZLIB":   2,
-	"ZSTD":   3,
-	"SNAPPY": 4,
-}
+// Enum value maps for CompressionType.
+var (
+	CompressionType_name = map[int32]string{
+		0: "NONE",
+		1: "LZ4",
+		2: "ZLIB",
+		3: "ZSTD",
+		4: "SNAPPY",
+	}
+	CompressionType_value = map[string]int32{
+		"NONE":   0,
+		"LZ4":    1,
+		"ZLIB":   2,
+		"ZSTD":   3,
+		"SNAPPY": 4,
+	}
+)
 
 func (x CompressionType) Enum() *CompressionType {
 	p := new(CompressionType)
@@ -57,44 +73,60 @@ func (x CompressionType) Enum() *CompressionType {
 }
 
 func (x CompressionType) String() string {
-	return proto.EnumName(CompressionType_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (CompressionType) Descriptor() protoreflect.EnumDescriptor {
+	return file_PulsarApi_proto_enumTypes[0].Descriptor()
+}
+
+func (CompressionType) Type() protoreflect.EnumType {
+	return &file_PulsarApi_proto_enumTypes[0]
+}
+
+func (x CompressionType) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
 }
 
-func (x *CompressionType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(CompressionType_value, data, "CompressionType")
+// Deprecated: Do not use.
+func (x *CompressionType) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
 	if err != nil {
 		return err
 	}
-	*x = CompressionType(value)
+	*x = CompressionType(num)
 	return nil
 }
 
+// Deprecated: Use CompressionType.Descriptor instead.
 func (CompressionType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{0}
+	return file_PulsarApi_proto_rawDescGZIP(), []int{0}
 }
 
 type ProducerAccessMode int32
 
 const (
-	ProducerAccessMode_Shared               ProducerAccessMode = 0
-	ProducerAccessMode_Exclusive            ProducerAccessMode = 1
-	ProducerAccessMode_WaitForExclusive     ProducerAccessMode = 2
-	ProducerAccessMode_ExclusiveWithFencing ProducerAccessMode = 3
+	ProducerAccessMode_Shared               ProducerAccessMode = 0 // By default multiple producers can publish on a topic
+	ProducerAccessMode_Exclusive            ProducerAccessMode = 1 // Require exclusive access for producer. Fail immediately if there's already a producer connected.
+	ProducerAccessMode_WaitForExclusive     ProducerAccessMode = 2 // Producer creation is pending until it can acquire exclusive access
+	ProducerAccessMode_ExclusiveWithFencing ProducerAccessMode = 3 // Require exclusive access for producer. Fence out old producer.
 )
 
-var ProducerAccessMode_name = map[int32]string{
-	0: "Shared",
-	1: "Exclusive",
-	2: "WaitForExclusive",
-	3: "ExclusiveWithFencing",
-}
-
-var ProducerAccessMode_value = map[string]int32{
-	"Shared":               0,
-	"Exclusive":            1,
-	"WaitForExclusive":     2,
-	"ExclusiveWithFencing": 3,
-}
+// Enum value maps for ProducerAccessMode.
+var (
+	ProducerAccessMode_name = map[int32]string{
+		0: "Shared",
+		1: "Exclusive",
+		2: "WaitForExclusive",
+		3: "ExclusiveWithFencing",
+	}
+	ProducerAccessMode_value = map[string]int32{
+		"Shared":               0,
+		"Exclusive":            1,
+		"WaitForExclusive":     2,
+		"ExclusiveWithFencing": 3,
+	}
+)
 
 func (x ProducerAccessMode) Enum() *ProducerAccessMode {
 	p := new(ProducerAccessMode)
@@ -103,111 +135,127 @@ func (x ProducerAccessMode) Enum() *ProducerAccessMode {
 }
 
 func (x ProducerAccessMode) String() string {
-	return proto.EnumName(ProducerAccessMode_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (ProducerAccessMode) Descriptor() protoreflect.EnumDescriptor {
+	return file_PulsarApi_proto_enumTypes[1].Descriptor()
+}
+
+func (ProducerAccessMode) Type() protoreflect.EnumType {
+	return &file_PulsarApi_proto_enumTypes[1]
+}
+
+func (x ProducerAccessMode) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
 }
 
-func (x *ProducerAccessMode) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(ProducerAccessMode_value, data, "ProducerAccessMode")
+// Deprecated: Do not use.
+func (x *ProducerAccessMode) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
 	if err != nil {
 		return err
 	}
-	*x = ProducerAccessMode(value)
+	*x = ProducerAccessMode(num)
 	return nil
 }
 
+// Deprecated: Use ProducerAccessMode.Descriptor instead.
 func (ProducerAccessMode) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{1}
+	return file_PulsarApi_proto_rawDescGZIP(), []int{1}
 }
 
 type ServerError int32
 
 const (
 	ServerError_UnknownError        ServerError = 0
-	ServerError_MetadataError       ServerError = 1
-	ServerError_PersistenceError    ServerError = 2
-	ServerError_AuthenticationError ServerError = 3
-	ServerError_AuthorizationError  ServerError = 4
-	ServerError_ConsumerBusy        ServerError = 5
+	ServerError_MetadataError       ServerError = 1 // Error with ZK/metadata
+	ServerError_PersistenceError    ServerError = 2 // Error writing reading from BK
+	ServerError_AuthenticationError ServerError = 3 // Non valid authentication
+	ServerError_AuthorizationError  ServerError = 4 // Not authorized to use resource
+	ServerError_ConsumerBusy        ServerError = 5 // Unable to subscribe/unsubscribe because
 	// other consumers are connected
-	ServerError_ServiceNotReady                       ServerError = 6
-	ServerError_ProducerBlockedQuotaExceededError     ServerError = 7
-	ServerError_ProducerBlockedQuotaExceededException ServerError = 8
-	ServerError_ChecksumError                         ServerError = 9
-	ServerError_UnsupportedVersionError               ServerError = 10
-	ServerError_TopicNotFound                         ServerError = 11
-	ServerError_SubscriptionNotFound                  ServerError = 12
-	ServerError_ConsumerNotFound                      ServerError = 13
-	ServerError_TooManyRequests                       ServerError = 14
-	ServerError_TopicTerminatedError                  ServerError = 15
-	ServerError_ProducerBusy                          ServerError = 16
-	ServerError_InvalidTopicName                      ServerError = 17
-	ServerError_IncompatibleSchema                    ServerError = 18
-	ServerError_ConsumerAssignError                   ServerError = 19
-	ServerError_TransactionCoordinatorNotFound        ServerError = 20
-	ServerError_InvalidTxnStatus                      ServerError = 21
-	ServerError_NotAllowedError                       ServerError = 22
-	ServerError_TransactionConflict                   ServerError = 23
-	ServerError_TransactionNotFound                   ServerError = 24
-	ServerError_ProducerFenced                        ServerError = 25
+	ServerError_ServiceNotReady                       ServerError = 6  // Any error that requires client retry operation with a fresh lookup
+	ServerError_ProducerBlockedQuotaExceededError     ServerError = 7  // Unable to create producer because backlog quota exceeded
+	ServerError_ProducerBlockedQuotaExceededException ServerError = 8  // Exception while creating producer because quota exceeded
+	ServerError_ChecksumError                         ServerError = 9  // Error while verifying message checksum
+	ServerError_UnsupportedVersionError               ServerError = 10 // Error when an older client/version doesn't support a required feature
+	ServerError_TopicNotFound                         ServerError = 11 // Topic not found
+	ServerError_SubscriptionNotFound                  ServerError = 12 // Subscription not found
+	ServerError_ConsumerNotFound                      ServerError = 13 // Consumer not found
+	ServerError_TooManyRequests                       ServerError = 14 // Error with too many simultaneously request
+	ServerError_TopicTerminatedError                  ServerError = 15 // The topic has been terminated
+	ServerError_ProducerBusy                          ServerError = 16 // Producer with same name is already connected
+	ServerError_InvalidTopicName                      ServerError = 17 // The topic name is not valid
+	ServerError_IncompatibleSchema                    ServerError = 18 // Specified schema was incompatible with topic schema
+	ServerError_ConsumerAssignError                   ServerError = 19 // Dispatcher assign consumer error
+	ServerError_TransactionCoordinatorNotFound        ServerError = 20 // Transaction coordinator not found error
+	ServerError_InvalidTxnStatus                      ServerError = 21 // Invalid txn status error
+	ServerError_NotAllowedError                       ServerError = 22 // Not allowed error
+	ServerError_TransactionConflict                   ServerError = 23 // Ack with transaction conflict
+	ServerError_TransactionNotFound                   ServerError = 24 // Transaction not found
+	ServerError_ProducerFenced                        ServerError = 25 // When a producer asks and fail to get exclusive producer access,
 )
 
-var ServerError_name = map[int32]string{
-	0:  "UnknownError",
-	1:  "MetadataError",
-	2:  "PersistenceError",
-	3:  "AuthenticationError",
-	4:  "AuthorizationError",
-	5:  "ConsumerBusy",
-	6:  "ServiceNotReady",
-	7:  "ProducerBlockedQuotaExceededError",
-	8:  "ProducerBlockedQuotaExceededException",
-	9:  "ChecksumError",
-	10: "UnsupportedVersionError",
-	11: "TopicNotFound",
-	12: "SubscriptionNotFound",
-	13: "ConsumerNotFound",
-	14: "TooManyRequests",
-	15: "TopicTerminatedError",
-	16: "ProducerBusy",
-	17: "InvalidTopicName",
-	18: "IncompatibleSchema",
-	19: "ConsumerAssignError",
-	20: "TransactionCoordinatorNotFound",
-	21: "InvalidTxnStatus",
-	22: "NotAllowedError",
-	23: "TransactionConflict",
-	24: "TransactionNotFound",
-	25: "ProducerFenced",
-}
-
-var ServerError_value = map[string]int32{
-	"UnknownError":                          0,
-	"MetadataError":                         1,
-	"PersistenceError":                      2,
-	"AuthenticationError":                   3,
-	"AuthorizationError":                    4,
-	"ConsumerBusy":                          5,
-	"ServiceNotReady":                       6,
-	"ProducerBlockedQuotaExceededError":     7,
-	"ProducerBlockedQuotaExceededException": 8,
-	"ChecksumError":                         9,
-	"UnsupportedVersionError":               10,
-	"TopicNotFound":                         11,
-	"SubscriptionNotFound":                  12,
-	"ConsumerNotFound":                      13,
-	"TooManyRequests":                       14,
-	"TopicTerminatedError":                  15,
-	"ProducerBusy":                          16,
-	"InvalidTopicName":                      17,
-	"IncompatibleSchema":                    18,
-	"ConsumerAssignError":                   19,
-	"TransactionCoordinatorNotFound":        20,
-	"InvalidTxnStatus":                      21,
-	"NotAllowedError":                       22,
-	"TransactionConflict":                   23,
-	"TransactionNotFound":                   24,
-	"ProducerFenced":                        25,
-}
+// Enum value maps for ServerError.
+var (
+	ServerError_name = map[int32]string{
+		0:  "UnknownError",
+		1:  "MetadataError",
+		2:  "PersistenceError",
+		3:  "AuthenticationError",
+		4:  "AuthorizationError",
+		5:  "ConsumerBusy",
+		6:  "ServiceNotReady",
+		7:  "ProducerBlockedQuotaExceededError",
+		8:  "ProducerBlockedQuotaExceededException",
+		9:  "ChecksumError",
+		10: "UnsupportedVersionError",
+		11: "TopicNotFound",
+		12: "SubscriptionNotFound",
+		13: "ConsumerNotFound",
+		14: "TooManyRequests",
+		15: "TopicTerminatedError",
+		16: "ProducerBusy",
+		17: "InvalidTopicName",
+		18: "IncompatibleSchema",
+		19: "ConsumerAssignError",
+		20: "TransactionCoordinatorNotFound",
+		21: "InvalidTxnStatus",
+		22: "NotAllowedError",
+		23: "TransactionConflict",
+		24: "TransactionNotFound",
+		25: "ProducerFenced",
+	}
+	ServerError_value = map[string]int32{
+		"UnknownError":                          0,
+		"MetadataError":                         1,
+		"PersistenceError":                      2,
+		"AuthenticationError":                   3,
+		"AuthorizationError":                    4,
+		"ConsumerBusy":                          5,
+		"ServiceNotReady":                       6,
+		"ProducerBlockedQuotaExceededError":     7,
+		"ProducerBlockedQuotaExceededException": 8,
+		"ChecksumError":                         9,
+		"UnsupportedVersionError":               10,
+		"TopicNotFound":                         11,
+		"SubscriptionNotFound":                  12,
+		"ConsumerNotFound":                      13,
+		"TooManyRequests":                       14,
+		"TopicTerminatedError":                  15,
+		"ProducerBusy":                          16,
+		"InvalidTopicName":                      17,
+		"IncompatibleSchema":                    18,
+		"ConsumerAssignError":                   19,
+		"TransactionCoordinatorNotFound":        20,
+		"InvalidTxnStatus":                      21,
+		"NotAllowedError":                       22,
+		"TransactionConflict":                   23,
+		"TransactionNotFound":                   24,
+		"ProducerFenced":                        25,
+	}
+)
 
 func (x ServerError) Enum() *ServerError {
 	p := new(ServerError)
@@ -216,20 +264,34 @@ func (x ServerError) Enum() *ServerError {
 }
 
 func (x ServerError) String() string {
-	return proto.EnumName(ServerError_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (ServerError) Descriptor() protoreflect.EnumDescriptor {
+	return file_PulsarApi_proto_enumTypes[2].Descriptor()
+}
+
+func (ServerError) Type() protoreflect.EnumType {
+	return &file_PulsarApi_proto_enumTypes[2]
+}
+
+func (x ServerError) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
 }
 
-func (x *ServerError) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(ServerError_value, data, "ServerError")
+// Deprecated: Do not use.
+func (x *ServerError) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
 	if err != nil {
 		return err
 	}
-	*x = ServerError(value)
+	*x = ServerError(num)
 	return nil
 }
 
+// Deprecated: Use ServerError.Descriptor instead.
 func (ServerError) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{2}
+	return file_PulsarApi_proto_rawDescGZIP(), []int{2}
 }
 
 type AuthMethod int32
@@ -240,17 +302,19 @@ const (
 	AuthMethod_AuthMethodAthens AuthMethod = 2
 )
 
-var AuthMethod_name = map[int32]string{
-	0: "AuthMethodNone",
-	1: "AuthMethodYcaV1",
-	2: "AuthMethodAthens",
-}
-
-var AuthMethod_value = map[string]int32{
-	"AuthMethodNone":   0,
-	"AuthMethodYcaV1":  1,
-	"AuthMethodAthens": 2,
-}
+// Enum value maps for AuthMethod.
+var (
+	AuthMethod_name = map[int32]string{
+		0: "AuthMethodNone",
+		1: "AuthMethodYcaV1",
+		2: "AuthMethodAthens",
+	}
+	AuthMethod_value = map[string]int32{
+		"AuthMethodNone":   0,
+		"AuthMethodYcaV1":  1,
+		"AuthMethodAthens": 2,
+	}
+)
 
 func (x AuthMethod) Enum() *AuthMethod {
 	p := new(AuthMethod)
@@ -259,20 +323,34 @@ func (x AuthMethod) Enum() *AuthMethod {
 }
 
 func (x AuthMethod) String() string {
-	return proto.EnumName(AuthMethod_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (AuthMethod) Descriptor() protoreflect.EnumDescriptor {
+	return file_PulsarApi_proto_enumTypes[3].Descriptor()
+}
+
+func (AuthMethod) Type() protoreflect.EnumType {
+	return &file_PulsarApi_proto_enumTypes[3]
 }
 
-func (x *AuthMethod) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(AuthMethod_value, data, "AuthMethod")
+func (x AuthMethod) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *AuthMethod) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
 	if err != nil {
 		return err
 	}
-	*x = AuthMethod(value)
+	*x = AuthMethod(num)
 	return nil
 }
 
+// Deprecated: Use AuthMethod.Descriptor instead.
 func (AuthMethod) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{3}
+	return file_PulsarApi_proto_rawDescGZIP(), []int{3}
 }
 
 // Each protocol version identify new features that are
@@ -280,76 +358,78 @@ func (AuthMethod) EnumDescriptor() ([]byte, []int) {
 type ProtocolVersion int32
 
 const (
-	ProtocolVersion_v0  ProtocolVersion = 0
-	ProtocolVersion_v1  ProtocolVersion = 1
-	ProtocolVersion_v2  ProtocolVersion = 2
-	ProtocolVersion_v3  ProtocolVersion = 3
-	ProtocolVersion_v4  ProtocolVersion = 4
-	ProtocolVersion_v5  ProtocolVersion = 5
-	ProtocolVersion_v6  ProtocolVersion = 6
-	ProtocolVersion_v7  ProtocolVersion = 7
-	ProtocolVersion_v8  ProtocolVersion = 8
-	ProtocolVersion_v9  ProtocolVersion = 9
-	ProtocolVersion_v10 ProtocolVersion = 10
-	ProtocolVersion_v11 ProtocolVersion = 11
-	ProtocolVersion_v12 ProtocolVersion = 12
+	ProtocolVersion_v0  ProtocolVersion = 0  // Initial versioning
+	ProtocolVersion_v1  ProtocolVersion = 1  // Added application keep-alive
+	ProtocolVersion_v2  ProtocolVersion = 2  // Added RedeliverUnacknowledgedMessages Command
+	ProtocolVersion_v3  ProtocolVersion = 3  // Added compression with LZ4 and ZLib
+	ProtocolVersion_v4  ProtocolVersion = 4  // Added batch message support
+	ProtocolVersion_v5  ProtocolVersion = 5  // Added disconnect client w/o closing connection
+	ProtocolVersion_v6  ProtocolVersion = 6  // Added checksum computation for metadata + payload
+	ProtocolVersion_v7  ProtocolVersion = 7  // Added CommandLookupTopic - Binary Lookup
+	ProtocolVersion_v8  ProtocolVersion = 8  // Added CommandConsumerStats - Client fetches broker side consumer stats
+	ProtocolVersion_v9  ProtocolVersion = 9  // Added end of topic notification
+	ProtocolVersion_v10 ProtocolVersion = 10 // Added proxy to broker
+	ProtocolVersion_v11 ProtocolVersion = 11 // C++ consumers before this version are not correctly handling the checksum field
+	ProtocolVersion_v12 ProtocolVersion = 12 // Added get topic's last messageId from broker
 	// Added CommandActiveConsumerChange
 	// Added CommandGetTopicsOfNamespace
-	ProtocolVersion_v13 ProtocolVersion = 13
-	ProtocolVersion_v14 ProtocolVersion = 14
+	ProtocolVersion_v13 ProtocolVersion = 13 // Schema-registry : added avro schema format for json
+	ProtocolVersion_v14 ProtocolVersion = 14 // Add CommandAuthChallenge and CommandAuthResponse for mutual auth
 	// Added Key_Shared subscription
-	ProtocolVersion_v15 ProtocolVersion = 15
-	ProtocolVersion_v16 ProtocolVersion = 16
-	ProtocolVersion_v17 ProtocolVersion = 17
-	ProtocolVersion_v18 ProtocolVersion = 18
-	ProtocolVersion_v19 ProtocolVersion = 19
+	ProtocolVersion_v15 ProtocolVersion = 15 // Add CommandGetOrCreateSchema and CommandGetOrCreateSchemaResponse
+	ProtocolVersion_v16 ProtocolVersion = 16 // Add support for broker entry metadata
+	ProtocolVersion_v17 ProtocolVersion = 17 // Added support ack receipt
+	ProtocolVersion_v18 ProtocolVersion = 18 // Add client support for broker entry metadata
+	ProtocolVersion_v19 ProtocolVersion = 19 // Add CommandTcClientConnectRequest and CommandTcClientConnectResponse
 )
 
-var ProtocolVersion_name = map[int32]string{
-	0:  "v0",
-	1:  "v1",
-	2:  "v2",
-	3:  "v3",
-	4:  "v4",
-	5:  "v5",
-	6:  "v6",
-	7:  "v7",
-	8:  "v8",
-	9:  "v9",
-	10: "v10",
-	11: "v11",
-	12: "v12",
-	13: "v13",
-	14: "v14",
-	15: "v15",
-	16: "v16",
-	17: "v17",
-	18: "v18",
-	19: "v19",
-}
-
-var ProtocolVersion_value = map[string]int32{
-	"v0":  0,
-	"v1":  1,
-	"v2":  2,
-	"v3":  3,
-	"v4":  4,
-	"v5":  5,
-	"v6":  6,
-	"v7":  7,
-	"v8":  8,
-	"v9":  9,
-	"v10": 10,
-	"v11": 11,
-	"v12": 12,
-	"v13": 13,
-	"v14": 14,
-	"v15": 15,
-	"v16": 16,
-	"v17": 17,
-	"v18": 18,
-	"v19": 19,
-}
+// Enum value maps for ProtocolVersion.
+var (
+	ProtocolVersion_name = map[int32]string{
+		0:  "v0",
+		1:  "v1",
+		2:  "v2",
+		3:  "v3",
+		4:  "v4",
+		5:  "v5",
+		6:  "v6",
+		7:  "v7",
+		8:  "v8",
+		9:  "v9",
+		10: "v10",
+		11: "v11",
+		12: "v12",
+		13: "v13",
+		14: "v14",
+		15: "v15",
+		16: "v16",
+		17: "v17",
+		18: "v18",
+		19: "v19",
+	}
+	ProtocolVersion_value = map[string]int32{
+		"v0":  0,
+		"v1":  1,
+		"v2":  2,
+		"v3":  3,
+		"v4":  4,
+		"v5":  5,
+		"v6":  6,
+		"v7":  7,
+		"v8":  8,
+		"v9":  9,
+		"v10": 10,
+		"v11": 11,
+		"v12": 12,
+		"v13": 13,
+		"v14": 14,
+		"v15": 15,
+		"v16": 16,
+		"v17": 17,
+		"v18": 18,
+		"v19": 19,
+	}
+)
 
 func (x ProtocolVersion) Enum() *ProtocolVersion {
 	p := new(ProtocolVersion)
@@ -358,20 +438,34 @@ func (x ProtocolVersion) Enum() *ProtocolVersion {
 }
 
 func (x ProtocolVersion) String() string {
-	return proto.EnumName(ProtocolVersion_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (ProtocolVersion) Descriptor() protoreflect.EnumDescriptor {
+	return file_PulsarApi_proto_enumTypes[4].Descriptor()
 }
 
-func (x *ProtocolVersion) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(ProtocolVersion_value, data, "ProtocolVersion")
+func (ProtocolVersion) Type() protoreflect.EnumType {
+	return &file_PulsarApi_proto_enumTypes[4]
+}
+
+func (x ProtocolVersion) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *ProtocolVersion) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
 	if err != nil {
 		return err
 	}
-	*x = ProtocolVersion(value)
+	*x = ProtocolVersion(num)
 	return nil
 }
 
+// Deprecated: Use ProtocolVersion.Descriptor instead.
 func (ProtocolVersion) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{4}
+	return file_PulsarApi_proto_rawDescGZIP(), []int{4}
 }
 
 type KeySharedMode int32
@@ -381,15 +475,17 @@ const (
 	KeySharedMode_STICKY     KeySharedMode = 1
 )
 
-var KeySharedMode_name = map[int32]string{
-	0: "AUTO_SPLIT",
-	1: "STICKY",
-}
-
-var KeySharedMode_value = map[string]int32{
-	"AUTO_SPLIT": 0,
-	"STICKY":     1,
-}
+// Enum value maps for KeySharedMode.
+var (
+	KeySharedMode_name = map[int32]string{
+		0: "AUTO_SPLIT",
+		1: "STICKY",
+	}
+	KeySharedMode_value = map[string]int32{
+		"AUTO_SPLIT": 0,
+		"STICKY":     1,
+	}
+)
 
 func (x KeySharedMode) Enum() *KeySharedMode {
 	p := new(KeySharedMode)
@@ -398,20 +494,34 @@ func (x KeySharedMode) Enum() *KeySharedMode {
 }
 
 func (x KeySharedMode) String() string {
-	return proto.EnumName(KeySharedMode_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (KeySharedMode) Descriptor() protoreflect.EnumDescriptor {
+	return file_PulsarApi_proto_enumTypes[5].Descriptor()
+}
+
+func (KeySharedMode) Type() protoreflect.EnumType {
+	return &file_PulsarApi_proto_enumTypes[5]
+}
+
+func (x KeySharedMode) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
 }
 
-func (x *KeySharedMode) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(KeySharedMode_value, data, "KeySharedMode")
+// Deprecated: Do not use.
+func (x *KeySharedMode) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
 	if err != nil {
 		return err
 	}
-	*x = KeySharedMode(value)
+	*x = KeySharedMode(num)
 	return nil
 }
 
+// Deprecated: Use KeySharedMode.Descriptor instead.
 func (KeySharedMode) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{5}
+	return file_PulsarApi_proto_rawDescGZIP(), []int{5}
 }
 
 type TxnAction int32
@@ -421,15 +531,17 @@ const (
 	TxnAction_ABORT  TxnAction = 1
 )
 
-var TxnAction_name = map[int32]string{
-	0: "COMMIT",
-	1: "ABORT",
-}
-
-var TxnAction_value = map[string]int32{
-	"COMMIT": 0,
-	"ABORT":  1,
-}
+// Enum value maps for TxnAction.
+var (
+	TxnAction_name = map[int32]string{
+		0: "COMMIT",
+		1: "ABORT",
+	}
+	TxnAction_value = map[string]int32{
+		"COMMIT": 0,
+		"ABORT":  1,
+	}
+)
 
 func (x TxnAction) Enum() *TxnAction {
 	p := new(TxnAction)
@@ -438,20 +550,34 @@ func (x TxnAction) Enum() *TxnAction {
 }
 
 func (x TxnAction) String() string {
-	return proto.EnumName(TxnAction_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
 }
 
-func (x *TxnAction) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(TxnAction_value, data, "TxnAction")
+func (TxnAction) Descriptor() protoreflect.EnumDescriptor {
+	return file_PulsarApi_proto_enumTypes[6].Descriptor()
+}
+
+func (TxnAction) Type() protoreflect.EnumType {
+	return &file_PulsarApi_proto_enumTypes[6]
+}
+
+func (x TxnAction) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *TxnAction) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
 	if err != nil {
 		return err
 	}
-	*x = TxnAction(value)
+	*x = TxnAction(num)
 	return nil
 }
 
+// Deprecated: Use TxnAction.Descriptor instead.
 func (TxnAction) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{6}
+	return file_PulsarApi_proto_rawDescGZIP(), []int{6}
 }
 
 type Schema_Type int32
@@ -480,53 +606,55 @@ const (
 	Schema_ProtobufNative Schema_Type = 20
 )
 
-var Schema_Type_name = map[int32]string{
-	0:  "None",
-	1:  "String",
-	2:  "Json",
-	3:  "Protobuf",
-	4:  "Avro",
-	5:  "Bool",
-	6:  "Int8",
-	7:  "Int16",
-	8:  "Int32",
-	9:  "Int64",
-	10: "Float",
-	11: "Double",
-	12: "Date",
-	13: "Time",
-	14: "Timestamp",
-	15: "KeyValue",
-	16: "Instant",
-	17: "LocalDate",
-	18: "LocalTime",
-	19: "LocalDateTime",
-	20: "ProtobufNative",
-}
-
-var Schema_Type_value = map[string]int32{
-	"None":           0,
-	"String":         1,
-	"Json":           2,
-	"Protobuf":       3,
-	"Avro":           4,
-	"Bool":           5,
-	"Int8":           6,
-	"Int16":          7,
-	"Int32":          8,
-	"Int64":          9,
-	"Float":          10,
-	"Double":         11,
-	"Date":           12,
-	"Time":           13,
-	"Timestamp":      14,
-	"KeyValue":       15,
-	"Instant":        16,
-	"LocalDate":      17,
-	"LocalTime":      18,
-	"LocalDateTime":  19,
-	"ProtobufNative": 20,
-}
+// Enum value maps for Schema_Type.
+var (
+	Schema_Type_name = map[int32]string{
+		0:  "None",
+		1:  "String",
+		2:  "Json",
+		3:  "Protobuf",
+		4:  "Avro",
+		5:  "Bool",
+		6:  "Int8",
+		7:  "Int16",
+		8:  "Int32",
+		9:  "Int64",
+		10: "Float",
+		11: "Double",
+		12: "Date",
+		13: "Time",
+		14: "Timestamp",
+		15: "KeyValue",
+		16: "Instant",
+		17: "LocalDate",
+		18: "LocalTime",
+		19: "LocalDateTime",
+		20: "ProtobufNative",
+	}
+	Schema_Type_value = map[string]int32{
+		"None":           0,
+		"String":         1,
+		"Json":           2,
+		"Protobuf":       3,
+		"Avro":           4,
+		"Bool":           5,
+		"Int8":           6,
+		"Int16":          7,
+		"Int32":          8,
+		"Int64":          9,
+		"Float":          10,
+		"Double":         11,
+		"Date":           12,
+		"Time":           13,
+		"Timestamp":      14,
+		"KeyValue":       15,
+		"Instant":        16,
+		"LocalDate":      17,
+		"LocalTime":      18,
+		"LocalDateTime":  19,
+		"ProtobufNative": 20,
+	}
+)
 
 func (x Schema_Type) Enum() *Schema_Type {
 	p := new(Schema_Type)
@@ -535,20 +663,34 @@ func (x Schema_Type) Enum() *Schema_Type {
 }
 
 func (x Schema_Type) String() string {
-	return proto.EnumName(Schema_Type_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Schema_Type) Descriptor() protoreflect.EnumDescriptor {
+	return file_PulsarApi_proto_enumTypes[7].Descriptor()
+}
+
+func (Schema_Type) Type() protoreflect.EnumType {
+	return &file_PulsarApi_proto_enumTypes[7]
+}
+
+func (x Schema_Type) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
 }
 
-func (x *Schema_Type) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(Schema_Type_value, data, "Schema_Type")
+// Deprecated: Do not use.
+func (x *Schema_Type) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
 	if err != nil {
 		return err
 	}
-	*x = Schema_Type(value)
+	*x = Schema_Type(num)
 	return nil
 }
 
+// Deprecated: Use Schema_Type.Descriptor instead.
 func (Schema_Type) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{0, 0}
+	return file_PulsarApi_proto_rawDescGZIP(), []int{0, 0}
 }
 
 type CommandSubscribe_SubType int32
@@ -560,19 +702,21 @@ const (
 	CommandSubscribe_Key_Shared CommandSubscribe_SubType = 3
 )
 
-var CommandSubscribe_SubType_name = map[int32]string{
-	0: "Exclusive",
-	1: "Shared",
-	2: "Failover",
-	3: "Key_Shared",
-}
-
-var CommandSubscribe_SubType_value = map[string]int32{
-	"Exclusive":  0,
-	"Shared":     1,
-	"Failover":   2,
-	"Key_Shared": 3,
-}
+// Enum value maps for CommandSubscribe_SubType.
+var (
+	CommandSubscribe_SubType_name = map[int32]string{
+		0: "Exclusive",
+		1: "Shared",
+		2: "Failover",
+		3: "Key_Shared",
+	}
+	CommandSubscribe_SubType_value = map[string]int32{
+		"Exclusive":  0,
+		"Shared":     1,
+		"Failover":   2,
+		"Key_Shared": 3,
+	}
+)
 
 func (x CommandSubscribe_SubType) Enum() *CommandSubscribe_SubType {
 	p := new(CommandSubscribe_SubType)
@@ -581,20 +725,34 @@ func (x CommandSubscribe_SubType) Enum() *CommandSubscribe_SubType {
 }
 
 func (x CommandSubscribe_SubType) String() string {
-	return proto.EnumName(CommandSubscribe_SubType_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (CommandSubscribe_SubType) Descriptor() protoreflect.EnumDescriptor {
+	return file_PulsarApi_proto_enumTypes[8].Descriptor()
 }
 
-func (x *CommandSubscribe_SubType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(CommandSubscribe_SubType_value, data, "CommandSubscribe_SubType")
+func (CommandSubscribe_SubType) Type() protoreflect.EnumType {
+	return &file_PulsarApi_proto_enumTypes[8]
+}
+
+func (x CommandSubscribe_SubType) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *CommandSubscribe_SubType) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
 	if err != nil {
 		return err
 	}
-	*x = CommandSubscribe_SubType(value)
+	*x = CommandSubscribe_SubType(num)
 	return nil
 }
 
+// Deprecated: Use CommandSubscribe_SubType.Descriptor instead.
 func (CommandSubscribe_SubType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{16, 0}
+	return file_PulsarApi_proto_rawDescGZIP(), []int{16, 0}
 }
 
 type CommandSubscribe_InitialPosition int32
@@ -604,15 +762,17 @@ const (
 	CommandSubscribe_Earliest CommandSubscribe_InitialPosition = 1
 )
 
-var CommandSubscribe_InitialPosition_name = map[int32]string{
-	0: "Latest",
-	1: "Earliest",
-}
-
-var CommandSubscribe_InitialPosition_value = map[string]int32{
-	"Latest":   0,
-	"Earliest": 1,
-}
+// Enum value maps for CommandSubscribe_InitialPosition.
+var (
+	CommandSubscribe_InitialPosition_name = map[int32]string{
+		0: "Latest",
+		1: "Earliest",
+	}
+	CommandSubscribe_InitialPosition_value = map[string]int32{
+		"Latest":   0,
+		"Earliest": 1,
+	}
+)
 
 func (x CommandSubscribe_InitialPosition) Enum() *CommandSubscribe_InitialPosition {
 	p := new(CommandSubscribe_InitialPosition)
@@ -621,20 +781,34 @@ func (x CommandSubscribe_InitialPosition) Enum() *CommandSubscribe_InitialPositi
 }
 
 func (x CommandSubscribe_InitialPosition) String() string {
-	return proto.EnumName(CommandSubscribe_InitialPosition_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (CommandSubscribe_InitialPosition) Descriptor() protoreflect.EnumDescriptor {
+	return file_PulsarApi_proto_enumTypes[9].Descriptor()
+}
+
+func (CommandSubscribe_InitialPosition) Type() protoreflect.EnumType {
+	return &file_PulsarApi_proto_enumTypes[9]
+}
+
+func (x CommandSubscribe_InitialPosition) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
 }
 
-func (x *CommandSubscribe_InitialPosition) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(CommandSubscribe_InitialPosition_value, data, "CommandSubscribe_InitialPosition")
+// Deprecated: Do not use.
+func (x *CommandSubscribe_InitialPosition) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
 	if err != nil {
 		return err
 	}
-	*x = CommandSubscribe_InitialPosition(value)
+	*x = CommandSubscribe_InitialPosition(num)
 	return nil
 }
 
+// Deprecated: Use CommandSubscribe_InitialPosition.Descriptor instead.
 func (CommandSubscribe_InitialPosition) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{16, 1}
+	return file_PulsarApi_proto_rawDescGZIP(), []int{16, 1}
 }
 
 type CommandPartitionedTopicMetadataResponse_LookupType int32
@@ -644,15 +818,17 @@ const (
 	CommandPartitionedTopicMetadataResponse_Failed  CommandPartitionedTopicMetadataResponse_LookupType = 1
 )
 
-var CommandPartitionedTopicMetadataResponse_LookupType_name = map[int32]string{
-	0: "Success",
-	1: "Failed",
-}
-
-var CommandPartitionedTopicMetadataResponse_LookupType_value = map[string]int32{
-	"Success": 0,
-	"Failed":  1,
-}
+// Enum value maps for CommandPartitionedTopicMetadataResponse_LookupType.
+var (
+	CommandPartitionedTopicMetadataResponse_LookupType_name = map[int32]string{
+		0: "Success",
+		1: "Failed",
+	}
+	CommandPartitionedTopicMetadataResponse_LookupType_value = map[string]int32{
+		"Success": 0,
+		"Failed":  1,
+	}
+)
 
 func (x CommandPartitionedTopicMetadataResponse_LookupType) Enum() *CommandPartitionedTopicMetadataResponse_LookupType {
 	p := new(CommandPartitionedTopicMetadataResponse_LookupType)
@@ -661,20 +837,34 @@ func (x CommandPartitionedTopicMetadataResponse_LookupType) Enum() *CommandParti
 }
 
 func (x CommandPartitionedTopicMetadataResponse_LookupType) String() string {
-	return proto.EnumName(CommandPartitionedTopicMetadataResponse_LookupType_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
 }
 
-func (x *CommandPartitionedTopicMetadataResponse_LookupType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(CommandPartitionedTopicMetadataResponse_LookupType_value, data, "CommandPartitionedTopicMetadataResponse_LookupType")
+func (CommandPartitionedTopicMetadataResponse_LookupType) Descriptor() protoreflect.EnumDescriptor {
+	return file_PulsarApi_proto_enumTypes[10].Descriptor()
+}
+
+func (CommandPartitionedTopicMetadataResponse_LookupType) Type() protoreflect.EnumType {
+	return &file_PulsarApi_proto_enumTypes[10]
+}
+
+func (x CommandPartitionedTopicMetadataResponse_LookupType) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *CommandPartitionedTopicMetadataResponse_LookupType) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
 	if err != nil {
 		return err
 	}
-	*x = CommandPartitionedTopicMetadataResponse_LookupType(value)
+	*x = CommandPartitionedTopicMetadataResponse_LookupType(num)
 	return nil
 }
 
+// Deprecated: Use CommandPartitionedTopicMetadataResponse_LookupType.Descriptor instead.
 func (CommandPartitionedTopicMetadataResponse_LookupType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{18, 0}
+	return file_PulsarApi_proto_rawDescGZIP(), []int{18, 0}
 }
 
 type CommandLookupTopicResponse_LookupType int32
@@ -685,17 +875,19 @@ const (
 	CommandLookupTopicResponse_Failed   CommandLookupTopicResponse_LookupType = 2
 )
 
-var CommandLookupTopicResponse_LookupType_name = map[int32]string{
-	0: "Redirect",
-	1: "Connect",
-	2: "Failed",
-}
-
-var CommandLookupTopicResponse_LookupType_value = map[string]int32{
-	"Redirect": 0,
-	"Connect":  1,
-	"Failed":   2,
-}
+// Enum value maps for CommandLookupTopicResponse_LookupType.
+var (
+	CommandLookupTopicResponse_LookupType_name = map[int32]string{
+		0: "Redirect",
+		1: "Connect",
+		2: "Failed",
+	}
+	CommandLookupTopicResponse_LookupType_value = map[string]int32{
+		"Redirect": 0,
+		"Connect":  1,
+		"Failed":   2,
+	}
+)
 
 func (x CommandLookupTopicResponse_LookupType) Enum() *CommandLookupTopicResponse_LookupType {
 	p := new(CommandLookupTopicResponse_LookupType)
@@ -704,20 +896,34 @@ func (x CommandLookupTopicResponse_LookupType) Enum() *CommandLookupTopicRespons
 }
 
 func (x CommandLookupTopicResponse_LookupType) String() string {
-	return proto.EnumName(CommandLookupTopicResponse_LookupType_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (CommandLookupTopicResponse_LookupType) Descriptor() protoreflect.EnumDescriptor {
+	return file_PulsarApi_proto_enumTypes[11].Descriptor()
+}
+
+func (CommandLookupTopicResponse_LookupType) Type() protoreflect.EnumType {
+	return &file_PulsarApi_proto_enumTypes[11]
+}
+
+func (x CommandLookupTopicResponse_LookupType) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
 }
 
-func (x *CommandLookupTopicResponse_LookupType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(CommandLookupTopicResponse_LookupType_value, data, "CommandLookupTopicResponse_LookupType")
+// Deprecated: Do not use.
+func (x *CommandLookupTopicResponse_LookupType) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
 	if err != nil {
 		return err
 	}
-	*x = CommandLookupTopicResponse_LookupType(value)
+	*x = CommandLookupTopicResponse_LookupType(num)
 	return nil
 }
 
+// Deprecated: Use CommandLookupTopicResponse_LookupType.Descriptor instead.
 func (CommandLookupTopicResponse_LookupType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{20, 0}
+	return file_PulsarApi_proto_rawDescGZIP(), []int{20, 0}
 }
 
 type CommandAck_AckType int32
@@ -727,15 +933,17 @@ const (
 	CommandAck_Cumulative CommandAck_AckType = 1
 )
 
-var CommandAck_AckType_name = map[int32]string{
-	0: "Individual",
-	1: "Cumulative",
-}
-
-var CommandAck_AckType_value = map[string]int32{
-	"Individual": 0,
-	"Cumulative": 1,
-}
+// Enum value maps for CommandAck_AckType.
+var (
+	CommandAck_AckType_name = map[int32]string{
+		0: "Individual",
+		1: "Cumulative",
+	}
+	CommandAck_AckType_value = map[string]int32{
+		"Individual": 0,
+		"Cumulative": 1,
+	}
+)
 
 func (x CommandAck_AckType) Enum() *CommandAck_AckType {
 	p := new(CommandAck_AckType)
@@ -744,20 +952,34 @@ func (x CommandAck_AckType) Enum() *CommandAck_AckType {
 }
 
 func (x CommandAck_AckType) String() string {
-	return proto.EnumName(CommandAck_AckType_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (CommandAck_AckType) Descriptor() protoreflect.EnumDescriptor {
+	return file_PulsarApi_proto_enumTypes[12].Descriptor()
+}
+
+func (CommandAck_AckType) Type() protoreflect.EnumType {
+	return &file_PulsarApi_proto_enumTypes[12]
+}
+
+func (x CommandAck_AckType) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
 }
 
-func (x *CommandAck_AckType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(CommandAck_AckType_value, data, "CommandAck_AckType")
+// Deprecated: Do not use.
+func (x *CommandAck_AckType) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
 	if err != nil {
 		return err
 	}
-	*x = CommandAck_AckType(value)
+	*x = CommandAck_AckType(num)
 	return nil
 }
 
+// Deprecated: Use CommandAck_AckType.Descriptor instead.
 func (CommandAck_AckType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{26, 0}
+	return file_PulsarApi_proto_rawDescGZIP(), []int{26, 0}
 }
 
 // Acks can contain a flag to indicate the consumer
@@ -773,21 +995,23 @@ const (
 	CommandAck_DecryptionError            CommandAck_ValidationError = 4
 )
 
-var CommandAck_ValidationError_name = map[int32]string{
-	0: "UncompressedSizeCorruption",
-	1: "DecompressionError",
-	2: "ChecksumMismatch",
-	3: "BatchDeSerializeError",
-	4: "DecryptionError",
-}
-
-var CommandAck_ValidationError_value = map[string]int32{
-	"UncompressedSizeCorruption": 0,
-	"DecompressionError":         1,
-	"ChecksumMismatch":           2,
-	"BatchDeSerializeError":      3,
-	"DecryptionError":            4,
-}
+// Enum value maps for CommandAck_ValidationError.
+var (
+	CommandAck_ValidationError_name = map[int32]string{
+		0: "UncompressedSizeCorruption",
+		1: "DecompressionError",
+		2: "ChecksumMismatch",
+		3: "BatchDeSerializeError",
+		4: "DecryptionError",
+	}
+	CommandAck_ValidationError_value = map[string]int32{
+		"UncompressedSizeCorruption": 0,
+		"DecompressionError":         1,
+		"ChecksumMismatch":           2,
+		"BatchDeSerializeError":      3,
+		"DecryptionError":            4,
+	}
+)
 
 func (x CommandAck_ValidationError) Enum() *CommandAck_ValidationError {
 	p := new(CommandAck_ValidationError)
@@ -796,20 +1020,34 @@ func (x CommandAck_ValidationError) Enum() *CommandAck_ValidationError {
 }
 
 func (x CommandAck_ValidationError) String() string {
-	return proto.EnumName(CommandAck_ValidationError_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (CommandAck_ValidationError) Descriptor() protoreflect.EnumDescriptor {
+	return file_PulsarApi_proto_enumTypes[13].Descriptor()
 }
 
-func (x *CommandAck_ValidationError) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(CommandAck_ValidationError_value, data, "CommandAck_ValidationError")
+func (CommandAck_ValidationError) Type() protoreflect.EnumType {
+	return &file_PulsarApi_proto_enumTypes[13]
+}
+
+func (x CommandAck_ValidationError) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *CommandAck_ValidationError) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
 	if err != nil {
 		return err
 	}
-	*x = CommandAck_ValidationError(value)
+	*x = CommandAck_ValidationError(num)
 	return nil
 }
 
+// Deprecated: Use CommandAck_ValidationError.Descriptor instead.
 func (CommandAck_ValidationError) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{26, 1}
+	return file_PulsarApi_proto_rawDescGZIP(), []int{26, 1}
 }
 
 type CommandGetTopicsOfNamespace_Mode int32
@@ -820,17 +1058,19 @@ const (
 	CommandGetTopicsOfNamespace_ALL            CommandGetTopicsOfNamespace_Mode = 2
 )
 
-var CommandGetTopicsOfNamespace_Mode_name = map[int32]string{
-	0: "PERSISTENT",
-	1: "NON_PERSISTENT",
-	2: "ALL",
-}
-
-var CommandGetTopicsOfNamespace_Mode_value = map[string]int32{
-	"PERSISTENT":     0,
-	"NON_PERSISTENT": 1,
-	"ALL":            2,
-}
+// Enum value maps for CommandGetTopicsOfNamespace_Mode.
+var (
+	CommandGetTopicsOfNamespace_Mode_name = map[int32]string{
+		0: "PERSISTENT",
+		1: "NON_PERSISTENT",
+		2: "ALL",
+	}
+	CommandGetTopicsOfNamespace_Mode_value = map[string]int32{
+		"PERSISTENT":     0,
+		"NON_PERSISTENT": 1,
+		"ALL":            2,
+	}
+)
 
 func (x CommandGetTopicsOfNamespace_Mode) Enum() *CommandGetTopicsOfNamespace_Mode {
 	p := new(CommandGetTopicsOfNamespace_Mode)
@@ -839,20 +1079,34 @@ func (x CommandGetTopicsOfNamespace_Mode) Enum() *CommandGetTopicsOfNamespace_Mo
 }
 
 func (x CommandGetTopicsOfNamespace_Mode) String() string {
-	return proto.EnumName(CommandGetTopicsOfNamespace_Mode_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (CommandGetTopicsOfNamespace_Mode) Descriptor() protoreflect.EnumDescriptor {
+	return file_PulsarApi_proto_enumTypes[14].Descriptor()
+}
+
+func (CommandGetTopicsOfNamespace_Mode) Type() protoreflect.EnumType {
+	return &file_PulsarApi_proto_enumTypes[14]
+}
+
+func (x CommandGetTopicsOfNamespace_Mode) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
 }
 
-func (x *CommandGetTopicsOfNamespace_Mode) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(CommandGetTopicsOfNamespace_Mode_value, data, "CommandGetTopicsOfNamespace_Mode")
+// Deprecated: Do not use.
+func (x *CommandGetTopicsOfNamespace_Mode) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
 	if err != nil {
 		return err
 	}
-	*x = CommandGetTopicsOfNamespace_Mode(value)
+	*x = CommandGetTopicsOfNamespace_Mode(num)
 	return nil
 }
 
+// Deprecated: Use CommandGetTopicsOfNamespace_Mode.Descriptor instead.
 func (CommandGetTopicsOfNamespace_Mode) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{45, 0}
+	return file_PulsarApi_proto_rawDescGZIP(), []int{45, 0}
 }
 
 type BaseCommand_Type int32
@@ -918,125 +1172,127 @@ const (
 	BaseCommand_WATCH_TOPIC_LIST_CLOSE           BaseCommand_Type = 67
 )
 
-var BaseCommand_Type_name = map[int32]string{
-	2:  "CONNECT",
-	3:  "CONNECTED",
-	4:  "SUBSCRIBE",
-	5:  "PRODUCER",
-	6:  "SEND",
-	7:  "SEND_RECEIPT",
-	8:  "SEND_ERROR",
-	9:  "MESSAGE",
-	10: "ACK",
-	11: "FLOW",
-	12: "UNSUBSCRIBE",
-	13: "SUCCESS",
-	14: "ERROR",
-	15: "CLOSE_PRODUCER",
-	16: "CLOSE_CONSUMER",
-	17: "PRODUCER_SUCCESS",
-	18: "PING",
-	19: "PONG",
-	20: "REDELIVER_UNACKNOWLEDGED_MESSAGES",
-	21: "PARTITIONED_METADATA",
-	22: "PARTITIONED_METADATA_RESPONSE",
-	23: "LOOKUP",
-	24: "LOOKUP_RESPONSE",
-	25: "CONSUMER_STATS",
-	26: "CONSUMER_STATS_RESPONSE",
-	27: "REACHED_END_OF_TOPIC",
-	28: "SEEK",
-	29: "GET_LAST_MESSAGE_ID",
-	30: "GET_LAST_MESSAGE_ID_RESPONSE",
-	31: "ACTIVE_CONSUMER_CHANGE",
-	32: "GET_TOPICS_OF_NAMESPACE",
-	33: "GET_TOPICS_OF_NAMESPACE_RESPONSE",
-	34: "GET_SCHEMA",
-	35: "GET_SCHEMA_RESPONSE",
-	36: "AUTH_CHALLENGE",
-	37: "AUTH_RESPONSE",
-	38: "ACK_RESPONSE",
-	39: "GET_OR_CREATE_SCHEMA",
-	40: "GET_OR_CREATE_SCHEMA_RESPONSE",
-	50: "NEW_TXN",
-	51: "NEW_TXN_RESPONSE",
-	52: "ADD_PARTITION_TO_TXN",
-	53: "ADD_PARTITION_TO_TXN_RESPONSE",
-	54: "ADD_SUBSCRIPTION_TO_TXN",
-	55: "ADD_SUBSCRIPTION_TO_TXN_RESPONSE",
-	56: "END_TXN",
-	57: "END_TXN_RESPONSE",
-	58: "END_TXN_ON_PARTITION",
-	59: "END_TXN_ON_PARTITION_RESPONSE",
-	60: "END_TXN_ON_SUBSCRIPTION",
-	61: "END_TXN_ON_SUBSCRIPTION_RESPONSE",
-	62: "TC_CLIENT_CONNECT_REQUEST",
-	63: "TC_CLIENT_CONNECT_RESPONSE",
-	64: "WATCH_TOPIC_LIST",
-	65: "WATCH_TOPIC_LIST_SUCCESS",
-	66: "WATCH_TOPIC_UPDATE",
-	67: "WATCH_TOPIC_LIST_CLOSE",
-}
-
-var BaseCommand_Type_value = map[string]int32{
-	"CONNECT":                           2,
-	"CONNECTED":                         3,
-	"SUBSCRIBE":                         4,
-	"PRODUCER":                          5,
-	"SEND":                              6,
-	"SEND_RECEIPT":                      7,
-	"SEND_ERROR":                        8,
-	"MESSAGE":                           9,
-	"ACK":                               10,
-	"FLOW":                              11,
-	"UNSUBSCRIBE":                       12,
-	"SUCCESS":                           13,
-	"ERROR":                             14,
-	"CLOSE_PRODUCER":                    15,
-	"CLOSE_CONSUMER":                    16,
-	"PRODUCER_SUCCESS":                  17,
-	"PING":                              18,
-	"PONG":                              19,
-	"REDELIVER_UNACKNOWLEDGED_MESSAGES": 20,
-	"PARTITIONED_METADATA":              21,
-	"PARTITIONED_METADATA_RESPONSE":     22,
-	"LOOKUP":                            23,
-	"LOOKUP_RESPONSE":                   24,
-	"CONSUMER_STATS":                    25,
-	"CONSUMER_STATS_RESPONSE":           26,
-	"REACHED_END_OF_TOPIC":              27,
-	"SEEK":                              28,
-	"GET_LAST_MESSAGE_ID":               29,
-	"GET_LAST_MESSAGE_ID_RESPONSE":      30,
-	"ACTIVE_CONSUMER_CHANGE":            31,
-	"GET_TOPICS_OF_NAMESPACE":           32,
-	"GET_TOPICS_OF_NAMESPACE_RESPONSE":  33,
-	"GET_SCHEMA":                        34,
-	"GET_SCHEMA_RESPONSE":               35,
-	"AUTH_CHALLENGE":                    36,
-	"AUTH_RESPONSE":                     37,
-	"ACK_RESPONSE":                      38,
-	"GET_OR_CREATE_SCHEMA":              39,
-	"GET_OR_CREATE_SCHEMA_RESPONSE":     40,
-	"NEW_TXN":                           50,
-	"NEW_TXN_RESPONSE":                  51,
-	"ADD_PARTITION_TO_TXN":              52,
-	"ADD_PARTITION_TO_TXN_RESPONSE":     53,
-	"ADD_SUBSCRIPTION_TO_TXN":           54,
-	"ADD_SUBSCRIPTION_TO_TXN_RESPONSE":  55,
-	"END_TXN":                           56,
-	"END_TXN_RESPONSE":                  57,
-	"END_TXN_ON_PARTITION":              58,
-	"END_TXN_ON_PARTITION_RESPONSE":     59,
-	"END_TXN_ON_SUBSCRIPTION":           60,
-	"END_TXN_ON_SUBSCRIPTION_RESPONSE":  61,
-	"TC_CLIENT_CONNECT_REQUEST":         62,
-	"TC_CLIENT_CONNECT_RESPONSE":        63,
-	"WATCH_TOPIC_LIST":                  64,
-	"WATCH_TOPIC_LIST_SUCCESS":          65,
-	"WATCH_TOPIC_UPDATE":                66,
-	"WATCH_TOPIC_LIST_CLOSE":            67,
-}
+// Enum value maps for BaseCommand_Type.
+var (
+	BaseCommand_Type_name = map[int32]string{
+		2:  "CONNECT",
+		3:  "CONNECTED",
+		4:  "SUBSCRIBE",
+		5:  "PRODUCER",
+		6:  "SEND",
+		7:  "SEND_RECEIPT",
+		8:  "SEND_ERROR",
+		9:  "MESSAGE",
+		10: "ACK",
+		11: "FLOW",
+		12: "UNSUBSCRIBE",
+		13: "SUCCESS",
+		14: "ERROR",
+		15: "CLOSE_PRODUCER",
+		16: "CLOSE_CONSUMER",
+		17: "PRODUCER_SUCCESS",
+		18: "PING",
+		19: "PONG",
+		20: "REDELIVER_UNACKNOWLEDGED_MESSAGES",
+		21: "PARTITIONED_METADATA",
+		22: "PARTITIONED_METADATA_RESPONSE",
+		23: "LOOKUP",
+		24: "LOOKUP_RESPONSE",
+		25: "CONSUMER_STATS",
+		26: "CONSUMER_STATS_RESPONSE",
+		27: "REACHED_END_OF_TOPIC",
+		28: "SEEK",
+		29: "GET_LAST_MESSAGE_ID",
+		30: "GET_LAST_MESSAGE_ID_RESPONSE",
+		31: "ACTIVE_CONSUMER_CHANGE",
+		32: "GET_TOPICS_OF_NAMESPACE",
+		33: "GET_TOPICS_OF_NAMESPACE_RESPONSE",
+		34: "GET_SCHEMA",
+		35: "GET_SCHEMA_RESPONSE",
+		36: "AUTH_CHALLENGE",
+		37: "AUTH_RESPONSE",
+		38: "ACK_RESPONSE",
+		39: "GET_OR_CREATE_SCHEMA",
+		40: "GET_OR_CREATE_SCHEMA_RESPONSE",
+		50: "NEW_TXN",
+		51: "NEW_TXN_RESPONSE",
+		52: "ADD_PARTITION_TO_TXN",
+		53: "ADD_PARTITION_TO_TXN_RESPONSE",
+		54: "ADD_SUBSCRIPTION_TO_TXN",
+		55: "ADD_SUBSCRIPTION_TO_TXN_RESPONSE",
+		56: "END_TXN",
+		57: "END_TXN_RESPONSE",
+		58: "END_TXN_ON_PARTITION",
+		59: "END_TXN_ON_PARTITION_RESPONSE",
+		60: "END_TXN_ON_SUBSCRIPTION",
+		61: "END_TXN_ON_SUBSCRIPTION_RESPONSE",
+		62: "TC_CLIENT_CONNECT_REQUEST",
+		63: "TC_CLIENT_CONNECT_RESPONSE",
+		64: "WATCH_TOPIC_LIST",
+		65: "WATCH_TOPIC_LIST_SUCCESS",
+		66: "WATCH_TOPIC_UPDATE",
+		67: "WATCH_TOPIC_LIST_CLOSE",
+	}
+	BaseCommand_Type_value = map[string]int32{
+		"CONNECT":                           2,
+		"CONNECTED":                         3,
+		"SUBSCRIBE":                         4,
+		"PRODUCER":                          5,
+		"SEND":                              6,
+		"SEND_RECEIPT":                      7,
+		"SEND_ERROR":                        8,
+		"MESSAGE":                           9,
+		"ACK":                               10,
+		"FLOW":                              11,
+		"UNSUBSCRIBE":                       12,
+		"SUCCESS":                           13,
+		"ERROR":                             14,
+		"CLOSE_PRODUCER":                    15,
+		"CLOSE_CONSUMER":                    16,
+		"PRODUCER_SUCCESS":                  17,
+		"PING":                              18,
+		"PONG":                              19,
+		"REDELIVER_UNACKNOWLEDGED_MESSAGES": 20,
+		"PARTITIONED_METADATA":              21,
+		"PARTITIONED_METADATA_RESPONSE":     22,
+		"LOOKUP":                            23,
+		"LOOKUP_RESPONSE":                   24,
+		"CONSUMER_STATS":                    25,
+		"CONSUMER_STATS_RESPONSE":           26,
+		"REACHED_END_OF_TOPIC":              27,
+		"SEEK":                              28,
+		"GET_LAST_MESSAGE_ID":               29,
+		"GET_LAST_MESSAGE_ID_RESPONSE":      30,
+		"ACTIVE_CONSUMER_CHANGE":            31,
+		"GET_TOPICS_OF_NAMESPACE":           32,
+		"GET_TOPICS_OF_NAMESPACE_RESPONSE":  33,
+		"GET_SCHEMA":                        34,
+		"GET_SCHEMA_RESPONSE":               35,
+		"AUTH_CHALLENGE":                    36,
+		"AUTH_RESPONSE":                     37,
+		"ACK_RESPONSE":                      38,
+		"GET_OR_CREATE_SCHEMA":              39,
+		"GET_OR_CREATE_SCHEMA_RESPONSE":     40,
+		"NEW_TXN":                           50,
+		"NEW_TXN_RESPONSE":                  51,
+		"ADD_PARTITION_TO_TXN":              52,
+		"ADD_PARTITION_TO_TXN_RESPONSE":     53,
+		"ADD_SUBSCRIPTION_TO_TXN":           54,
+		"ADD_SUBSCRIPTION_TO_TXN_RESPONSE":  55,
+		"END_TXN":                           56,
+		"END_TXN_RESPONSE":                  57,
+		"END_TXN_ON_PARTITION":              58,
+		"END_TXN_ON_PARTITION_RESPONSE":     59,
+		"END_TXN_ON_SUBSCRIPTION":           60,
+		"END_TXN_ON_SUBSCRIPTION_RESPONSE":  61,
+		"TC_CLIENT_CONNECT_REQUEST":         62,
+		"TC_CLIENT_CONNECT_RESPONSE":        63,
+		"WATCH_TOPIC_LIST":                  64,
+		"WATCH_TOPIC_LIST_SUCCESS":          65,
+		"WATCH_TOPIC_UPDATE":                66,
+		"WATCH_TOPIC_LIST_CLOSE":            67,
+	}
+)
 
 func (x BaseCommand_Type) Enum() *BaseCommand_Type {
 	p := new(BaseCommand_Type)
@@ -1045,94 +1301,112 @@ func (x BaseCommand_Type) Enum() *BaseCommand_Type {
 }
 
 func (x BaseCommand_Type) String() string {
-	return proto.EnumName(BaseCommand_Type_name, int32(x))
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (BaseCommand_Type) Descriptor() protoreflect.EnumDescriptor {
+	return file_PulsarApi_proto_enumTypes[15].Descriptor()
+}
+
+func (BaseCommand_Type) Type() protoreflect.EnumType {
+	return &file_PulsarApi_proto_enumTypes[15]
+}
+
+func (x BaseCommand_Type) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
 }
 
-func (x *BaseCommand_Type) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(BaseCommand_Type_value, data, "BaseCommand_Type")
+// Deprecated: Do not use.
+func (x *BaseCommand_Type) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
 	if err != nil {
 		return err
 	}
-	*x = BaseCommand_Type(value)
+	*x = BaseCommand_Type(num)
 	return nil
 }
 
+// Deprecated: Use BaseCommand_Type.Descriptor instead.
 func (BaseCommand_Type) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{70, 0}
+	return file_PulsarApi_proto_rawDescGZIP(), []int{70, 0}
 }
 
 type Schema struct {
-	Name                 *string      `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
-	SchemaData           []byte       `protobuf:"bytes,3,req,name=schema_data,json=schemaData" json:"schema_data,omitempty"`
-	Type                 *Schema_Type `protobuf:"varint,4,req,name=type,enum=pulsar.proto.Schema_Type" json:"type,omitempty"`
-	Properties           []*KeyValue  `protobuf:"bytes,5,rep,name=properties" json:"properties,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
-}
-
-func (m *Schema) Reset()         { *m = Schema{} }
-func (m *Schema) String() string { return proto.CompactTextString(m) }
-func (*Schema) ProtoMessage()    {}
-func (*Schema) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{0}
-}
-func (m *Schema) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *Schema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_Schema.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Name       *string      `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
+	SchemaData []byte       `protobuf:"bytes,3,req,name=schema_data,json=schemaData" json:"schema_data,omitempty"`
+	Type       *Schema_Type `protobuf:"varint,4,req,name=type,enum=pulsar.proto.Schema_Type" json:"type,omitempty"`
+	Properties []*KeyValue  `protobuf:"bytes,5,rep,name=properties" json:"properties,omitempty"`
 }
-func (m *Schema) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Schema.Merge(m, src)
+
+func (x *Schema) Reset() {
+	*x = Schema{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *Schema) XXX_Size() int {
-	return m.Size()
+
+func (x *Schema) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *Schema) XXX_DiscardUnknown() {
-	xxx_messageInfo_Schema.DiscardUnknown(m)
+
+func (*Schema) ProtoMessage() {}
+
+func (x *Schema) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_Schema proto.InternalMessageInfo
+// Deprecated: Use Schema.ProtoReflect.Descriptor instead.
+func (*Schema) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{0}
+}
 
-func (m *Schema) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
+func (x *Schema) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
 	}
 	return ""
 }
 
-func (m *Schema) GetSchemaData() []byte {
-	if m != nil {
-		return m.SchemaData
+func (x *Schema) GetSchemaData() []byte {
+	if x != nil {
+		return x.SchemaData
 	}
 	return nil
 }
 
-func (m *Schema) GetType() Schema_Type {
-	if m != nil && m.Type != nil {
-		return *m.Type
+func (x *Schema) GetType() Schema_Type {
+	if x != nil && x.Type != nil {
+		return *x.Type
 	}
 	return Schema_None
 }
 
-func (m *Schema) GetProperties() []*KeyValue {
-	if m != nil {
-		return m.Properties
+func (x *Schema) GetProperties() []*KeyValue {
+	if x != nil {
+		return x.Properties
 	}
 	return nil
 }
 
 type MessageIdData struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	LedgerId   *uint64 `protobuf:"varint,1,req,name=ledgerId" json:"ledgerId,omitempty"`
 	EntryId    *uint64 `protobuf:"varint,2,req,name=entryId" json:"entryId,omitempty"`
 	Partition  *int32  `protobuf:"varint,3,opt,name=partition,def=-1" json:"partition,omitempty"`
@@ -1140,326 +1414,329 @@ type MessageIdData struct {
 	AckSet     []int64 `protobuf:"varint,5,rep,name=ack_set,json=ackSet" json:"ack_set,omitempty"`
 	BatchSize  *int32  `protobuf:"varint,6,opt,name=batch_size,json=batchSize" json:"batch_size,omitempty"`
 	// For the chunk message id, we need to specify the first chunk message id.
-	FirstChunkMessageId  *MessageIdData `protobuf:"bytes,7,opt,name=first_chunk_message_id,json=firstChunkMessageId" json:"first_chunk_message_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
-	XXX_unrecognized     []byte         `json:"-"`
-	XXX_sizecache        int32          `json:"-"`
+	FirstChunkMessageId *MessageIdData `protobuf:"bytes,7,opt,name=first_chunk_message_id,json=firstChunkMessageId" json:"first_chunk_message_id,omitempty"`
 }
 
-func (m *MessageIdData) Reset()         { *m = MessageIdData{} }
-func (m *MessageIdData) String() string { return proto.CompactTextString(m) }
-func (*MessageIdData) ProtoMessage()    {}
-func (*MessageIdData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{1}
-}
-func (m *MessageIdData) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *MessageIdData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_MessageIdData.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for MessageIdData fields.
+const (
+	Default_MessageIdData_Partition  = int32(-1)
+	Default_MessageIdData_BatchIndex = int32(-1)
+)
+
+func (x *MessageIdData) Reset() {
+	*x = MessageIdData{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *MessageIdData) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MessageIdData.Merge(m, src)
-}
-func (m *MessageIdData) XXX_Size() int {
-	return m.Size()
-}
-func (m *MessageIdData) XXX_DiscardUnknown() {
-	xxx_messageInfo_MessageIdData.DiscardUnknown(m)
+
+func (x *MessageIdData) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_MessageIdData proto.InternalMessageInfo
+func (*MessageIdData) ProtoMessage() {}
+
+func (x *MessageIdData) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_MessageIdData_Partition int32 = -1
-const Default_MessageIdData_BatchIndex int32 = -1
+// Deprecated: Use MessageIdData.ProtoReflect.Descriptor instead.
+func (*MessageIdData) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{1}
+}
 
-func (m *MessageIdData) GetLedgerId() uint64 {
-	if m != nil && m.LedgerId != nil {
-		return *m.LedgerId
+func (x *MessageIdData) GetLedgerId() uint64 {
+	if x != nil && x.LedgerId != nil {
+		return *x.LedgerId
 	}
 	return 0
 }
 
-func (m *MessageIdData) GetEntryId() uint64 {
-	if m != nil && m.EntryId != nil {
-		return *m.EntryId
+func (x *MessageIdData) GetEntryId() uint64 {
+	if x != nil && x.EntryId != nil {
+		return *x.EntryId
 	}
 	return 0
 }
 
-func (m *MessageIdData) GetPartition() int32 {
-	if m != nil && m.Partition != nil {
-		return *m.Partition
+func (x *MessageIdData) GetPartition() int32 {
+	if x != nil && x.Partition != nil {
+		return *x.Partition
 	}
 	return Default_MessageIdData_Partition
 }
 
-func (m *MessageIdData) GetBatchIndex() int32 {
-	if m != nil && m.BatchIndex != nil {
-		return *m.BatchIndex
+func (x *MessageIdData) GetBatchIndex() int32 {
+	if x != nil && x.BatchIndex != nil {
+		return *x.BatchIndex
 	}
 	return Default_MessageIdData_BatchIndex
 }
 
-func (m *MessageIdData) GetAckSet() []int64 {
-	if m != nil {
-		return m.AckSet
+func (x *MessageIdData) GetAckSet() []int64 {
+	if x != nil {
+		return x.AckSet
 	}
 	return nil
 }
 
-func (m *MessageIdData) GetBatchSize() int32 {
-	if m != nil && m.BatchSize != nil {
-		return *m.BatchSize
+func (x *MessageIdData) GetBatchSize() int32 {
+	if x != nil && x.BatchSize != nil {
+		return *x.BatchSize
 	}
 	return 0
 }
 
-func (m *MessageIdData) GetFirstChunkMessageId() *MessageIdData {
-	if m != nil {
-		return m.FirstChunkMessageId
+func (x *MessageIdData) GetFirstChunkMessageId() *MessageIdData {
+	if x != nil {
+		return x.FirstChunkMessageId
 	}
 	return nil
 }
 
 type KeyValue struct {
-	Key                  *string  `protobuf:"bytes,1,req,name=key" json:"key,omitempty"`
-	Value                *string  `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Key   *string `protobuf:"bytes,1,req,name=key" json:"key,omitempty"`
+	Value *string `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
 }
 
-func (m *KeyValue) Reset()         { *m = KeyValue{} }
-func (m *KeyValue) String() string { return proto.CompactTextString(m) }
-func (*KeyValue) ProtoMessage()    {}
-func (*KeyValue) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{2}
-}
-func (m *KeyValue) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *KeyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_KeyValue.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *KeyValue) Reset() {
+	*x = KeyValue{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *KeyValue) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_KeyValue.Merge(m, src)
-}
-func (m *KeyValue) XXX_Size() int {
-	return m.Size()
+
+func (x *KeyValue) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *KeyValue) XXX_DiscardUnknown() {
-	xxx_messageInfo_KeyValue.DiscardUnknown(m)
+
+func (*KeyValue) ProtoMessage() {}
+
+func (x *KeyValue) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_KeyValue proto.InternalMessageInfo
+// Deprecated: Use KeyValue.ProtoReflect.Descriptor instead.
+func (*KeyValue) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{2}
+}
 
-func (m *KeyValue) GetKey() string {
-	if m != nil && m.Key != nil {
-		return *m.Key
+func (x *KeyValue) GetKey() string {
+	if x != nil && x.Key != nil {
+		return *x.Key
 	}
 	return ""
 }
 
-func (m *KeyValue) GetValue() string {
-	if m != nil && m.Value != nil {
-		return *m.Value
+func (x *KeyValue) GetValue() string {
+	if x != nil && x.Value != nil {
+		return *x.Value
 	}
 	return ""
 }
 
 type KeyLongValue struct {
-	Key                  *string  `protobuf:"bytes,1,req,name=key" json:"key,omitempty"`
-	Value                *uint64  `protobuf:"varint,2,req,name=value" json:"value,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Key   *string `protobuf:"bytes,1,req,name=key" json:"key,omitempty"`
+	Value *uint64 `protobuf:"varint,2,req,name=value" json:"value,omitempty"`
 }
 
-func (m *KeyLongValue) Reset()         { *m = KeyLongValue{} }
-func (m *KeyLongValue) String() string { return proto.CompactTextString(m) }
-func (*KeyLongValue) ProtoMessage()    {}
-func (*KeyLongValue) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{3}
-}
-func (m *KeyLongValue) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *KeyLongValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_KeyLongValue.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *KeyLongValue) Reset() {
+	*x = KeyLongValue{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *KeyLongValue) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_KeyLongValue.Merge(m, src)
-}
-func (m *KeyLongValue) XXX_Size() int {
-	return m.Size()
+
+func (x *KeyLongValue) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *KeyLongValue) XXX_DiscardUnknown() {
-	xxx_messageInfo_KeyLongValue.DiscardUnknown(m)
+
+func (*KeyLongValue) ProtoMessage() {}
+
+func (x *KeyLongValue) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_KeyLongValue proto.InternalMessageInfo
+// Deprecated: Use KeyLongValue.ProtoReflect.Descriptor instead.
+func (*KeyLongValue) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{3}
+}
 
-func (m *KeyLongValue) GetKey() string {
-	if m != nil && m.Key != nil {
-		return *m.Key
+func (x *KeyLongValue) GetKey() string {
+	if x != nil && x.Key != nil {
+		return *x.Key
 	}
 	return ""
 }
 
-func (m *KeyLongValue) GetValue() uint64 {
-	if m != nil && m.Value != nil {
-		return *m.Value
+func (x *KeyLongValue) GetValue() uint64 {
+	if x != nil && x.Value != nil {
+		return *x.Value
 	}
 	return 0
 }
 
 type IntRange struct {
-	Start                *int32   `protobuf:"varint,1,req,name=start" json:"start,omitempty"`
-	End                  *int32   `protobuf:"varint,2,req,name=end" json:"end,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Start *int32 `protobuf:"varint,1,req,name=start" json:"start,omitempty"`
+	End   *int32 `protobuf:"varint,2,req,name=end" json:"end,omitempty"`
 }
 
-func (m *IntRange) Reset()         { *m = IntRange{} }
-func (m *IntRange) String() string { return proto.CompactTextString(m) }
-func (*IntRange) ProtoMessage()    {}
-func (*IntRange) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{4}
-}
-func (m *IntRange) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *IntRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_IntRange.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *IntRange) Reset() {
+	*x = IntRange{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *IntRange) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_IntRange.Merge(m, src)
-}
-func (m *IntRange) XXX_Size() int {
-	return m.Size()
+
+func (x *IntRange) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *IntRange) XXX_DiscardUnknown() {
-	xxx_messageInfo_IntRange.DiscardUnknown(m)
+
+func (*IntRange) ProtoMessage() {}
+
+func (x *IntRange) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_IntRange proto.InternalMessageInfo
+// Deprecated: Use IntRange.ProtoReflect.Descriptor instead.
+func (*IntRange) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{4}
+}
 
-func (m *IntRange) GetStart() int32 {
-	if m != nil && m.Start != nil {
-		return *m.Start
+func (x *IntRange) GetStart() int32 {
+	if x != nil && x.Start != nil {
+		return *x.Start
 	}
 	return 0
 }
 
-func (m *IntRange) GetEnd() int32 {
-	if m != nil && m.End != nil {
-		return *m.End
+func (x *IntRange) GetEnd() int32 {
+	if x != nil && x.End != nil {
+		return *x.End
 	}
 	return 0
 }
 
 type EncryptionKeys struct {
-	Key                  *string     `protobuf:"bytes,1,req,name=key" json:"key,omitempty"`
-	Value                []byte      `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
-	Metadata             []*KeyValue `protobuf:"bytes,3,rep,name=metadata" json:"metadata,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
-	XXX_unrecognized     []byte      `json:"-"`
-	XXX_sizecache        int32       `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Key      *string     `protobuf:"bytes,1,req,name=key" json:"key,omitempty"`
+	Value    []byte      `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
+	Metadata []*KeyValue `protobuf:"bytes,3,rep,name=metadata" json:"metadata,omitempty"`
 }
 
-func (m *EncryptionKeys) Reset()         { *m = EncryptionKeys{} }
-func (m *EncryptionKeys) String() string { return proto.CompactTextString(m) }
-func (*EncryptionKeys) ProtoMessage()    {}
-func (*EncryptionKeys) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{5}
-}
-func (m *EncryptionKeys) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *EncryptionKeys) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_EncryptionKeys.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *EncryptionKeys) Reset() {
+	*x = EncryptionKeys{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *EncryptionKeys) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EncryptionKeys.Merge(m, src)
-}
-func (m *EncryptionKeys) XXX_Size() int {
-	return m.Size()
+
+func (x *EncryptionKeys) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *EncryptionKeys) XXX_DiscardUnknown() {
-	xxx_messageInfo_EncryptionKeys.DiscardUnknown(m)
+
+func (*EncryptionKeys) ProtoMessage() {}
+
+func (x *EncryptionKeys) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_EncryptionKeys proto.InternalMessageInfo
+// Deprecated: Use EncryptionKeys.ProtoReflect.Descriptor instead.
+func (*EncryptionKeys) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{5}
+}
 
-func (m *EncryptionKeys) GetKey() string {
-	if m != nil && m.Key != nil {
-		return *m.Key
+func (x *EncryptionKeys) GetKey() string {
+	if x != nil && x.Key != nil {
+		return *x.Key
 	}
 	return ""
 }
 
-func (m *EncryptionKeys) GetValue() []byte {
-	if m != nil {
-		return m.Value
+func (x *EncryptionKeys) GetValue() []byte {
+	if x != nil {
+		return x.Value
 	}
 	return nil
 }
 
-func (m *EncryptionKeys) GetMetadata() []*KeyValue {
-	if m != nil {
-		return m.Metadata
+func (x *EncryptionKeys) GetMetadata() []*KeyValue {
+	if x != nil {
+		return x.Metadata
 	}
 	return nil
 }
 
 type MessageMetadata struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	ProducerName *string     `protobuf:"bytes,1,req,name=producer_name,json=producerName" json:"producer_name,omitempty"`
 	SequenceId   *uint64     `protobuf:"varint,2,req,name=sequence_id,json=sequenceId" json:"sequence_id,omitempty"`
 	PublishTime  *uint64     `protobuf:"varint,3,req,name=publish_time,json=publishTime" json:"publish_time,omitempty"`
@@ -1509,251 +1786,254 @@ type MessageMetadata struct {
 	TotalChunkMsgSize *int32  `protobuf:"varint,28,opt,name=total_chunk_msg_size,json=totalChunkMsgSize" json:"total_chunk_msg_size,omitempty"`
 	ChunkId           *int32  `protobuf:"varint,29,opt,name=chunk_id,json=chunkId" json:"chunk_id,omitempty"`
 	// Indicate if the message partition key is set
-	NullPartitionKey     *bool    `protobuf:"varint,30,opt,name=null_partition_key,json=nullPartitionKey,def=0" json:"null_partition_key,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	NullPartitionKey *bool `protobuf:"varint,30,opt,name=null_partition_key,json=nullPartitionKey,def=0" json:"null_partition_key,omitempty"`
 }
 
-func (m *MessageMetadata) Reset()         { *m = MessageMetadata{} }
-func (m *MessageMetadata) String() string { return proto.CompactTextString(m) }
-func (*MessageMetadata) ProtoMessage()    {}
-func (*MessageMetadata) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{6}
-}
-func (m *MessageMetadata) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *MessageMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_MessageMetadata.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for MessageMetadata fields.
+const (
+	Default_MessageMetadata_Compression            = CompressionType_NONE
+	Default_MessageMetadata_UncompressedSize       = uint32(0)
+	Default_MessageMetadata_NumMessagesInBatch     = int32(1)
+	Default_MessageMetadata_EventTime              = uint64(0)
+	Default_MessageMetadata_PartitionKeyB64Encoded = bool(false)
+	Default_MessageMetadata_HighestSequenceId      = uint64(0)
+	Default_MessageMetadata_NullValue              = bool(false)
+	Default_MessageMetadata_NullPartitionKey       = bool(false)
+)
+
+func (x *MessageMetadata) Reset() {
+	*x = MessageMetadata{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *MessageMetadata) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MessageMetadata.Merge(m, src)
-}
-func (m *MessageMetadata) XXX_Size() int {
-	return m.Size()
-}
-func (m *MessageMetadata) XXX_DiscardUnknown() {
-	xxx_messageInfo_MessageMetadata.DiscardUnknown(m)
+
+func (x *MessageMetadata) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_MessageMetadata proto.InternalMessageInfo
+func (*MessageMetadata) ProtoMessage() {}
+
+func (x *MessageMetadata) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_MessageMetadata_Compression CompressionType = CompressionType_NONE
-const Default_MessageMetadata_UncompressedSize uint32 = 0
-const Default_MessageMetadata_NumMessagesInBatch int32 = 1
-const Default_MessageMetadata_EventTime uint64 = 0
-const Default_MessageMetadata_PartitionKeyB64Encoded bool = false
-const Default_MessageMetadata_HighestSequenceId uint64 = 0
-const Default_MessageMetadata_NullValue bool = false
-const Default_MessageMetadata_NullPartitionKey bool = false
+// Deprecated: Use MessageMetadata.ProtoReflect.Descriptor instead.
+func (*MessageMetadata) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{6}
+}
 
-func (m *MessageMetadata) GetProducerName() string {
-	if m != nil && m.ProducerName != nil {
-		return *m.ProducerName
+func (x *MessageMetadata) GetProducerName() string {
+	if x != nil && x.ProducerName != nil {
+		return *x.ProducerName
 	}
 	return ""
 }
 
-func (m *MessageMetadata) GetSequenceId() uint64 {
-	if m != nil && m.SequenceId != nil {
-		return *m.SequenceId
+func (x *MessageMetadata) GetSequenceId() uint64 {
+	if x != nil && x.SequenceId != nil {
+		return *x.SequenceId
 	}
 	return 0
 }
 
-func (m *MessageMetadata) GetPublishTime() uint64 {
-	if m != nil && m.PublishTime != nil {
-		return *m.PublishTime
+func (x *MessageMetadata) GetPublishTime() uint64 {
+	if x != nil && x.PublishTime != nil {
+		return *x.PublishTime
 	}
 	return 0
 }
 
-func (m *MessageMetadata) GetProperties() []*KeyValue {
-	if m != nil {
-		return m.Properties
+func (x *MessageMetadata) GetProperties() []*KeyValue {
+	if x != nil {
+		return x.Properties
 	}
 	return nil
 }
 
-func (m *MessageMetadata) GetReplicatedFrom() string {
-	if m != nil && m.ReplicatedFrom != nil {
-		return *m.ReplicatedFrom
+func (x *MessageMetadata) GetReplicatedFrom() string {
+	if x != nil && x.ReplicatedFrom != nil {
+		return *x.ReplicatedFrom
 	}
 	return ""
 }
 
-func (m *MessageMetadata) GetPartitionKey() string {
-	if m != nil && m.PartitionKey != nil {
-		return *m.PartitionKey
+func (x *MessageMetadata) GetPartitionKey() string {
+	if x != nil && x.PartitionKey != nil {
+		return *x.PartitionKey
 	}
 	return ""
 }
 
-func (m *MessageMetadata) GetReplicateTo() []string {
-	if m != nil {
-		return m.ReplicateTo
+func (x *MessageMetadata) GetReplicateTo() []string {
+	if x != nil {
+		return x.ReplicateTo
 	}
 	return nil
 }
 
-func (m *MessageMetadata) GetCompression() CompressionType {
-	if m != nil && m.Compression != nil {
-		return *m.Compression
+func (x *MessageMetadata) GetCompression() CompressionType {
+	if x != nil && x.Compression != nil {
+		return *x.Compression
 	}
 	return Default_MessageMetadata_Compression
 }
 
-func (m *MessageMetadata) GetUncompressedSize() uint32 {
-	if m != nil && m.UncompressedSize != nil {
-		return *m.UncompressedSize
+func (x *MessageMetadata) GetUncompressedSize() uint32 {
+	if x != nil && x.UncompressedSize != nil {
+		return *x.UncompressedSize
 	}
 	return Default_MessageMetadata_UncompressedSize
 }
 
-func (m *MessageMetadata) GetNumMessagesInBatch() int32 {
-	if m != nil && m.NumMessagesInBatch != nil {
-		return *m.NumMessagesInBatch
+func (x *MessageMetadata) GetNumMessagesInBatch() int32 {
+	if x != nil && x.NumMessagesInBatch != nil {
+		return *x.NumMessagesInBatch
 	}
 	return Default_MessageMetadata_NumMessagesInBatch
 }
 
-func (m *MessageMetadata) GetEventTime() uint64 {
-	if m != nil && m.EventTime != nil {
-		return *m.EventTime
+func (x *MessageMetadata) GetEventTime() uint64 {
+	if x != nil && x.EventTime != nil {
+		return *x.EventTime
 	}
 	return Default_MessageMetadata_EventTime
 }
 
-func (m *MessageMetadata) GetEncryptionKeys() []*EncryptionKeys {
-	if m != nil {
-		return m.EncryptionKeys
+func (x *MessageMetadata) GetEncryptionKeys() []*EncryptionKeys {
+	if x != nil {
+		return x.EncryptionKeys
 	}
 	return nil
 }
 
-func (m *MessageMetadata) GetEncryptionAlgo() string {
-	if m != nil && m.EncryptionAlgo != nil {
-		return *m.EncryptionAlgo
+func (x *MessageMetadata) GetEncryptionAlgo() string {
+	if x != nil && x.EncryptionAlgo != nil {
+		return *x.EncryptionAlgo
 	}
 	return ""
 }
 
-func (m *MessageMetadata) GetEncryptionParam() []byte {
-	if m != nil {
-		return m.EncryptionParam
+func (x *MessageMetadata) GetEncryptionParam() []byte {
+	if x != nil {
+		return x.EncryptionParam
 	}
 	return nil
 }
 
-func (m *MessageMetadata) GetSchemaVersion() []byte {
-	if m != nil {
-		return m.SchemaVersion
+func (x *MessageMetadata) GetSchemaVersion() []byte {
+	if x != nil {
+		return x.SchemaVersion
 	}
 	return nil
 }
 
-func (m *MessageMetadata) GetPartitionKeyB64Encoded() bool {
-	if m != nil && m.PartitionKeyB64Encoded != nil {
-		return *m.PartitionKeyB64Encoded
+func (x *MessageMetadata) GetPartitionKeyB64Encoded() bool {
+	if x != nil && x.PartitionKeyB64Encoded != nil {
+		return *x.PartitionKeyB64Encoded
 	}
 	return Default_MessageMetadata_PartitionKeyB64Encoded
 }
 
-func (m *MessageMetadata) GetOrderingKey() []byte {
-	if m != nil {
-		return m.OrderingKey
+func (x *MessageMetadata) GetOrderingKey() []byte {
+	if x != nil {
+		return x.OrderingKey
 	}
 	return nil
 }
 
-func (m *MessageMetadata) GetDeliverAtTime() int64 {
-	if m != nil && m.DeliverAtTime != nil {
-		return *m.DeliverAtTime
+func (x *MessageMetadata) GetDeliverAtTime() int64 {
+	if x != nil && x.DeliverAtTime != nil {
+		return *x.DeliverAtTime
 	}
 	return 0
 }
 
-func (m *MessageMetadata) GetMarkerType() int32 {
-	if m != nil && m.MarkerType != nil {
-		return *m.MarkerType
+func (x *MessageMetadata) GetMarkerType() int32 {
+	if x != nil && x.MarkerType != nil {
+		return *x.MarkerType
 	}
 	return 0
 }
 
-func (m *MessageMetadata) GetTxnidLeastBits() uint64 {
-	if m != nil && m.TxnidLeastBits != nil {
-		return *m.TxnidLeastBits
+func (x *MessageMetadata) GetTxnidLeastBits() uint64 {
+	if x != nil && x.TxnidLeastBits != nil {
+		return *x.TxnidLeastBits
 	}
 	return 0
 }
 
-func (m *MessageMetadata) GetTxnidMostBits() uint64 {
-	if m != nil && m.TxnidMostBits != nil {
-		return *m.TxnidMostBits
+func (x *MessageMetadata) GetTxnidMostBits() uint64 {
+	if x != nil && x.TxnidMostBits != nil {
+		return *x.TxnidMostBits
 	}
 	return 0
 }
 
-func (m *MessageMetadata) GetHighestSequenceId() uint64 {
-	if m != nil && m.HighestSequenceId != nil {
-		return *m.HighestSequenceId
+func (x *MessageMetadata) GetHighestSequenceId() uint64 {
+	if x != nil && x.HighestSequenceId != nil {
+		return *x.HighestSequenceId
 	}
 	return Default_MessageMetadata_HighestSequenceId
 }
 
-func (m *MessageMetadata) GetNullValue() bool {
-	if m != nil && m.NullValue != nil {
-		return *m.NullValue
+func (x *MessageMetadata) GetNullValue() bool {
+	if x != nil && x.NullValue != nil {
+		return *x.NullValue
 	}
 	return Default_MessageMetadata_NullValue
 }
 
-func (m *MessageMetadata) GetUuid() string {
-	if m != nil && m.Uuid != nil {
-		return *m.Uuid
+func (x *MessageMetadata) GetUuid() string {
+	if x != nil && x.Uuid != nil {
+		return *x.Uuid
 	}
 	return ""
 }
 
-func (m *MessageMetadata) GetNumChunksFromMsg() int32 {
-	if m != nil && m.NumChunksFromMsg != nil {
-		return *m.NumChunksFromMsg
+func (x *MessageMetadata) GetNumChunksFromMsg() int32 {
+	if x != nil && x.NumChunksFromMsg != nil {
+		return *x.NumChunksFromMsg
 	}
 	return 0
 }
 
-func (m *MessageMetadata) GetTotalChunkMsgSize() int32 {
-	if m != nil && m.TotalChunkMsgSize != nil {
-		return *m.TotalChunkMsgSize
+func (x *MessageMetadata) GetTotalChunkMsgSize() int32 {
+	if x != nil && x.TotalChunkMsgSize != nil {
+		return *x.TotalChunkMsgSize
 	}
 	return 0
 }
 
-func (m *MessageMetadata) GetChunkId() int32 {
-	if m != nil && m.ChunkId != nil {
-		return *m.ChunkId
+func (x *MessageMetadata) GetChunkId() int32 {
+	if x != nil && x.ChunkId != nil {
+		return *x.ChunkId
 	}
 	return 0
 }
 
-func (m *MessageMetadata) GetNullPartitionKey() bool {
-	if m != nil && m.NullPartitionKey != nil {
-		return *m.NullPartitionKey
+func (x *MessageMetadata) GetNullPartitionKey() bool {
+	if x != nil && x.NullPartitionKey != nil {
+		return *x.NullPartitionKey
 	}
 	return Default_MessageMetadata_NullPartitionKey
 }
 
 type SingleMessageMetadata struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	Properties   []*KeyValue `protobuf:"bytes,1,rep,name=properties" json:"properties,omitempty"`
 	PartitionKey *string     `protobuf:"bytes,2,opt,name=partition_key,json=partitionKey" json:"partition_key,omitempty"`
 	PayloadSize  *int32      `protobuf:"varint,3,req,name=payload_size,json=payloadSize" json:"payload_size,omitempty"`
@@ -1769,180 +2049,183 @@ type SingleMessageMetadata struct {
 	// Indicate if the message payload value is set
 	NullValue *bool `protobuf:"varint,9,opt,name=null_value,json=nullValue,def=0" json:"null_value,omitempty"`
 	// Indicate if the message partition key is set
-	NullPartitionKey     *bool    `protobuf:"varint,10,opt,name=null_partition_key,json=nullPartitionKey,def=0" json:"null_partition_key,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	NullPartitionKey *bool `protobuf:"varint,10,opt,name=null_partition_key,json=nullPartitionKey,def=0" json:"null_partition_key,omitempty"`
 }
 
-func (m *SingleMessageMetadata) Reset()         { *m = SingleMessageMetadata{} }
-func (m *SingleMessageMetadata) String() string { return proto.CompactTextString(m) }
-func (*SingleMessageMetadata) ProtoMessage()    {}
-func (*SingleMessageMetadata) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{7}
-}
-func (m *SingleMessageMetadata) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *SingleMessageMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_SingleMessageMetadata.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for SingleMessageMetadata fields.
+const (
+	Default_SingleMessageMetadata_CompactedOut           = bool(false)
+	Default_SingleMessageMetadata_EventTime              = uint64(0)
+	Default_SingleMessageMetadata_PartitionKeyB64Encoded = bool(false)
+	Default_SingleMessageMetadata_NullValue              = bool(false)
+	Default_SingleMessageMetadata_NullPartitionKey       = bool(false)
+)
+
+func (x *SingleMessageMetadata) Reset() {
+	*x = SingleMessageMetadata{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *SingleMessageMetadata) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SingleMessageMetadata.Merge(m, src)
-}
-func (m *SingleMessageMetadata) XXX_Size() int {
-	return m.Size()
-}
-func (m *SingleMessageMetadata) XXX_DiscardUnknown() {
-	xxx_messageInfo_SingleMessageMetadata.DiscardUnknown(m)
+
+func (x *SingleMessageMetadata) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_SingleMessageMetadata proto.InternalMessageInfo
+func (*SingleMessageMetadata) ProtoMessage() {}
+
+func (x *SingleMessageMetadata) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_SingleMessageMetadata_CompactedOut bool = false
-const Default_SingleMessageMetadata_EventTime uint64 = 0
-const Default_SingleMessageMetadata_PartitionKeyB64Encoded bool = false
-const Default_SingleMessageMetadata_NullValue bool = false
-const Default_SingleMessageMetadata_NullPartitionKey bool = false
+// Deprecated: Use SingleMessageMetadata.ProtoReflect.Descriptor instead.
+func (*SingleMessageMetadata) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{7}
+}
 
-func (m *SingleMessageMetadata) GetProperties() []*KeyValue {
-	if m != nil {
-		return m.Properties
+func (x *SingleMessageMetadata) GetProperties() []*KeyValue {
+	if x != nil {
+		return x.Properties
 	}
 	return nil
 }
 
-func (m *SingleMessageMetadata) GetPartitionKey() string {
-	if m != nil && m.PartitionKey != nil {
-		return *m.PartitionKey
+func (x *SingleMessageMetadata) GetPartitionKey() string {
+	if x != nil && x.PartitionKey != nil {
+		return *x.PartitionKey
 	}
 	return ""
 }
 
-func (m *SingleMessageMetadata) GetPayloadSize() int32 {
-	if m != nil && m.PayloadSize != nil {
-		return *m.PayloadSize
+func (x *SingleMessageMetadata) GetPayloadSize() int32 {
+	if x != nil && x.PayloadSize != nil {
+		return *x.PayloadSize
 	}
 	return 0
 }
 
-func (m *SingleMessageMetadata) GetCompactedOut() bool {
-	if m != nil && m.CompactedOut != nil {
-		return *m.CompactedOut
+func (x *SingleMessageMetadata) GetCompactedOut() bool {
+	if x != nil && x.CompactedOut != nil {
+		return *x.CompactedOut
 	}
 	return Default_SingleMessageMetadata_CompactedOut
 }
 
-func (m *SingleMessageMetadata) GetEventTime() uint64 {
-	if m != nil && m.EventTime != nil {
-		return *m.EventTime
+func (x *SingleMessageMetadata) GetEventTime() uint64 {
+	if x != nil && x.EventTime != nil {
+		return *x.EventTime
 	}
 	return Default_SingleMessageMetadata_EventTime
 }
 
-func (m *SingleMessageMetadata) GetPartitionKeyB64Encoded() bool {
-	if m != nil && m.PartitionKeyB64Encoded != nil {
-		return *m.PartitionKeyB64Encoded
+func (x *SingleMessageMetadata) GetPartitionKeyB64Encoded() bool {
+	if x != nil && x.PartitionKeyB64Encoded != nil {
+		return *x.PartitionKeyB64Encoded
 	}
 	return Default_SingleMessageMetadata_PartitionKeyB64Encoded
 }
 
-func (m *SingleMessageMetadata) GetOrderingKey() []byte {
-	if m != nil {
-		return m.OrderingKey
+func (x *SingleMessageMetadata) GetOrderingKey() []byte {
+	if x != nil {
+		return x.OrderingKey
 	}
 	return nil
 }
 
-func (m *SingleMessageMetadata) GetSequenceId() uint64 {
-	if m != nil && m.SequenceId != nil {
-		return *m.SequenceId
+func (x *SingleMessageMetadata) GetSequenceId() uint64 {
+	if x != nil && x.SequenceId != nil {
+		return *x.SequenceId
 	}
 	return 0
 }
 
-func (m *SingleMessageMetadata) GetNullValue() bool {
-	if m != nil && m.NullValue != nil {
-		return *m.NullValue
+func (x *SingleMessageMetadata) GetNullValue() bool {
+	if x != nil && x.NullValue != nil {
+		return *x.NullValue
 	}
 	return Default_SingleMessageMetadata_NullValue
 }
 
-func (m *SingleMessageMetadata) GetNullPartitionKey() bool {
-	if m != nil && m.NullPartitionKey != nil {
-		return *m.NullPartitionKey
+func (x *SingleMessageMetadata) GetNullPartitionKey() bool {
+	if x != nil && x.NullPartitionKey != nil {
+		return *x.NullPartitionKey
 	}
 	return Default_SingleMessageMetadata_NullPartitionKey
 }
 
 // metadata added for entry from broker
 type BrokerEntryMetadata struct {
-	BrokerTimestamp      *uint64  `protobuf:"varint,1,opt,name=broker_timestamp,json=brokerTimestamp" json:"broker_timestamp,omitempty"`
-	Index                *uint64  `protobuf:"varint,2,opt,name=index" json:"index,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	BrokerTimestamp *uint64 `protobuf:"varint,1,opt,name=broker_timestamp,json=brokerTimestamp" json:"broker_timestamp,omitempty"`
+	Index           *uint64 `protobuf:"varint,2,opt,name=index" json:"index,omitempty"`
 }
 
-func (m *BrokerEntryMetadata) Reset()         { *m = BrokerEntryMetadata{} }
-func (m *BrokerEntryMetadata) String() string { return proto.CompactTextString(m) }
-func (*BrokerEntryMetadata) ProtoMessage()    {}
-func (*BrokerEntryMetadata) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{8}
-}
-func (m *BrokerEntryMetadata) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *BrokerEntryMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_BrokerEntryMetadata.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *BrokerEntryMetadata) Reset() {
+	*x = BrokerEntryMetadata{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *BrokerEntryMetadata) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BrokerEntryMetadata.Merge(m, src)
-}
-func (m *BrokerEntryMetadata) XXX_Size() int {
-	return m.Size()
+
+func (x *BrokerEntryMetadata) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *BrokerEntryMetadata) XXX_DiscardUnknown() {
-	xxx_messageInfo_BrokerEntryMetadata.DiscardUnknown(m)
+
+func (*BrokerEntryMetadata) ProtoMessage() {}
+
+func (x *BrokerEntryMetadata) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_BrokerEntryMetadata proto.InternalMessageInfo
+// Deprecated: Use BrokerEntryMetadata.ProtoReflect.Descriptor instead.
+func (*BrokerEntryMetadata) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{8}
+}
 
-func (m *BrokerEntryMetadata) GetBrokerTimestamp() uint64 {
-	if m != nil && m.BrokerTimestamp != nil {
-		return *m.BrokerTimestamp
+func (x *BrokerEntryMetadata) GetBrokerTimestamp() uint64 {
+	if x != nil && x.BrokerTimestamp != nil {
+		return *x.BrokerTimestamp
 	}
 	return 0
 }
 
-func (m *BrokerEntryMetadata) GetIndex() uint64 {
-	if m != nil && m.Index != nil {
-		return *m.Index
+func (x *BrokerEntryMetadata) GetIndex() uint64 {
+	if x != nil && x.Index != nil {
+		return *x.Index
 	}
 	return 0
 }
 
 type CommandConnect struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	ClientVersion   *string     `protobuf:"bytes,1,req,name=client_version,json=clientVersion" json:"client_version,omitempty"`
-	AuthMethod      *AuthMethod `protobuf:"varint,2,opt,name=auth_method,json=authMethod,enum=pulsar.proto.AuthMethod" json:"auth_method,omitempty"`
+	AuthMethod      *AuthMethod `protobuf:"varint,2,opt,name=auth_method,json=authMethod,enum=pulsar.proto.AuthMethod" json:"auth_method,omitempty"` // Deprecated. Use "auth_method_name" instead.
 	AuthMethodName  *string     `protobuf:"bytes,5,opt,name=auth_method_name,json=authMethodName" json:"auth_method_name,omitempty"`
 	AuthData        []byte      `protobuf:"bytes,3,opt,name=auth_data,json=authData" json:"auth_data,omitempty"`
 	ProtocolVersion *int32      `protobuf:"varint,4,opt,name=protocol_version,json=protocolVersion,def=0" json:"protocol_version,omitempty"`
@@ -1959,518 +2242,536 @@ type CommandConnect struct {
 	OriginalAuthData   *string `protobuf:"bytes,8,opt,name=original_auth_data,json=originalAuthData" json:"original_auth_data,omitempty"`
 	OriginalAuthMethod *string `protobuf:"bytes,9,opt,name=original_auth_method,json=originalAuthMethod" json:"original_auth_method,omitempty"`
 	// Feature flags
-	FeatureFlags         *FeatureFlags `protobuf:"bytes,10,opt,name=feature_flags,json=featureFlags" json:"feature_flags,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
-	XXX_unrecognized     []byte        `json:"-"`
-	XXX_sizecache        int32         `json:"-"`
+	FeatureFlags *FeatureFlags `protobuf:"bytes,10,opt,name=feature_flags,json=featureFlags" json:"feature_flags,omitempty"`
 }
 
-func (m *CommandConnect) Reset()         { *m = CommandConnect{} }
-func (m *CommandConnect) String() string { return proto.CompactTextString(m) }
-func (*CommandConnect) ProtoMessage()    {}
-func (*CommandConnect) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{9}
-}
-func (m *CommandConnect) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandConnect) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandConnect.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for CommandConnect fields.
+const (
+	Default_CommandConnect_ProtocolVersion = int32(0)
+)
+
+func (x *CommandConnect) Reset() {
+	*x = CommandConnect{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandConnect) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandConnect.Merge(m, src)
-}
-func (m *CommandConnect) XXX_Size() int {
-	return m.Size()
-}
-func (m *CommandConnect) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandConnect.DiscardUnknown(m)
+
+func (x *CommandConnect) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandConnect proto.InternalMessageInfo
+func (*CommandConnect) ProtoMessage() {}
+
+func (x *CommandConnect) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandConnect_ProtocolVersion int32 = 0
+// Deprecated: Use CommandConnect.ProtoReflect.Descriptor instead.
+func (*CommandConnect) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{9}
+}
 
-func (m *CommandConnect) GetClientVersion() string {
-	if m != nil && m.ClientVersion != nil {
-		return *m.ClientVersion
+func (x *CommandConnect) GetClientVersion() string {
+	if x != nil && x.ClientVersion != nil {
+		return *x.ClientVersion
 	}
 	return ""
 }
 
-func (m *CommandConnect) GetAuthMethod() AuthMethod {
-	if m != nil && m.AuthMethod != nil {
-		return *m.AuthMethod
+func (x *CommandConnect) GetAuthMethod() AuthMethod {
+	if x != nil && x.AuthMethod != nil {
+		return *x.AuthMethod
 	}
 	return AuthMethod_AuthMethodNone
 }
 
-func (m *CommandConnect) GetAuthMethodName() string {
-	if m != nil && m.AuthMethodName != nil {
-		return *m.AuthMethodName
+func (x *CommandConnect) GetAuthMethodName() string {
+	if x != nil && x.AuthMethodName != nil {
+		return *x.AuthMethodName
 	}
 	return ""
 }
 
-func (m *CommandConnect) GetAuthData() []byte {
-	if m != nil {
-		return m.AuthData
+func (x *CommandConnect) GetAuthData() []byte {
+	if x != nil {
+		return x.AuthData
 	}
 	return nil
 }
 
-func (m *CommandConnect) GetProtocolVersion() int32 {
-	if m != nil && m.ProtocolVersion != nil {
-		return *m.ProtocolVersion
+func (x *CommandConnect) GetProtocolVersion() int32 {
+	if x != nil && x.ProtocolVersion != nil {
+		return *x.ProtocolVersion
 	}
 	return Default_CommandConnect_ProtocolVersion
 }
 
-func (m *CommandConnect) GetProxyToBrokerUrl() string {
-	if m != nil && m.ProxyToBrokerUrl != nil {
-		return *m.ProxyToBrokerUrl
+func (x *CommandConnect) GetProxyToBrokerUrl() string {
+	if x != nil && x.ProxyToBrokerUrl != nil {
+		return *x.ProxyToBrokerUrl
 	}
 	return ""
 }
 
-func (m *CommandConnect) GetOriginalPrincipal() string {
-	if m != nil && m.OriginalPrincipal != nil {
-		return *m.OriginalPrincipal
+func (x *CommandConnect) GetOriginalPrincipal() string {
+	if x != nil && x.OriginalPrincipal != nil {
+		return *x.OriginalPrincipal
 	}
 	return ""
 }
 
-func (m *CommandConnect) GetOriginalAuthData() string {
-	if m != nil && m.OriginalAuthData != nil {
-		return *m.OriginalAuthData
+func (x *CommandConnect) GetOriginalAuthData() string {
+	if x != nil && x.OriginalAuthData != nil {
+		return *x.OriginalAuthData
 	}
 	return ""
 }
 
-func (m *CommandConnect) GetOriginalAuthMethod() string {
-	if m != nil && m.OriginalAuthMethod != nil {
-		return *m.OriginalAuthMethod
+func (x *CommandConnect) GetOriginalAuthMethod() string {
+	if x != nil && x.OriginalAuthMethod != nil {
+		return *x.OriginalAuthMethod
 	}
 	return ""
 }
 
-func (m *CommandConnect) GetFeatureFlags() *FeatureFlags {
-	if m != nil {
-		return m.FeatureFlags
+func (x *CommandConnect) GetFeatureFlags() *FeatureFlags {
+	if x != nil {
+		return x.FeatureFlags
 	}
 	return nil
 }
 
 type FeatureFlags struct {
-	SupportsAuthRefresh         *bool    `protobuf:"varint,1,opt,name=supports_auth_refresh,json=supportsAuthRefresh,def=0" json:"supports_auth_refresh,omitempty"`
-	SupportsBrokerEntryMetadata *bool    `protobuf:"varint,2,opt,name=supports_broker_entry_metadata,json=supportsBrokerEntryMetadata,def=0" json:"supports_broker_entry_metadata,omitempty"`
-	SupportsPartialProducer     *bool    `protobuf:"varint,3,opt,name=supports_partial_producer,json=supportsPartialProducer,def=0" json:"supports_partial_producer,omitempty"`
-	SupportsTopicWatchers       *bool    `protobuf:"varint,4,opt,name=supports_topic_watchers,json=supportsTopicWatchers,def=0" json:"supports_topic_watchers,omitempty"`
-	XXX_NoUnkeyedLiteral        struct{} `json:"-"`
-	XXX_unrecognized            []byte   `json:"-"`
-	XXX_sizecache               int32    `json:"-"`
-}
-
-func (m *FeatureFlags) Reset()         { *m = FeatureFlags{} }
-func (m *FeatureFlags) String() string { return proto.CompactTextString(m) }
-func (*FeatureFlags) ProtoMessage()    {}
-func (*FeatureFlags) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{10}
-}
-func (m *FeatureFlags) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *FeatureFlags) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_FeatureFlags.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *FeatureFlags) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FeatureFlags.Merge(m, src)
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	SupportsAuthRefresh         *bool `protobuf:"varint,1,opt,name=supports_auth_refresh,json=supportsAuthRefresh,def=0" json:"supports_auth_refresh,omitempty"`
+	SupportsBrokerEntryMetadata *bool `protobuf:"varint,2,opt,name=supports_broker_entry_metadata,json=supportsBrokerEntryMetadata,def=0" json:"supports_broker_entry_metadata,omitempty"`
+	SupportsPartialProducer     *bool `protobuf:"varint,3,opt,name=supports_partial_producer,json=supportsPartialProducer,def=0" json:"supports_partial_producer,omitempty"`
+	SupportsTopicWatchers       *bool `protobuf:"varint,4,opt,name=supports_topic_watchers,json=supportsTopicWatchers,def=0" json:"supports_topic_watchers,omitempty"`
 }
-func (m *FeatureFlags) XXX_Size() int {
-	return m.Size()
+
+// Default values for FeatureFlags fields.
+const (
+	Default_FeatureFlags_SupportsAuthRefresh         = bool(false)
+	Default_FeatureFlags_SupportsBrokerEntryMetadata = bool(false)
+	Default_FeatureFlags_SupportsPartialProducer     = bool(false)
+	Default_FeatureFlags_SupportsTopicWatchers       = bool(false)
+)
+
+func (x *FeatureFlags) Reset() {
+	*x = FeatureFlags{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *FeatureFlags) XXX_DiscardUnknown() {
-	xxx_messageInfo_FeatureFlags.DiscardUnknown(m)
+
+func (x *FeatureFlags) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_FeatureFlags proto.InternalMessageInfo
+func (*FeatureFlags) ProtoMessage() {}
+
+func (x *FeatureFlags) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_FeatureFlags_SupportsAuthRefresh bool = false
-const Default_FeatureFlags_SupportsBrokerEntryMetadata bool = false
-const Default_FeatureFlags_SupportsPartialProducer bool = false
-const Default_FeatureFlags_SupportsTopicWatchers bool = false
+// Deprecated: Use FeatureFlags.ProtoReflect.Descriptor instead.
+func (*FeatureFlags) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{10}
+}
 
-func (m *FeatureFlags) GetSupportsAuthRefresh() bool {
-	if m != nil && m.SupportsAuthRefresh != nil {
-		return *m.SupportsAuthRefresh
+func (x *FeatureFlags) GetSupportsAuthRefresh() bool {
+	if x != nil && x.SupportsAuthRefresh != nil {
+		return *x.SupportsAuthRefresh
 	}
 	return Default_FeatureFlags_SupportsAuthRefresh
 }
 
-func (m *FeatureFlags) GetSupportsBrokerEntryMetadata() bool {
-	if m != nil && m.SupportsBrokerEntryMetadata != nil {
-		return *m.SupportsBrokerEntryMetadata
+func (x *FeatureFlags) GetSupportsBrokerEntryMetadata() bool {
+	if x != nil && x.SupportsBrokerEntryMetadata != nil {
+		return *x.SupportsBrokerEntryMetadata
 	}
 	return Default_FeatureFlags_SupportsBrokerEntryMetadata
 }
 
-func (m *FeatureFlags) GetSupportsPartialProducer() bool {
-	if m != nil && m.SupportsPartialProducer != nil {
-		return *m.SupportsPartialProducer
+func (x *FeatureFlags) GetSupportsPartialProducer() bool {
+	if x != nil && x.SupportsPartialProducer != nil {
+		return *x.SupportsPartialProducer
 	}
 	return Default_FeatureFlags_SupportsPartialProducer
 }
 
-func (m *FeatureFlags) GetSupportsTopicWatchers() bool {
-	if m != nil && m.SupportsTopicWatchers != nil {
-		return *m.SupportsTopicWatchers
+func (x *FeatureFlags) GetSupportsTopicWatchers() bool {
+	if x != nil && x.SupportsTopicWatchers != nil {
+		return *x.SupportsTopicWatchers
 	}
 	return Default_FeatureFlags_SupportsTopicWatchers
 }
 
 type CommandConnected struct {
-	ServerVersion        *string       `protobuf:"bytes,1,req,name=server_version,json=serverVersion" json:"server_version,omitempty"`
-	ProtocolVersion      *int32        `protobuf:"varint,2,opt,name=protocol_version,json=protocolVersion,def=0" json:"protocol_version,omitempty"`
-	MaxMessageSize       *int32        `protobuf:"varint,3,opt,name=max_message_size,json=maxMessageSize" json:"max_message_size,omitempty"`
-	FeatureFlags         *FeatureFlags `protobuf:"bytes,4,opt,name=feature_flags,json=featureFlags" json:"feature_flags,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
-	XXX_unrecognized     []byte        `json:"-"`
-	XXX_sizecache        int32         `json:"-"`
-}
-
-func (m *CommandConnected) Reset()         { *m = CommandConnected{} }
-func (m *CommandConnected) String() string { return proto.CompactTextString(m) }
-func (*CommandConnected) ProtoMessage()    {}
-func (*CommandConnected) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{11}
-}
-func (m *CommandConnected) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandConnected) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandConnected.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *CommandConnected) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandConnected.Merge(m, src)
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ServerVersion   *string       `protobuf:"bytes,1,req,name=server_version,json=serverVersion" json:"server_version,omitempty"`
+	ProtocolVersion *int32        `protobuf:"varint,2,opt,name=protocol_version,json=protocolVersion,def=0" json:"protocol_version,omitempty"`
+	MaxMessageSize  *int32        `protobuf:"varint,3,opt,name=max_message_size,json=maxMessageSize" json:"max_message_size,omitempty"`
+	FeatureFlags    *FeatureFlags `protobuf:"bytes,4,opt,name=feature_flags,json=featureFlags" json:"feature_flags,omitempty"`
 }
-func (m *CommandConnected) XXX_Size() int {
-	return m.Size()
+
+// Default values for CommandConnected fields.
+const (
+	Default_CommandConnected_ProtocolVersion = int32(0)
+)
+
+func (x *CommandConnected) Reset() {
+	*x = CommandConnected{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *CommandConnected) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandConnected.DiscardUnknown(m)
+
+func (x *CommandConnected) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandConnected proto.InternalMessageInfo
+func (*CommandConnected) ProtoMessage() {}
+
+func (x *CommandConnected) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandConnected_ProtocolVersion int32 = 0
+// Deprecated: Use CommandConnected.ProtoReflect.Descriptor instead.
+func (*CommandConnected) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{11}
+}
 
-func (m *CommandConnected) GetServerVersion() string {
-	if m != nil && m.ServerVersion != nil {
-		return *m.ServerVersion
+func (x *CommandConnected) GetServerVersion() string {
+	if x != nil && x.ServerVersion != nil {
+		return *x.ServerVersion
 	}
 	return ""
 }
 
-func (m *CommandConnected) GetProtocolVersion() int32 {
-	if m != nil && m.ProtocolVersion != nil {
-		return *m.ProtocolVersion
+func (x *CommandConnected) GetProtocolVersion() int32 {
+	if x != nil && x.ProtocolVersion != nil {
+		return *x.ProtocolVersion
 	}
 	return Default_CommandConnected_ProtocolVersion
 }
 
-func (m *CommandConnected) GetMaxMessageSize() int32 {
-	if m != nil && m.MaxMessageSize != nil {
-		return *m.MaxMessageSize
+func (x *CommandConnected) GetMaxMessageSize() int32 {
+	if x != nil && x.MaxMessageSize != nil {
+		return *x.MaxMessageSize
 	}
 	return 0
 }
 
-func (m *CommandConnected) GetFeatureFlags() *FeatureFlags {
-	if m != nil {
-		return m.FeatureFlags
+func (x *CommandConnected) GetFeatureFlags() *FeatureFlags {
+	if x != nil {
+		return x.FeatureFlags
 	}
 	return nil
 }
 
 type CommandAuthResponse struct {
-	ClientVersion        *string   `protobuf:"bytes,1,opt,name=client_version,json=clientVersion" json:"client_version,omitempty"`
-	Response             *AuthData `protobuf:"bytes,2,opt,name=response" json:"response,omitempty"`
-	ProtocolVersion      *int32    `protobuf:"varint,3,opt,name=protocol_version,json=protocolVersion,def=0" json:"protocol_version,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
-	XXX_unrecognized     []byte    `json:"-"`
-	XXX_sizecache        int32     `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ClientVersion   *string   `protobuf:"bytes,1,opt,name=client_version,json=clientVersion" json:"client_version,omitempty"`
+	Response        *AuthData `protobuf:"bytes,2,opt,name=response" json:"response,omitempty"`
+	ProtocolVersion *int32    `protobuf:"varint,3,opt,name=protocol_version,json=protocolVersion,def=0" json:"protocol_version,omitempty"`
 }
 
-func (m *CommandAuthResponse) Reset()         { *m = CommandAuthResponse{} }
-func (m *CommandAuthResponse) String() string { return proto.CompactTextString(m) }
-func (*CommandAuthResponse) ProtoMessage()    {}
-func (*CommandAuthResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{12}
-}
-func (m *CommandAuthResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandAuthResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandAuthResponse.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for CommandAuthResponse fields.
+const (
+	Default_CommandAuthResponse_ProtocolVersion = int32(0)
+)
+
+func (x *CommandAuthResponse) Reset() {
+	*x = CommandAuthResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandAuthResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandAuthResponse.Merge(m, src)
-}
-func (m *CommandAuthResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *CommandAuthResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandAuthResponse.DiscardUnknown(m)
+
+func (x *CommandAuthResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandAuthResponse proto.InternalMessageInfo
+func (*CommandAuthResponse) ProtoMessage() {}
+
+func (x *CommandAuthResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandAuthResponse_ProtocolVersion int32 = 0
+// Deprecated: Use CommandAuthResponse.ProtoReflect.Descriptor instead.
+func (*CommandAuthResponse) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{12}
+}
 
-func (m *CommandAuthResponse) GetClientVersion() string {
-	if m != nil && m.ClientVersion != nil {
-		return *m.ClientVersion
+func (x *CommandAuthResponse) GetClientVersion() string {
+	if x != nil && x.ClientVersion != nil {
+		return *x.ClientVersion
 	}
 	return ""
 }
 
-func (m *CommandAuthResponse) GetResponse() *AuthData {
-	if m != nil {
-		return m.Response
+func (x *CommandAuthResponse) GetResponse() *AuthData {
+	if x != nil {
+		return x.Response
 	}
 	return nil
 }
 
-func (m *CommandAuthResponse) GetProtocolVersion() int32 {
-	if m != nil && m.ProtocolVersion != nil {
-		return *m.ProtocolVersion
+func (x *CommandAuthResponse) GetProtocolVersion() int32 {
+	if x != nil && x.ProtocolVersion != nil {
+		return *x.ProtocolVersion
 	}
 	return Default_CommandAuthResponse_ProtocolVersion
 }
 
 type CommandAuthChallenge struct {
-	ServerVersion        *string   `protobuf:"bytes,1,opt,name=server_version,json=serverVersion" json:"server_version,omitempty"`
-	Challenge            *AuthData `protobuf:"bytes,2,opt,name=challenge" json:"challenge,omitempty"`
-	ProtocolVersion      *int32    `protobuf:"varint,3,opt,name=protocol_version,json=protocolVersion,def=0" json:"protocol_version,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
-	XXX_unrecognized     []byte    `json:"-"`
-	XXX_sizecache        int32     `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ServerVersion   *string   `protobuf:"bytes,1,opt,name=server_version,json=serverVersion" json:"server_version,omitempty"`
+	Challenge       *AuthData `protobuf:"bytes,2,opt,name=challenge" json:"challenge,omitempty"`
+	ProtocolVersion *int32    `protobuf:"varint,3,opt,name=protocol_version,json=protocolVersion,def=0" json:"protocol_version,omitempty"`
 }
 
-func (m *CommandAuthChallenge) Reset()         { *m = CommandAuthChallenge{} }
-func (m *CommandAuthChallenge) String() string { return proto.CompactTextString(m) }
-func (*CommandAuthChallenge) ProtoMessage()    {}
-func (*CommandAuthChallenge) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{13}
-}
-func (m *CommandAuthChallenge) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandAuthChallenge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandAuthChallenge.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for CommandAuthChallenge fields.
+const (
+	Default_CommandAuthChallenge_ProtocolVersion = int32(0)
+)
+
+func (x *CommandAuthChallenge) Reset() {
+	*x = CommandAuthChallenge{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandAuthChallenge) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandAuthChallenge.Merge(m, src)
-}
-func (m *CommandAuthChallenge) XXX_Size() int {
-	return m.Size()
-}
-func (m *CommandAuthChallenge) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandAuthChallenge.DiscardUnknown(m)
+
+func (x *CommandAuthChallenge) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandAuthChallenge proto.InternalMessageInfo
+func (*CommandAuthChallenge) ProtoMessage() {}
+
+func (x *CommandAuthChallenge) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandAuthChallenge_ProtocolVersion int32 = 0
+// Deprecated: Use CommandAuthChallenge.ProtoReflect.Descriptor instead.
+func (*CommandAuthChallenge) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{13}
+}
 
-func (m *CommandAuthChallenge) GetServerVersion() string {
-	if m != nil && m.ServerVersion != nil {
-		return *m.ServerVersion
+func (x *CommandAuthChallenge) GetServerVersion() string {
+	if x != nil && x.ServerVersion != nil {
+		return *x.ServerVersion
 	}
 	return ""
 }
 
-func (m *CommandAuthChallenge) GetChallenge() *AuthData {
-	if m != nil {
-		return m.Challenge
+func (x *CommandAuthChallenge) GetChallenge() *AuthData {
+	if x != nil {
+		return x.Challenge
 	}
 	return nil
 }
 
-func (m *CommandAuthChallenge) GetProtocolVersion() int32 {
-	if m != nil && m.ProtocolVersion != nil {
-		return *m.ProtocolVersion
+func (x *CommandAuthChallenge) GetProtocolVersion() int32 {
+	if x != nil && x.ProtocolVersion != nil {
+		return *x.ProtocolVersion
 	}
 	return Default_CommandAuthChallenge_ProtocolVersion
 }
 
 // To support mutual authentication type, such as Sasl, reuse this command to mutual auth.
 type AuthData struct {
-	AuthMethodName       *string  `protobuf:"bytes,1,opt,name=auth_method_name,json=authMethodName" json:"auth_method_name,omitempty"`
-	AuthData             []byte   `protobuf:"bytes,2,opt,name=auth_data,json=authData" json:"auth_data,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	AuthMethodName *string `protobuf:"bytes,1,opt,name=auth_method_name,json=authMethodName" json:"auth_method_name,omitempty"`
+	AuthData       []byte  `protobuf:"bytes,2,opt,name=auth_data,json=authData" json:"auth_data,omitempty"`
 }
 
-func (m *AuthData) Reset()         { *m = AuthData{} }
-func (m *AuthData) String() string { return proto.CompactTextString(m) }
-func (*AuthData) ProtoMessage()    {}
-func (*AuthData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{14}
-}
-func (m *AuthData) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *AuthData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_AuthData.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *AuthData) Reset() {
+	*x = AuthData{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *AuthData) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_AuthData.Merge(m, src)
-}
-func (m *AuthData) XXX_Size() int {
-	return m.Size()
+
+func (x *AuthData) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *AuthData) XXX_DiscardUnknown() {
-	xxx_messageInfo_AuthData.DiscardUnknown(m)
+
+func (*AuthData) ProtoMessage() {}
+
+func (x *AuthData) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_AuthData proto.InternalMessageInfo
+// Deprecated: Use AuthData.ProtoReflect.Descriptor instead.
+func (*AuthData) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{14}
+}
 
-func (m *AuthData) GetAuthMethodName() string {
-	if m != nil && m.AuthMethodName != nil {
-		return *m.AuthMethodName
+func (x *AuthData) GetAuthMethodName() string {
+	if x != nil && x.AuthMethodName != nil {
+		return *x.AuthMethodName
 	}
 	return ""
 }
 
-func (m *AuthData) GetAuthData() []byte {
-	if m != nil {
-		return m.AuthData
+func (x *AuthData) GetAuthData() []byte {
+	if x != nil {
+		return x.AuthData
 	}
 	return nil
 }
 
 type KeySharedMeta struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	KeySharedMode           *KeySharedMode `protobuf:"varint,1,req,name=keySharedMode,enum=pulsar.proto.KeySharedMode" json:"keySharedMode,omitempty"`
 	HashRanges              []*IntRange    `protobuf:"bytes,3,rep,name=hashRanges" json:"hashRanges,omitempty"`
 	AllowOutOfOrderDelivery *bool          `protobuf:"varint,4,opt,name=allowOutOfOrderDelivery,def=0" json:"allowOutOfOrderDelivery,omitempty"`
-	XXX_NoUnkeyedLiteral    struct{}       `json:"-"`
-	XXX_unrecognized        []byte         `json:"-"`
-	XXX_sizecache           int32          `json:"-"`
 }
 
-func (m *KeySharedMeta) Reset()         { *m = KeySharedMeta{} }
-func (m *KeySharedMeta) String() string { return proto.CompactTextString(m) }
-func (*KeySharedMeta) ProtoMessage()    {}
-func (*KeySharedMeta) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{15}
-}
-func (m *KeySharedMeta) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *KeySharedMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_KeySharedMeta.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for KeySharedMeta fields.
+const (
+	Default_KeySharedMeta_AllowOutOfOrderDelivery = bool(false)
+)
+
+func (x *KeySharedMeta) Reset() {
+	*x = KeySharedMeta{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *KeySharedMeta) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_KeySharedMeta.Merge(m, src)
-}
-func (m *KeySharedMeta) XXX_Size() int {
-	return m.Size()
-}
-func (m *KeySharedMeta) XXX_DiscardUnknown() {
-	xxx_messageInfo_KeySharedMeta.DiscardUnknown(m)
+
+func (x *KeySharedMeta) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_KeySharedMeta proto.InternalMessageInfo
+func (*KeySharedMeta) ProtoMessage() {}
+
+func (x *KeySharedMeta) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_KeySharedMeta_AllowOutOfOrderDelivery bool = false
+// Deprecated: Use KeySharedMeta.ProtoReflect.Descriptor instead.
+func (*KeySharedMeta) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{15}
+}
 
-func (m *KeySharedMeta) GetKeySharedMode() KeySharedMode {
-	if m != nil && m.KeySharedMode != nil {
-		return *m.KeySharedMode
+func (x *KeySharedMeta) GetKeySharedMode() KeySharedMode {
+	if x != nil && x.KeySharedMode != nil {
+		return *x.KeySharedMode
 	}
 	return KeySharedMode_AUTO_SPLIT
 }
 
-func (m *KeySharedMeta) GetHashRanges() []*IntRange {
-	if m != nil {
-		return m.HashRanges
+func (x *KeySharedMeta) GetHashRanges() []*IntRange {
+	if x != nil {
+		return x.HashRanges
 	}
 	return nil
 }
 
-func (m *KeySharedMeta) GetAllowOutOfOrderDelivery() bool {
-	if m != nil && m.AllowOutOfOrderDelivery != nil {
-		return *m.AllowOutOfOrderDelivery
+func (x *KeySharedMeta) GetAllowOutOfOrderDelivery() bool {
+	if x != nil && x.AllowOutOfOrderDelivery != nil {
+		return *x.AllowOutOfOrderDelivery
 	}
 	return Default_KeySharedMeta_AllowOutOfOrderDelivery
 }
 
 type CommandSubscribe struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	Topic         *string                   `protobuf:"bytes,1,req,name=topic" json:"topic,omitempty"`
 	Subscription  *string                   `protobuf:"bytes,2,req,name=subscription" json:"subscription,omitempty"`
 	SubType       *CommandSubscribe_SubType `protobuf:"varint,3,req,name=subType,enum=pulsar.proto.CommandSubscribe_SubType" json:"subType,omitempty"`
@@ -2508,184 +2809,187 @@ type CommandSubscribe struct {
 	KeySharedMeta                   *KeySharedMeta `protobuf:"bytes,17,opt,name=keySharedMeta" json:"keySharedMeta,omitempty"`
 	SubscriptionProperties          []*KeyValue    `protobuf:"bytes,18,rep,name=subscription_properties,json=subscriptionProperties" json:"subscription_properties,omitempty"`
 	// The consumer epoch, when exclusive and failover consumer redeliver unack message will increase the epoch
-	ConsumerEpoch        *uint64  `protobuf:"varint,19,opt,name=consumer_epoch,json=consumerEpoch" json:"consumer_epoch,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	ConsumerEpoch *uint64 `protobuf:"varint,19,opt,name=consumer_epoch,json=consumerEpoch" json:"consumer_epoch,omitempty"`
 }
 
-func (m *CommandSubscribe) Reset()         { *m = CommandSubscribe{} }
-func (m *CommandSubscribe) String() string { return proto.CompactTextString(m) }
-func (*CommandSubscribe) ProtoMessage()    {}
-func (*CommandSubscribe) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{16}
-}
-func (m *CommandSubscribe) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandSubscribe) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandSubscribe.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for CommandSubscribe fields.
+const (
+	Default_CommandSubscribe_Durable                         = bool(true)
+	Default_CommandSubscribe_InitialPosition                 = CommandSubscribe_Latest
+	Default_CommandSubscribe_ForceTopicCreation              = bool(true)
+	Default_CommandSubscribe_StartMessageRollbackDurationSec = uint64(0)
+)
+
+func (x *CommandSubscribe) Reset() {
+	*x = CommandSubscribe{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandSubscribe) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandSubscribe.Merge(m, src)
-}
-func (m *CommandSubscribe) XXX_Size() int {
-	return m.Size()
-}
-func (m *CommandSubscribe) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandSubscribe.DiscardUnknown(m)
+
+func (x *CommandSubscribe) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandSubscribe proto.InternalMessageInfo
+func (*CommandSubscribe) ProtoMessage() {}
+
+func (x *CommandSubscribe) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandSubscribe_Durable bool = true
-const Default_CommandSubscribe_InitialPosition CommandSubscribe_InitialPosition = CommandSubscribe_Latest
-const Default_CommandSubscribe_ForceTopicCreation bool = true
-const Default_CommandSubscribe_StartMessageRollbackDurationSec uint64 = 0
+// Deprecated: Use CommandSubscribe.ProtoReflect.Descriptor instead.
+func (*CommandSubscribe) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{16}
+}
 
-func (m *CommandSubscribe) GetTopic() string {
-	if m != nil && m.Topic != nil {
-		return *m.Topic
+func (x *CommandSubscribe) GetTopic() string {
+	if x != nil && x.Topic != nil {
+		return *x.Topic
 	}
 	return ""
 }
 
-func (m *CommandSubscribe) GetSubscription() string {
-	if m != nil && m.Subscription != nil {
-		return *m.Subscription
+func (x *CommandSubscribe) GetSubscription() string {
+	if x != nil && x.Subscription != nil {
+		return *x.Subscription
 	}
 	return ""
 }
 
-func (m *CommandSubscribe) GetSubType() CommandSubscribe_SubType {
-	if m != nil && m.SubType != nil {
-		return *m.SubType
+func (x *CommandSubscribe) GetSubType() CommandSubscribe_SubType {
+	if x != nil && x.SubType != nil {
+		return *x.SubType
 	}
 	return CommandSubscribe_Exclusive
 }
 
-func (m *CommandSubscribe) GetConsumerId() uint64 {
-	if m != nil && m.ConsumerId != nil {
-		return *m.ConsumerId
+func (x *CommandSubscribe) GetConsumerId() uint64 {
+	if x != nil && x.ConsumerId != nil {
+		return *x.ConsumerId
 	}
 	return 0
 }
 
-func (m *CommandSubscribe) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandSubscribe) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandSubscribe) GetConsumerName() string {
-	if m != nil && m.ConsumerName != nil {
-		return *m.ConsumerName
+func (x *CommandSubscribe) GetConsumerName() string {
+	if x != nil && x.ConsumerName != nil {
+		return *x.ConsumerName
 	}
 	return ""
 }
 
-func (m *CommandSubscribe) GetPriorityLevel() int32 {
-	if m != nil && m.PriorityLevel != nil {
-		return *m.PriorityLevel
+func (x *CommandSubscribe) GetPriorityLevel() int32 {
+	if x != nil && x.PriorityLevel != nil {
+		return *x.PriorityLevel
 	}
 	return 0
 }
 
-func (m *CommandSubscribe) GetDurable() bool {
-	if m != nil && m.Durable != nil {
-		return *m.Durable
+func (x *CommandSubscribe) GetDurable() bool {
+	if x != nil && x.Durable != nil {
+		return *x.Durable
 	}
 	return Default_CommandSubscribe_Durable
 }
 
-func (m *CommandSubscribe) GetStartMessageId() *MessageIdData {
-	if m != nil {
-		return m.StartMessageId
+func (x *CommandSubscribe) GetStartMessageId() *MessageIdData {
+	if x != nil {
+		return x.StartMessageId
 	}
 	return nil
 }
 
-func (m *CommandSubscribe) GetMetadata() []*KeyValue {
-	if m != nil {
-		return m.Metadata
+func (x *CommandSubscribe) GetMetadata() []*KeyValue {
+	if x != nil {
+		return x.Metadata
 	}
 	return nil
 }
 
-func (m *CommandSubscribe) GetReadCompacted() bool {
-	if m != nil && m.ReadCompacted != nil {
-		return *m.ReadCompacted
+func (x *CommandSubscribe) GetReadCompacted() bool {
+	if x != nil && x.ReadCompacted != nil {
+		return *x.ReadCompacted
 	}
 	return false
 }
 
-func (m *CommandSubscribe) GetSchema() *Schema {
-	if m != nil {
-		return m.Schema
+func (x *CommandSubscribe) GetSchema() *Schema {
+	if x != nil {
+		return x.Schema
 	}
 	return nil
 }
 
-func (m *CommandSubscribe) GetInitialPosition() CommandSubscribe_InitialPosition {
-	if m != nil && m.InitialPosition != nil {
-		return *m.InitialPosition
+func (x *CommandSubscribe) GetInitialPosition() CommandSubscribe_InitialPosition {
+	if x != nil && x.InitialPosition != nil {
+		return *x.InitialPosition
 	}
 	return Default_CommandSubscribe_InitialPosition
 }
 
-func (m *CommandSubscribe) GetReplicateSubscriptionState() bool {
-	if m != nil && m.ReplicateSubscriptionState != nil {
-		return *m.ReplicateSubscriptionState
+func (x *CommandSubscribe) GetReplicateSubscriptionState() bool {
+	if x != nil && x.ReplicateSubscriptionState != nil {
+		return *x.ReplicateSubscriptionState
 	}
 	return false
 }
 
-func (m *CommandSubscribe) GetForceTopicCreation() bool {
-	if m != nil && m.ForceTopicCreation != nil {
-		return *m.ForceTopicCreation
+func (x *CommandSubscribe) GetForceTopicCreation() bool {
+	if x != nil && x.ForceTopicCreation != nil {
+		return *x.ForceTopicCreation
 	}
 	return Default_CommandSubscribe_ForceTopicCreation
 }
 
-func (m *CommandSubscribe) GetStartMessageRollbackDurationSec() uint64 {
-	if m != nil && m.StartMessageRollbackDurationSec != nil {
-		return *m.StartMessageRollbackDurationSec
+func (x *CommandSubscribe) GetStartMessageRollbackDurationSec() uint64 {
+	if x != nil && x.StartMessageRollbackDurationSec != nil {
+		return *x.StartMessageRollbackDurationSec
 	}
 	return Default_CommandSubscribe_StartMessageRollbackDurationSec
 }
 
-func (m *CommandSubscribe) GetKeySharedMeta() *KeySharedMeta {
-	if m != nil {
-		return m.KeySharedMeta
+func (x *CommandSubscribe) GetKeySharedMeta() *KeySharedMeta {
+	if x != nil {
+		return x.KeySharedMeta
 	}
 	return nil
 }
 
-func (m *CommandSubscribe) GetSubscriptionProperties() []*KeyValue {
-	if m != nil {
-		return m.SubscriptionProperties
+func (x *CommandSubscribe) GetSubscriptionProperties() []*KeyValue {
+	if x != nil {
+		return x.SubscriptionProperties
 	}
 	return nil
 }
 
-func (m *CommandSubscribe) GetConsumerEpoch() uint64 {
-	if m != nil && m.ConsumerEpoch != nil {
-		return *m.ConsumerEpoch
+func (x *CommandSubscribe) GetConsumerEpoch() uint64 {
+	if x != nil && x.ConsumerEpoch != nil {
+		return *x.ConsumerEpoch
 	}
 	return 0
 }
 
 type CommandPartitionedTopicMetadata struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	Topic     *string `protobuf:"bytes,1,req,name=topic" json:"topic,omitempty"`
 	RequestId *uint64 `protobuf:"varint,2,req,name=request_id,json=requestId" json:"request_id,omitempty"`
 	// TODO - Remove original_principal, original_auth_data, original_auth_method
@@ -2694,163 +2998,161 @@ type CommandPartitionedTopicMetadata struct {
 	OriginalPrincipal *string `protobuf:"bytes,3,opt,name=original_principal,json=originalPrincipal" json:"original_principal,omitempty"`
 	// Original auth role and auth Method that was passed
 	// to the proxy.
-	OriginalAuthData     *string  `protobuf:"bytes,4,opt,name=original_auth_data,json=originalAuthData" json:"original_auth_data,omitempty"`
-	OriginalAuthMethod   *string  `protobuf:"bytes,5,opt,name=original_auth_method,json=originalAuthMethod" json:"original_auth_method,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	OriginalAuthData   *string `protobuf:"bytes,4,opt,name=original_auth_data,json=originalAuthData" json:"original_auth_data,omitempty"`
+	OriginalAuthMethod *string `protobuf:"bytes,5,opt,name=original_auth_method,json=originalAuthMethod" json:"original_auth_method,omitempty"`
 }
 
-func (m *CommandPartitionedTopicMetadata) Reset()         { *m = CommandPartitionedTopicMetadata{} }
-func (m *CommandPartitionedTopicMetadata) String() string { return proto.CompactTextString(m) }
-func (*CommandPartitionedTopicMetadata) ProtoMessage()    {}
-func (*CommandPartitionedTopicMetadata) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{17}
-}
-func (m *CommandPartitionedTopicMetadata) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandPartitionedTopicMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandPartitionedTopicMetadata.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandPartitionedTopicMetadata) Reset() {
+	*x = CommandPartitionedTopicMetadata{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandPartitionedTopicMetadata) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandPartitionedTopicMetadata.Merge(m, src)
-}
-func (m *CommandPartitionedTopicMetadata) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandPartitionedTopicMetadata) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandPartitionedTopicMetadata) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandPartitionedTopicMetadata.DiscardUnknown(m)
+
+func (*CommandPartitionedTopicMetadata) ProtoMessage() {}
+
+func (x *CommandPartitionedTopicMetadata) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandPartitionedTopicMetadata proto.InternalMessageInfo
+// Deprecated: Use CommandPartitionedTopicMetadata.ProtoReflect.Descriptor instead.
+func (*CommandPartitionedTopicMetadata) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{17}
+}
 
-func (m *CommandPartitionedTopicMetadata) GetTopic() string {
-	if m != nil && m.Topic != nil {
-		return *m.Topic
+func (x *CommandPartitionedTopicMetadata) GetTopic() string {
+	if x != nil && x.Topic != nil {
+		return *x.Topic
 	}
 	return ""
 }
 
-func (m *CommandPartitionedTopicMetadata) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandPartitionedTopicMetadata) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandPartitionedTopicMetadata) GetOriginalPrincipal() string {
-	if m != nil && m.OriginalPrincipal != nil {
-		return *m.OriginalPrincipal
+func (x *CommandPartitionedTopicMetadata) GetOriginalPrincipal() string {
+	if x != nil && x.OriginalPrincipal != nil {
+		return *x.OriginalPrincipal
 	}
 	return ""
 }
 
-func (m *CommandPartitionedTopicMetadata) GetOriginalAuthData() string {
-	if m != nil && m.OriginalAuthData != nil {
-		return *m.OriginalAuthData
+func (x *CommandPartitionedTopicMetadata) GetOriginalAuthData() string {
+	if x != nil && x.OriginalAuthData != nil {
+		return *x.OriginalAuthData
 	}
 	return ""
 }
 
-func (m *CommandPartitionedTopicMetadata) GetOriginalAuthMethod() string {
-	if m != nil && m.OriginalAuthMethod != nil {
-		return *m.OriginalAuthMethod
+func (x *CommandPartitionedTopicMetadata) GetOriginalAuthMethod() string {
+	if x != nil && x.OriginalAuthMethod != nil {
+		return *x.OriginalAuthMethod
 	}
 	return ""
 }
 
 type CommandPartitionedTopicMetadataResponse struct {
-	Partitions           *uint32                                             `protobuf:"varint,1,opt,name=partitions" json:"partitions,omitempty"`
-	RequestId            *uint64                                             `protobuf:"varint,2,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	Response             *CommandPartitionedTopicMetadataResponse_LookupType `protobuf:"varint,3,opt,name=response,enum=pulsar.proto.CommandPartitionedTopicMetadataResponse_LookupType" json:"response,omitempty"`
-	Error                *ServerError                                        `protobuf:"varint,4,opt,name=error,enum=pulsar.proto.ServerError" json:"error,omitempty"`
-	Message              *string                                             `protobuf:"bytes,5,opt,name=message" json:"message,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                                            `json:"-"`
-	XXX_unrecognized     []byte                                              `json:"-"`
-	XXX_sizecache        int32                                               `json:"-"`
-}
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 
-func (m *CommandPartitionedTopicMetadataResponse) Reset() {
-	*m = CommandPartitionedTopicMetadataResponse{}
+	Partitions *uint32                                             `protobuf:"varint,1,opt,name=partitions" json:"partitions,omitempty"` // Optional in case of error
+	RequestId  *uint64                                             `protobuf:"varint,2,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+	Response   *CommandPartitionedTopicMetadataResponse_LookupType `protobuf:"varint,3,opt,name=response,enum=pulsar.proto.CommandPartitionedTopicMetadataResponse_LookupType" json:"response,omitempty"`
+	Error      *ServerError                                        `protobuf:"varint,4,opt,name=error,enum=pulsar.proto.ServerError" json:"error,omitempty"`
+	Message    *string                                             `protobuf:"bytes,5,opt,name=message" json:"message,omitempty"`
 }
-func (m *CommandPartitionedTopicMetadataResponse) String() string { return proto.CompactTextString(m) }
-func (*CommandPartitionedTopicMetadataResponse) ProtoMessage()    {}
-func (*CommandPartitionedTopicMetadataResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{18}
-}
-func (m *CommandPartitionedTopicMetadataResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandPartitionedTopicMetadataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandPartitionedTopicMetadataResponse.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+
+func (x *CommandPartitionedTopicMetadataResponse) Reset() {
+	*x = CommandPartitionedTopicMetadataResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandPartitionedTopicMetadataResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandPartitionedTopicMetadataResponse.Merge(m, src)
-}
-func (m *CommandPartitionedTopicMetadataResponse) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandPartitionedTopicMetadataResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandPartitionedTopicMetadataResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandPartitionedTopicMetadataResponse.DiscardUnknown(m)
+
+func (*CommandPartitionedTopicMetadataResponse) ProtoMessage() {}
+
+func (x *CommandPartitionedTopicMetadataResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandPartitionedTopicMetadataResponse proto.InternalMessageInfo
+// Deprecated: Use CommandPartitionedTopicMetadataResponse.ProtoReflect.Descriptor instead.
+func (*CommandPartitionedTopicMetadataResponse) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{18}
+}
 
-func (m *CommandPartitionedTopicMetadataResponse) GetPartitions() uint32 {
-	if m != nil && m.Partitions != nil {
-		return *m.Partitions
+func (x *CommandPartitionedTopicMetadataResponse) GetPartitions() uint32 {
+	if x != nil && x.Partitions != nil {
+		return *x.Partitions
 	}
 	return 0
 }
 
-func (m *CommandPartitionedTopicMetadataResponse) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandPartitionedTopicMetadataResponse) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandPartitionedTopicMetadataResponse) GetResponse() CommandPartitionedTopicMetadataResponse_LookupType {
-	if m != nil && m.Response != nil {
-		return *m.Response
+func (x *CommandPartitionedTopicMetadataResponse) GetResponse() CommandPartitionedTopicMetadataResponse_LookupType {
+	if x != nil && x.Response != nil {
+		return *x.Response
 	}
 	return CommandPartitionedTopicMetadataResponse_Success
 }
 
-func (m *CommandPartitionedTopicMetadataResponse) GetError() ServerError {
-	if m != nil && m.Error != nil {
-		return *m.Error
+func (x *CommandPartitionedTopicMetadataResponse) GetError() ServerError {
+	if x != nil && x.Error != nil {
+		return *x.Error
 	}
 	return ServerError_UnknownError
 }
 
-func (m *CommandPartitionedTopicMetadataResponse) GetMessage() string {
-	if m != nil && m.Message != nil {
-		return *m.Message
+func (x *CommandPartitionedTopicMetadataResponse) GetMessage() string {
+	if x != nil && x.Message != nil {
+		return *x.Message
 	}
 	return ""
 }
 
 type CommandLookupTopic struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	Topic         *string `protobuf:"bytes,1,req,name=topic" json:"topic,omitempty"`
 	RequestId     *uint64 `protobuf:"varint,2,req,name=request_id,json=requestId" json:"request_id,omitempty"`
 	Authoritative *bool   `protobuf:"varint,3,opt,name=authoritative,def=0" json:"authoritative,omitempty"`
@@ -2863,98 +3165,101 @@ type CommandLookupTopic struct {
 	OriginalAuthData   *string `protobuf:"bytes,5,opt,name=original_auth_data,json=originalAuthData" json:"original_auth_data,omitempty"`
 	OriginalAuthMethod *string `protobuf:"bytes,6,opt,name=original_auth_method,json=originalAuthMethod" json:"original_auth_method,omitempty"`
 	//
-	AdvertisedListenerName *string  `protobuf:"bytes,7,opt,name=advertised_listener_name,json=advertisedListenerName" json:"advertised_listener_name,omitempty"`
-	XXX_NoUnkeyedLiteral   struct{} `json:"-"`
-	XXX_unrecognized       []byte   `json:"-"`
-	XXX_sizecache          int32    `json:"-"`
+	AdvertisedListenerName *string `protobuf:"bytes,7,opt,name=advertised_listener_name,json=advertisedListenerName" json:"advertised_listener_name,omitempty"`
 }
 
-func (m *CommandLookupTopic) Reset()         { *m = CommandLookupTopic{} }
-func (m *CommandLookupTopic) String() string { return proto.CompactTextString(m) }
-func (*CommandLookupTopic) ProtoMessage()    {}
-func (*CommandLookupTopic) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{19}
-}
-func (m *CommandLookupTopic) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandLookupTopic) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandLookupTopic.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for CommandLookupTopic fields.
+const (
+	Default_CommandLookupTopic_Authoritative = bool(false)
+)
+
+func (x *CommandLookupTopic) Reset() {
+	*x = CommandLookupTopic{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandLookupTopic) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandLookupTopic.Merge(m, src)
-}
-func (m *CommandLookupTopic) XXX_Size() int {
-	return m.Size()
-}
-func (m *CommandLookupTopic) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandLookupTopic.DiscardUnknown(m)
+
+func (x *CommandLookupTopic) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandLookupTopic proto.InternalMessageInfo
+func (*CommandLookupTopic) ProtoMessage() {}
+
+func (x *CommandLookupTopic) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[19]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandLookupTopic_Authoritative bool = false
+// Deprecated: Use CommandLookupTopic.ProtoReflect.Descriptor instead.
+func (*CommandLookupTopic) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{19}
+}
 
-func (m *CommandLookupTopic) GetTopic() string {
-	if m != nil && m.Topic != nil {
-		return *m.Topic
+func (x *CommandLookupTopic) GetTopic() string {
+	if x != nil && x.Topic != nil {
+		return *x.Topic
 	}
 	return ""
 }
 
-func (m *CommandLookupTopic) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandLookupTopic) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandLookupTopic) GetAuthoritative() bool {
-	if m != nil && m.Authoritative != nil {
-		return *m.Authoritative
+func (x *CommandLookupTopic) GetAuthoritative() bool {
+	if x != nil && x.Authoritative != nil {
+		return *x.Authoritative
 	}
 	return Default_CommandLookupTopic_Authoritative
 }
 
-func (m *CommandLookupTopic) GetOriginalPrincipal() string {
-	if m != nil && m.OriginalPrincipal != nil {
-		return *m.OriginalPrincipal
+func (x *CommandLookupTopic) GetOriginalPrincipal() string {
+	if x != nil && x.OriginalPrincipal != nil {
+		return *x.OriginalPrincipal
 	}
 	return ""
 }
 
-func (m *CommandLookupTopic) GetOriginalAuthData() string {
-	if m != nil && m.OriginalAuthData != nil {
-		return *m.OriginalAuthData
+func (x *CommandLookupTopic) GetOriginalAuthData() string {
+	if x != nil && x.OriginalAuthData != nil {
+		return *x.OriginalAuthData
 	}
 	return ""
 }
 
-func (m *CommandLookupTopic) GetOriginalAuthMethod() string {
-	if m != nil && m.OriginalAuthMethod != nil {
-		return *m.OriginalAuthMethod
+func (x *CommandLookupTopic) GetOriginalAuthMethod() string {
+	if x != nil && x.OriginalAuthMethod != nil {
+		return *x.OriginalAuthMethod
 	}
 	return ""
 }
 
-func (m *CommandLookupTopic) GetAdvertisedListenerName() string {
-	if m != nil && m.AdvertisedListenerName != nil {
-		return *m.AdvertisedListenerName
+func (x *CommandLookupTopic) GetAdvertisedListenerName() string {
+	if x != nil && x.AdvertisedListenerName != nil {
+		return *x.AdvertisedListenerName
 	}
 	return ""
 }
 
 type CommandLookupTopicResponse struct {
-	BrokerServiceUrl    *string                                `protobuf:"bytes,1,opt,name=brokerServiceUrl" json:"brokerServiceUrl,omitempty"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	BrokerServiceUrl    *string                                `protobuf:"bytes,1,opt,name=brokerServiceUrl" json:"brokerServiceUrl,omitempty"` // Optional in case of error
 	BrokerServiceUrlTls *string                                `protobuf:"bytes,2,opt,name=brokerServiceUrlTls" json:"brokerServiceUrlTls,omitempty"`
 	Response            *CommandLookupTopicResponse_LookupType `protobuf:"varint,3,opt,name=response,enum=pulsar.proto.CommandLookupTopicResponse_LookupType" json:"response,omitempty"`
 	RequestId           *uint64                                `protobuf:"varint,4,req,name=request_id,json=requestId" json:"request_id,omitempty"`
@@ -2964,100 +3269,99 @@ type CommandLookupTopicResponse struct {
 	// If it's true, indicates to the client that it must
 	// always connect through the service url after the
 	// lookup has been completed.
-	ProxyThroughServiceUrl *bool    `protobuf:"varint,8,opt,name=proxy_through_service_url,json=proxyThroughServiceUrl,def=0" json:"proxy_through_service_url,omitempty"`
-	XXX_NoUnkeyedLiteral   struct{} `json:"-"`
-	XXX_unrecognized       []byte   `json:"-"`
-	XXX_sizecache          int32    `json:"-"`
+	ProxyThroughServiceUrl *bool `protobuf:"varint,8,opt,name=proxy_through_service_url,json=proxyThroughServiceUrl,def=0" json:"proxy_through_service_url,omitempty"`
 }
 
-func (m *CommandLookupTopicResponse) Reset()         { *m = CommandLookupTopicResponse{} }
-func (m *CommandLookupTopicResponse) String() string { return proto.CompactTextString(m) }
-func (*CommandLookupTopicResponse) ProtoMessage()    {}
-func (*CommandLookupTopicResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{20}
-}
-func (m *CommandLookupTopicResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandLookupTopicResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandLookupTopicResponse.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for CommandLookupTopicResponse fields.
+const (
+	Default_CommandLookupTopicResponse_Authoritative          = bool(false)
+	Default_CommandLookupTopicResponse_ProxyThroughServiceUrl = bool(false)
+)
+
+func (x *CommandLookupTopicResponse) Reset() {
+	*x = CommandLookupTopicResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandLookupTopicResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandLookupTopicResponse.Merge(m, src)
-}
-func (m *CommandLookupTopicResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *CommandLookupTopicResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandLookupTopicResponse.DiscardUnknown(m)
+
+func (x *CommandLookupTopicResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandLookupTopicResponse proto.InternalMessageInfo
+func (*CommandLookupTopicResponse) ProtoMessage() {}
+
+func (x *CommandLookupTopicResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandLookupTopicResponse_Authoritative bool = false
-const Default_CommandLookupTopicResponse_ProxyThroughServiceUrl bool = false
+// Deprecated: Use CommandLookupTopicResponse.ProtoReflect.Descriptor instead.
+func (*CommandLookupTopicResponse) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{20}
+}
 
-func (m *CommandLookupTopicResponse) GetBrokerServiceUrl() string {
-	if m != nil && m.BrokerServiceUrl != nil {
-		return *m.BrokerServiceUrl
+func (x *CommandLookupTopicResponse) GetBrokerServiceUrl() string {
+	if x != nil && x.BrokerServiceUrl != nil {
+		return *x.BrokerServiceUrl
 	}
 	return ""
 }
 
-func (m *CommandLookupTopicResponse) GetBrokerServiceUrlTls() string {
-	if m != nil && m.BrokerServiceUrlTls != nil {
-		return *m.BrokerServiceUrlTls
+func (x *CommandLookupTopicResponse) GetBrokerServiceUrlTls() string {
+	if x != nil && x.BrokerServiceUrlTls != nil {
+		return *x.BrokerServiceUrlTls
 	}
 	return ""
 }
 
-func (m *CommandLookupTopicResponse) GetResponse() CommandLookupTopicResponse_LookupType {
-	if m != nil && m.Response != nil {
-		return *m.Response
+func (x *CommandLookupTopicResponse) GetResponse() CommandLookupTopicResponse_LookupType {
+	if x != nil && x.Response != nil {
+		return *x.Response
 	}
 	return CommandLookupTopicResponse_Redirect
 }
 
-func (m *CommandLookupTopicResponse) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandLookupTopicResponse) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandLookupTopicResponse) GetAuthoritative() bool {
-	if m != nil && m.Authoritative != nil {
-		return *m.Authoritative
+func (x *CommandLookupTopicResponse) GetAuthoritative() bool {
+	if x != nil && x.Authoritative != nil {
+		return *x.Authoritative
 	}
 	return Default_CommandLookupTopicResponse_Authoritative
 }
 
-func (m *CommandLookupTopicResponse) GetError() ServerError {
-	if m != nil && m.Error != nil {
-		return *m.Error
+func (x *CommandLookupTopicResponse) GetError() ServerError {
+	if x != nil && x.Error != nil {
+		return *x.Error
 	}
 	return ServerError_UnknownError
 }
 
-func (m *CommandLookupTopicResponse) GetMessage() string {
-	if m != nil && m.Message != nil {
-		return *m.Message
+func (x *CommandLookupTopicResponse) GetMessage() string {
+	if x != nil && x.Message != nil {
+		return *x.Message
 	}
 	return ""
 }
 
-func (m *CommandLookupTopicResponse) GetProxyThroughServiceUrl() bool {
-	if m != nil && m.ProxyThroughServiceUrl != nil {
-		return *m.ProxyThroughServiceUrl
+func (x *CommandLookupTopicResponse) GetProxyThroughServiceUrl() bool {
+	if x != nil && x.ProxyThroughServiceUrl != nil {
+		return *x.ProxyThroughServiceUrl
 	}
 	return Default_CommandLookupTopicResponse_ProxyThroughServiceUrl
 }
@@ -3065,6 +3369,10 @@ func (m *CommandLookupTopicResponse) GetProxyThroughServiceUrl() bool {
 /// Create a new Producer on a topic, assigning the given producer_id,
 /// all messages sent with this producer_id will be persisted on the topic
 type CommandProducer struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	Topic      *string `protobuf:"bytes,1,req,name=topic" json:"topic,omitempty"`
 	ProducerId *uint64 `protobuf:"varint,2,req,name=producer_id,json=producerId" json:"producer_id,omitempty"`
 	RequestId  *uint64 `protobuf:"varint,3,req,name=request_id,json=requestId" json:"request_id,omitempty"`
@@ -3093,143 +3401,146 @@ type CommandProducer struct {
 	// If this field is not set, the initial subscription will not be created.
 	// If this field is set but the broker's `allowAutoSubscriptionCreation`
 	// is disabled, the producer will fail to be created.
-	InitialSubscriptionName *string  `protobuf:"bytes,13,opt,name=initial_subscription_name,json=initialSubscriptionName" json:"initial_subscription_name,omitempty"`
-	XXX_NoUnkeyedLiteral    struct{} `json:"-"`
-	XXX_unrecognized        []byte   `json:"-"`
-	XXX_sizecache           int32    `json:"-"`
+	InitialSubscriptionName *string `protobuf:"bytes,13,opt,name=initial_subscription_name,json=initialSubscriptionName" json:"initial_subscription_name,omitempty"`
 }
 
-func (m *CommandProducer) Reset()         { *m = CommandProducer{} }
-func (m *CommandProducer) String() string { return proto.CompactTextString(m) }
-func (*CommandProducer) ProtoMessage()    {}
-func (*CommandProducer) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{21}
-}
-func (m *CommandProducer) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandProducer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandProducer.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for CommandProducer fields.
+const (
+	Default_CommandProducer_Encrypted                = bool(false)
+	Default_CommandProducer_Epoch                    = uint64(0)
+	Default_CommandProducer_UserProvidedProducerName = bool(true)
+	Default_CommandProducer_ProducerAccessMode       = ProducerAccessMode_Shared
+	Default_CommandProducer_TxnEnabled               = bool(false)
+)
+
+func (x *CommandProducer) Reset() {
+	*x = CommandProducer{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandProducer) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandProducer.Merge(m, src)
-}
-func (m *CommandProducer) XXX_Size() int {
-	return m.Size()
-}
-func (m *CommandProducer) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandProducer.DiscardUnknown(m)
+
+func (x *CommandProducer) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandProducer proto.InternalMessageInfo
+func (*CommandProducer) ProtoMessage() {}
+
+func (x *CommandProducer) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandProducer_Encrypted bool = false
-const Default_CommandProducer_Epoch uint64 = 0
-const Default_CommandProducer_UserProvidedProducerName bool = true
-const Default_CommandProducer_ProducerAccessMode ProducerAccessMode = ProducerAccessMode_Shared
-const Default_CommandProducer_TxnEnabled bool = false
+// Deprecated: Use CommandProducer.ProtoReflect.Descriptor instead.
+func (*CommandProducer) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{21}
+}
 
-func (m *CommandProducer) GetTopic() string {
-	if m != nil && m.Topic != nil {
-		return *m.Topic
+func (x *CommandProducer) GetTopic() string {
+	if x != nil && x.Topic != nil {
+		return *x.Topic
 	}
 	return ""
 }
 
-func (m *CommandProducer) GetProducerId() uint64 {
-	if m != nil && m.ProducerId != nil {
-		return *m.ProducerId
+func (x *CommandProducer) GetProducerId() uint64 {
+	if x != nil && x.ProducerId != nil {
+		return *x.ProducerId
 	}
 	return 0
 }
 
-func (m *CommandProducer) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandProducer) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandProducer) GetProducerName() string {
-	if m != nil && m.ProducerName != nil {
-		return *m.ProducerName
+func (x *CommandProducer) GetProducerName() string {
+	if x != nil && x.ProducerName != nil {
+		return *x.ProducerName
 	}
 	return ""
 }
 
-func (m *CommandProducer) GetEncrypted() bool {
-	if m != nil && m.Encrypted != nil {
-		return *m.Encrypted
+func (x *CommandProducer) GetEncrypted() bool {
+	if x != nil && x.Encrypted != nil {
+		return *x.Encrypted
 	}
 	return Default_CommandProducer_Encrypted
 }
 
-func (m *CommandProducer) GetMetadata() []*KeyValue {
-	if m != nil {
-		return m.Metadata
+func (x *CommandProducer) GetMetadata() []*KeyValue {
+	if x != nil {
+		return x.Metadata
 	}
 	return nil
 }
 
-func (m *CommandProducer) GetSchema() *Schema {
-	if m != nil {
-		return m.Schema
+func (x *CommandProducer) GetSchema() *Schema {
+	if x != nil {
+		return x.Schema
 	}
 	return nil
 }
 
-func (m *CommandProducer) GetEpoch() uint64 {
-	if m != nil && m.Epoch != nil {
-		return *m.Epoch
+func (x *CommandProducer) GetEpoch() uint64 {
+	if x != nil && x.Epoch != nil {
+		return *x.Epoch
 	}
 	return Default_CommandProducer_Epoch
 }
 
-func (m *CommandProducer) GetUserProvidedProducerName() bool {
-	if m != nil && m.UserProvidedProducerName != nil {
-		return *m.UserProvidedProducerName
+func (x *CommandProducer) GetUserProvidedProducerName() bool {
+	if x != nil && x.UserProvidedProducerName != nil {
+		return *x.UserProvidedProducerName
 	}
 	return Default_CommandProducer_UserProvidedProducerName
 }
 
-func (m *CommandProducer) GetProducerAccessMode() ProducerAccessMode {
-	if m != nil && m.ProducerAccessMode != nil {
-		return *m.ProducerAccessMode
+func (x *CommandProducer) GetProducerAccessMode() ProducerAccessMode {
+	if x != nil && x.ProducerAccessMode != nil {
+		return *x.ProducerAccessMode
 	}
 	return Default_CommandProducer_ProducerAccessMode
 }
 
-func (m *CommandProducer) GetTopicEpoch() uint64 {
-	if m != nil && m.TopicEpoch != nil {
-		return *m.TopicEpoch
+func (x *CommandProducer) GetTopicEpoch() uint64 {
+	if x != nil && x.TopicEpoch != nil {
+		return *x.TopicEpoch
 	}
 	return 0
 }
 
-func (m *CommandProducer) GetTxnEnabled() bool {
-	if m != nil && m.TxnEnabled != nil {
-		return *m.TxnEnabled
+func (x *CommandProducer) GetTxnEnabled() bool {
+	if x != nil && x.TxnEnabled != nil {
+		return *x.TxnEnabled
 	}
 	return Default_CommandProducer_TxnEnabled
 }
 
-func (m *CommandProducer) GetInitialSubscriptionName() string {
-	if m != nil && m.InitialSubscriptionName != nil {
-		return *m.InitialSubscriptionName
+func (x *CommandProducer) GetInitialSubscriptionName() string {
+	if x != nil && x.InitialSubscriptionName != nil {
+		return *x.InitialSubscriptionName
 	}
 	return ""
 }
 
 type CommandSend struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	ProducerId     *uint64 `protobuf:"varint,1,req,name=producer_id,json=producerId" json:"producer_id,omitempty"`
 	SequenceId     *uint64 `protobuf:"varint,2,req,name=sequence_id,json=sequenceId" json:"sequence_id,omitempty"`
 	NumMessages    *int32  `protobuf:"varint,3,opt,name=num_messages,json=numMessages,def=1" json:"num_messages,omitempty"`
@@ -3241,775 +3552,789 @@ type CommandSend struct {
 	// Specify if the message being published is a Pulsar marker or not
 	Marker *bool `protobuf:"varint,8,opt,name=marker,def=0" json:"marker,omitempty"`
 	// Message id of this message, currently is used in replicator for shadow topic.
-	MessageId            *MessageIdData `protobuf:"bytes,9,opt,name=message_id,json=messageId" json:"message_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
-	XXX_unrecognized     []byte         `json:"-"`
-	XXX_sizecache        int32          `json:"-"`
+	MessageId *MessageIdData `protobuf:"bytes,9,opt,name=message_id,json=messageId" json:"message_id,omitempty"`
 }
 
-func (m *CommandSend) Reset()         { *m = CommandSend{} }
-func (m *CommandSend) String() string { return proto.CompactTextString(m) }
-func (*CommandSend) ProtoMessage()    {}
-func (*CommandSend) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{22}
-}
-func (m *CommandSend) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandSend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandSend.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for CommandSend fields.
+const (
+	Default_CommandSend_NumMessages       = int32(1)
+	Default_CommandSend_TxnidLeastBits    = uint64(0)
+	Default_CommandSend_TxnidMostBits     = uint64(0)
+	Default_CommandSend_HighestSequenceId = uint64(0)
+	Default_CommandSend_IsChunk           = bool(false)
+	Default_CommandSend_Marker            = bool(false)
+)
+
+func (x *CommandSend) Reset() {
+	*x = CommandSend{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[22]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandSend) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandSend.Merge(m, src)
-}
-func (m *CommandSend) XXX_Size() int {
-	return m.Size()
-}
-func (m *CommandSend) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandSend.DiscardUnknown(m)
+
+func (x *CommandSend) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandSend proto.InternalMessageInfo
+func (*CommandSend) ProtoMessage() {}
+
+func (x *CommandSend) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[22]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandSend_NumMessages int32 = 1
-const Default_CommandSend_TxnidLeastBits uint64 = 0
-const Default_CommandSend_TxnidMostBits uint64 = 0
-const Default_CommandSend_HighestSequenceId uint64 = 0
-const Default_CommandSend_IsChunk bool = false
-const Default_CommandSend_Marker bool = false
+// Deprecated: Use CommandSend.ProtoReflect.Descriptor instead.
+func (*CommandSend) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{22}
+}
 
-func (m *CommandSend) GetProducerId() uint64 {
-	if m != nil && m.ProducerId != nil {
-		return *m.ProducerId
+func (x *CommandSend) GetProducerId() uint64 {
+	if x != nil && x.ProducerId != nil {
+		return *x.ProducerId
 	}
 	return 0
 }
 
-func (m *CommandSend) GetSequenceId() uint64 {
-	if m != nil && m.SequenceId != nil {
-		return *m.SequenceId
+func (x *CommandSend) GetSequenceId() uint64 {
+	if x != nil && x.SequenceId != nil {
+		return *x.SequenceId
 	}
 	return 0
 }
 
-func (m *CommandSend) GetNumMessages() int32 {
-	if m != nil && m.NumMessages != nil {
-		return *m.NumMessages
+func (x *CommandSend) GetNumMessages() int32 {
+	if x != nil && x.NumMessages != nil {
+		return *x.NumMessages
 	}
 	return Default_CommandSend_NumMessages
 }
 
-func (m *CommandSend) GetTxnidLeastBits() uint64 {
-	if m != nil && m.TxnidLeastBits != nil {
-		return *m.TxnidLeastBits
+func (x *CommandSend) GetTxnidLeastBits() uint64 {
+	if x != nil && x.TxnidLeastBits != nil {
+		return *x.TxnidLeastBits
 	}
 	return Default_CommandSend_TxnidLeastBits
 }
 
-func (m *CommandSend) GetTxnidMostBits() uint64 {
-	if m != nil && m.TxnidMostBits != nil {
-		return *m.TxnidMostBits
+func (x *CommandSend) GetTxnidMostBits() uint64 {
+	if x != nil && x.TxnidMostBits != nil {
+		return *x.TxnidMostBits
 	}
 	return Default_CommandSend_TxnidMostBits
 }
 
-func (m *CommandSend) GetHighestSequenceId() uint64 {
-	if m != nil && m.HighestSequenceId != nil {
-		return *m.HighestSequenceId
+func (x *CommandSend) GetHighestSequenceId() uint64 {
+	if x != nil && x.HighestSequenceId != nil {
+		return *x.HighestSequenceId
 	}
 	return Default_CommandSend_HighestSequenceId
 }
 
-func (m *CommandSend) GetIsChunk() bool {
-	if m != nil && m.IsChunk != nil {
-		return *m.IsChunk
+func (x *CommandSend) GetIsChunk() bool {
+	if x != nil && x.IsChunk != nil {
+		return *x.IsChunk
 	}
 	return Default_CommandSend_IsChunk
 }
 
-func (m *CommandSend) GetMarker() bool {
-	if m != nil && m.Marker != nil {
-		return *m.Marker
+func (x *CommandSend) GetMarker() bool {
+	if x != nil && x.Marker != nil {
+		return *x.Marker
 	}
 	return Default_CommandSend_Marker
 }
 
-func (m *CommandSend) GetMessageId() *MessageIdData {
-	if m != nil {
-		return m.MessageId
+func (x *CommandSend) GetMessageId() *MessageIdData {
+	if x != nil {
+		return x.MessageId
 	}
 	return nil
 }
 
 type CommandSendReceipt struct {
-	ProducerId           *uint64        `protobuf:"varint,1,req,name=producer_id,json=producerId" json:"producer_id,omitempty"`
-	SequenceId           *uint64        `protobuf:"varint,2,req,name=sequence_id,json=sequenceId" json:"sequence_id,omitempty"`
-	MessageId            *MessageIdData `protobuf:"bytes,3,opt,name=message_id,json=messageId" json:"message_id,omitempty"`
-	HighestSequenceId    *uint64        `protobuf:"varint,4,opt,name=highest_sequence_id,json=highestSequenceId,def=0" json:"highest_sequence_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
-	XXX_unrecognized     []byte         `json:"-"`
-	XXX_sizecache        int32          `json:"-"`
-}
-
-func (m *CommandSendReceipt) Reset()         { *m = CommandSendReceipt{} }
-func (m *CommandSendReceipt) String() string { return proto.CompactTextString(m) }
-func (*CommandSendReceipt) ProtoMessage()    {}
-func (*CommandSendReceipt) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{23}
-}
-func (m *CommandSendReceipt) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandSendReceipt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandSendReceipt.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *CommandSendReceipt) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandSendReceipt.Merge(m, src)
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ProducerId        *uint64        `protobuf:"varint,1,req,name=producer_id,json=producerId" json:"producer_id,omitempty"`
+	SequenceId        *uint64        `protobuf:"varint,2,req,name=sequence_id,json=sequenceId" json:"sequence_id,omitempty"`
+	MessageId         *MessageIdData `protobuf:"bytes,3,opt,name=message_id,json=messageId" json:"message_id,omitempty"`
+	HighestSequenceId *uint64        `protobuf:"varint,4,opt,name=highest_sequence_id,json=highestSequenceId,def=0" json:"highest_sequence_id,omitempty"`
 }
-func (m *CommandSendReceipt) XXX_Size() int {
-	return m.Size()
+
+// Default values for CommandSendReceipt fields.
+const (
+	Default_CommandSendReceipt_HighestSequenceId = uint64(0)
+)
+
+func (x *CommandSendReceipt) Reset() {
+	*x = CommandSendReceipt{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[23]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *CommandSendReceipt) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandSendReceipt.DiscardUnknown(m)
+
+func (x *CommandSendReceipt) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandSendReceipt proto.InternalMessageInfo
+func (*CommandSendReceipt) ProtoMessage() {}
+
+func (x *CommandSendReceipt) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[23]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandSendReceipt_HighestSequenceId uint64 = 0
+// Deprecated: Use CommandSendReceipt.ProtoReflect.Descriptor instead.
+func (*CommandSendReceipt) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{23}
+}
 
-func (m *CommandSendReceipt) GetProducerId() uint64 {
-	if m != nil && m.ProducerId != nil {
-		return *m.ProducerId
+func (x *CommandSendReceipt) GetProducerId() uint64 {
+	if x != nil && x.ProducerId != nil {
+		return *x.ProducerId
 	}
 	return 0
 }
 
-func (m *CommandSendReceipt) GetSequenceId() uint64 {
-	if m != nil && m.SequenceId != nil {
-		return *m.SequenceId
+func (x *CommandSendReceipt) GetSequenceId() uint64 {
+	if x != nil && x.SequenceId != nil {
+		return *x.SequenceId
 	}
 	return 0
 }
 
-func (m *CommandSendReceipt) GetMessageId() *MessageIdData {
-	if m != nil {
-		return m.MessageId
+func (x *CommandSendReceipt) GetMessageId() *MessageIdData {
+	if x != nil {
+		return x.MessageId
 	}
 	return nil
 }
 
-func (m *CommandSendReceipt) GetHighestSequenceId() uint64 {
-	if m != nil && m.HighestSequenceId != nil {
-		return *m.HighestSequenceId
+func (x *CommandSendReceipt) GetHighestSequenceId() uint64 {
+	if x != nil && x.HighestSequenceId != nil {
+		return *x.HighestSequenceId
 	}
 	return Default_CommandSendReceipt_HighestSequenceId
 }
 
 type CommandSendError struct {
-	ProducerId           *uint64      `protobuf:"varint,1,req,name=producer_id,json=producerId" json:"producer_id,omitempty"`
-	SequenceId           *uint64      `protobuf:"varint,2,req,name=sequence_id,json=sequenceId" json:"sequence_id,omitempty"`
-	Error                *ServerError `protobuf:"varint,3,req,name=error,enum=pulsar.proto.ServerError" json:"error,omitempty"`
-	Message              *string      `protobuf:"bytes,4,req,name=message" json:"message,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
-}
-
-func (m *CommandSendError) Reset()         { *m = CommandSendError{} }
-func (m *CommandSendError) String() string { return proto.CompactTextString(m) }
-func (*CommandSendError) ProtoMessage()    {}
-func (*CommandSendError) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{24}
-}
-func (m *CommandSendError) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandSendError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandSendError.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ProducerId *uint64      `protobuf:"varint,1,req,name=producer_id,json=producerId" json:"producer_id,omitempty"`
+	SequenceId *uint64      `protobuf:"varint,2,req,name=sequence_id,json=sequenceId" json:"sequence_id,omitempty"`
+	Error      *ServerError `protobuf:"varint,3,req,name=error,enum=pulsar.proto.ServerError" json:"error,omitempty"`
+	Message    *string      `protobuf:"bytes,4,req,name=message" json:"message,omitempty"`
 }
-func (m *CommandSendError) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandSendError.Merge(m, src)
+
+func (x *CommandSendError) Reset() {
+	*x = CommandSendError{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *CommandSendError) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandSendError) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandSendError) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandSendError.DiscardUnknown(m)
+
+func (*CommandSendError) ProtoMessage() {}
+
+func (x *CommandSendError) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandSendError proto.InternalMessageInfo
+// Deprecated: Use CommandSendError.ProtoReflect.Descriptor instead.
+func (*CommandSendError) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{24}
+}
 
-func (m *CommandSendError) GetProducerId() uint64 {
-	if m != nil && m.ProducerId != nil {
-		return *m.ProducerId
+func (x *CommandSendError) GetProducerId() uint64 {
+	if x != nil && x.ProducerId != nil {
+		return *x.ProducerId
 	}
 	return 0
 }
 
-func (m *CommandSendError) GetSequenceId() uint64 {
-	if m != nil && m.SequenceId != nil {
-		return *m.SequenceId
+func (x *CommandSendError) GetSequenceId() uint64 {
+	if x != nil && x.SequenceId != nil {
+		return *x.SequenceId
 	}
 	return 0
 }
 
-func (m *CommandSendError) GetError() ServerError {
-	if m != nil && m.Error != nil {
-		return *m.Error
+func (x *CommandSendError) GetError() ServerError {
+	if x != nil && x.Error != nil {
+		return *x.Error
 	}
 	return ServerError_UnknownError
 }
 
-func (m *CommandSendError) GetMessage() string {
-	if m != nil && m.Message != nil {
-		return *m.Message
+func (x *CommandSendError) GetMessage() string {
+	if x != nil && x.Message != nil {
+		return *x.Message
 	}
 	return ""
 }
 
 type CommandMessage struct {
-	ConsumerId           *uint64        `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
-	MessageId            *MessageIdData `protobuf:"bytes,2,req,name=message_id,json=messageId" json:"message_id,omitempty"`
-	RedeliveryCount      *uint32        `protobuf:"varint,3,opt,name=redelivery_count,json=redeliveryCount,def=0" json:"redelivery_count,omitempty"`
-	AckSet               []int64        `protobuf:"varint,4,rep,name=ack_set,json=ackSet" json:"ack_set,omitempty"`
-	ConsumerEpoch        *uint64        `protobuf:"varint,5,opt,name=consumer_epoch,json=consumerEpoch" json:"consumer_epoch,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
-	XXX_unrecognized     []byte         `json:"-"`
-	XXX_sizecache        int32          `json:"-"`
-}
-
-func (m *CommandMessage) Reset()         { *m = CommandMessage{} }
-func (m *CommandMessage) String() string { return proto.CompactTextString(m) }
-func (*CommandMessage) ProtoMessage()    {}
-func (*CommandMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{25}
-}
-func (m *CommandMessage) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandMessage.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *CommandMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandMessage.Merge(m, src)
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ConsumerId      *uint64        `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
+	MessageId       *MessageIdData `protobuf:"bytes,2,req,name=message_id,json=messageId" json:"message_id,omitempty"`
+	RedeliveryCount *uint32        `protobuf:"varint,3,opt,name=redelivery_count,json=redeliveryCount,def=0" json:"redelivery_count,omitempty"`
+	AckSet          []int64        `protobuf:"varint,4,rep,name=ack_set,json=ackSet" json:"ack_set,omitempty"`
+	ConsumerEpoch   *uint64        `protobuf:"varint,5,opt,name=consumer_epoch,json=consumerEpoch" json:"consumer_epoch,omitempty"`
 }
-func (m *CommandMessage) XXX_Size() int {
-	return m.Size()
+
+// Default values for CommandMessage fields.
+const (
+	Default_CommandMessage_RedeliveryCount = uint32(0)
+)
+
+func (x *CommandMessage) Reset() {
+	*x = CommandMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *CommandMessage) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandMessage.DiscardUnknown(m)
+
+func (x *CommandMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandMessage proto.InternalMessageInfo
+func (*CommandMessage) ProtoMessage() {}
 
-const Default_CommandMessage_RedeliveryCount uint32 = 0
+func (x *CommandMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CommandMessage.ProtoReflect.Descriptor instead.
+func (*CommandMessage) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{25}
+}
 
-func (m *CommandMessage) GetConsumerId() uint64 {
-	if m != nil && m.ConsumerId != nil {
-		return *m.ConsumerId
+func (x *CommandMessage) GetConsumerId() uint64 {
+	if x != nil && x.ConsumerId != nil {
+		return *x.ConsumerId
 	}
 	return 0
 }
 
-func (m *CommandMessage) GetMessageId() *MessageIdData {
-	if m != nil {
-		return m.MessageId
+func (x *CommandMessage) GetMessageId() *MessageIdData {
+	if x != nil {
+		return x.MessageId
 	}
 	return nil
 }
 
-func (m *CommandMessage) GetRedeliveryCount() uint32 {
-	if m != nil && m.RedeliveryCount != nil {
-		return *m.RedeliveryCount
+func (x *CommandMessage) GetRedeliveryCount() uint32 {
+	if x != nil && x.RedeliveryCount != nil {
+		return *x.RedeliveryCount
 	}
 	return Default_CommandMessage_RedeliveryCount
 }
 
-func (m *CommandMessage) GetAckSet() []int64 {
-	if m != nil {
-		return m.AckSet
+func (x *CommandMessage) GetAckSet() []int64 {
+	if x != nil {
+		return x.AckSet
 	}
 	return nil
 }
 
-func (m *CommandMessage) GetConsumerEpoch() uint64 {
-	if m != nil && m.ConsumerEpoch != nil {
-		return *m.ConsumerEpoch
+func (x *CommandMessage) GetConsumerEpoch() uint64 {
+	if x != nil && x.ConsumerEpoch != nil {
+		return *x.ConsumerEpoch
 	}
 	return 0
 }
 
 type CommandAck struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	ConsumerId *uint64             `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
 	AckType    *CommandAck_AckType `protobuf:"varint,2,req,name=ack_type,json=ackType,enum=pulsar.proto.CommandAck_AckType" json:"ack_type,omitempty"`
 	// In case of individual acks, the client can pass a list of message ids
-	MessageId            []*MessageIdData            `protobuf:"bytes,3,rep,name=message_id,json=messageId" json:"message_id,omitempty"`
-	ValidationError      *CommandAck_ValidationError `protobuf:"varint,4,opt,name=validation_error,json=validationError,enum=pulsar.proto.CommandAck_ValidationError" json:"validation_error,omitempty"`
-	Properties           []*KeyLongValue             `protobuf:"bytes,5,rep,name=properties" json:"properties,omitempty"`
-	TxnidLeastBits       *uint64                     `protobuf:"varint,6,opt,name=txnid_least_bits,json=txnidLeastBits,def=0" json:"txnid_least_bits,omitempty"`
-	TxnidMostBits        *uint64                     `protobuf:"varint,7,opt,name=txnid_most_bits,json=txnidMostBits,def=0" json:"txnid_most_bits,omitempty"`
-	RequestId            *uint64                     `protobuf:"varint,8,opt,name=request_id,json=requestId" json:"request_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
-	XXX_unrecognized     []byte                      `json:"-"`
-	XXX_sizecache        int32                       `json:"-"`
-}
-
-func (m *CommandAck) Reset()         { *m = CommandAck{} }
-func (m *CommandAck) String() string { return proto.CompactTextString(m) }
-func (*CommandAck) ProtoMessage()    {}
-func (*CommandAck) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{26}
-}
-func (m *CommandAck) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandAck.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
+	MessageId       []*MessageIdData            `protobuf:"bytes,3,rep,name=message_id,json=messageId" json:"message_id,omitempty"`
+	ValidationError *CommandAck_ValidationError `protobuf:"varint,4,opt,name=validation_error,json=validationError,enum=pulsar.proto.CommandAck_ValidationError" json:"validation_error,omitempty"`
+	Properties      []*KeyLongValue             `protobuf:"bytes,5,rep,name=properties" json:"properties,omitempty"`
+	TxnidLeastBits  *uint64                     `protobuf:"varint,6,opt,name=txnid_least_bits,json=txnidLeastBits,def=0" json:"txnid_least_bits,omitempty"`
+	TxnidMostBits   *uint64                     `protobuf:"varint,7,opt,name=txnid_most_bits,json=txnidMostBits,def=0" json:"txnid_most_bits,omitempty"`
+	RequestId       *uint64                     `protobuf:"varint,8,opt,name=request_id,json=requestId" json:"request_id,omitempty"`
 }
-func (m *CommandAck) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandAck.Merge(m, src)
-}
-func (m *CommandAck) XXX_Size() int {
-	return m.Size()
+
+// Default values for CommandAck fields.
+const (
+	Default_CommandAck_TxnidLeastBits = uint64(0)
+	Default_CommandAck_TxnidMostBits  = uint64(0)
+)
+
+func (x *CommandAck) Reset() {
+	*x = CommandAck{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *CommandAck) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandAck.DiscardUnknown(m)
+
+func (x *CommandAck) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandAck proto.InternalMessageInfo
+func (*CommandAck) ProtoMessage() {}
+
+func (x *CommandAck) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandAck_TxnidLeastBits uint64 = 0
-const Default_CommandAck_TxnidMostBits uint64 = 0
+// Deprecated: Use CommandAck.ProtoReflect.Descriptor instead.
+func (*CommandAck) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{26}
+}
 
-func (m *CommandAck) GetConsumerId() uint64 {
-	if m != nil && m.ConsumerId != nil {
-		return *m.ConsumerId
+func (x *CommandAck) GetConsumerId() uint64 {
+	if x != nil && x.ConsumerId != nil {
+		return *x.ConsumerId
 	}
 	return 0
 }
 
-func (m *CommandAck) GetAckType() CommandAck_AckType {
-	if m != nil && m.AckType != nil {
-		return *m.AckType
+func (x *CommandAck) GetAckType() CommandAck_AckType {
+	if x != nil && x.AckType != nil {
+		return *x.AckType
 	}
 	return CommandAck_Individual
 }
 
-func (m *CommandAck) GetMessageId() []*MessageIdData {
-	if m != nil {
-		return m.MessageId
+func (x *CommandAck) GetMessageId() []*MessageIdData {
+	if x != nil {
+		return x.MessageId
 	}
 	return nil
 }
 
-func (m *CommandAck) GetValidationError() CommandAck_ValidationError {
-	if m != nil && m.ValidationError != nil {
-		return *m.ValidationError
+func (x *CommandAck) GetValidationError() CommandAck_ValidationError {
+	if x != nil && x.ValidationError != nil {
+		return *x.ValidationError
 	}
 	return CommandAck_UncompressedSizeCorruption
 }
 
-func (m *CommandAck) GetProperties() []*KeyLongValue {
-	if m != nil {
-		return m.Properties
+func (x *CommandAck) GetProperties() []*KeyLongValue {
+	if x != nil {
+		return x.Properties
 	}
 	return nil
 }
 
-func (m *CommandAck) GetTxnidLeastBits() uint64 {
-	if m != nil && m.TxnidLeastBits != nil {
-		return *m.TxnidLeastBits
+func (x *CommandAck) GetTxnidLeastBits() uint64 {
+	if x != nil && x.TxnidLeastBits != nil {
+		return *x.TxnidLeastBits
 	}
 	return Default_CommandAck_TxnidLeastBits
 }
 
-func (m *CommandAck) GetTxnidMostBits() uint64 {
-	if m != nil && m.TxnidMostBits != nil {
-		return *m.TxnidMostBits
+func (x *CommandAck) GetTxnidMostBits() uint64 {
+	if x != nil && x.TxnidMostBits != nil {
+		return *x.TxnidMostBits
 	}
 	return Default_CommandAck_TxnidMostBits
 }
 
-func (m *CommandAck) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandAck) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
 type CommandAckResponse struct {
-	ConsumerId           *uint64      `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
-	TxnidLeastBits       *uint64      `protobuf:"varint,2,opt,name=txnid_least_bits,json=txnidLeastBits,def=0" json:"txnid_least_bits,omitempty"`
-	TxnidMostBits        *uint64      `protobuf:"varint,3,opt,name=txnid_most_bits,json=txnidMostBits,def=0" json:"txnid_most_bits,omitempty"`
-	Error                *ServerError `protobuf:"varint,4,opt,name=error,enum=pulsar.proto.ServerError" json:"error,omitempty"`
-	Message              *string      `protobuf:"bytes,5,opt,name=message" json:"message,omitempty"`
-	RequestId            *uint64      `protobuf:"varint,6,opt,name=request_id,json=requestId" json:"request_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
-}
-
-func (m *CommandAckResponse) Reset()         { *m = CommandAckResponse{} }
-func (m *CommandAckResponse) String() string { return proto.CompactTextString(m) }
-func (*CommandAckResponse) ProtoMessage()    {}
-func (*CommandAckResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{27}
-}
-func (m *CommandAckResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandAckResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandAckResponse.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *CommandAckResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandAckResponse.Merge(m, src)
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ConsumerId     *uint64      `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
+	TxnidLeastBits *uint64      `protobuf:"varint,2,opt,name=txnid_least_bits,json=txnidLeastBits,def=0" json:"txnid_least_bits,omitempty"`
+	TxnidMostBits  *uint64      `protobuf:"varint,3,opt,name=txnid_most_bits,json=txnidMostBits,def=0" json:"txnid_most_bits,omitempty"`
+	Error          *ServerError `protobuf:"varint,4,opt,name=error,enum=pulsar.proto.ServerError" json:"error,omitempty"`
+	Message        *string      `protobuf:"bytes,5,opt,name=message" json:"message,omitempty"`
+	RequestId      *uint64      `protobuf:"varint,6,opt,name=request_id,json=requestId" json:"request_id,omitempty"`
 }
-func (m *CommandAckResponse) XXX_Size() int {
-	return m.Size()
+
+// Default values for CommandAckResponse fields.
+const (
+	Default_CommandAckResponse_TxnidLeastBits = uint64(0)
+	Default_CommandAckResponse_TxnidMostBits  = uint64(0)
+)
+
+func (x *CommandAckResponse) Reset() {
+	*x = CommandAckResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[27]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *CommandAckResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandAckResponse.DiscardUnknown(m)
+
+func (x *CommandAckResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandAckResponse proto.InternalMessageInfo
+func (*CommandAckResponse) ProtoMessage() {}
+
+func (x *CommandAckResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[27]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandAckResponse_TxnidLeastBits uint64 = 0
-const Default_CommandAckResponse_TxnidMostBits uint64 = 0
+// Deprecated: Use CommandAckResponse.ProtoReflect.Descriptor instead.
+func (*CommandAckResponse) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{27}
+}
 
-func (m *CommandAckResponse) GetConsumerId() uint64 {
-	if m != nil && m.ConsumerId != nil {
-		return *m.ConsumerId
+func (x *CommandAckResponse) GetConsumerId() uint64 {
+	if x != nil && x.ConsumerId != nil {
+		return *x.ConsumerId
 	}
 	return 0
 }
 
-func (m *CommandAckResponse) GetTxnidLeastBits() uint64 {
-	if m != nil && m.TxnidLeastBits != nil {
-		return *m.TxnidLeastBits
+func (x *CommandAckResponse) GetTxnidLeastBits() uint64 {
+	if x != nil && x.TxnidLeastBits != nil {
+		return *x.TxnidLeastBits
 	}
 	return Default_CommandAckResponse_TxnidLeastBits
 }
 
-func (m *CommandAckResponse) GetTxnidMostBits() uint64 {
-	if m != nil && m.TxnidMostBits != nil {
-		return *m.TxnidMostBits
+func (x *CommandAckResponse) GetTxnidMostBits() uint64 {
+	if x != nil && x.TxnidMostBits != nil {
+		return *x.TxnidMostBits
 	}
 	return Default_CommandAckResponse_TxnidMostBits
 }
 
-func (m *CommandAckResponse) GetError() ServerError {
-	if m != nil && m.Error != nil {
-		return *m.Error
+func (x *CommandAckResponse) GetError() ServerError {
+	if x != nil && x.Error != nil {
+		return *x.Error
 	}
 	return ServerError_UnknownError
 }
 
-func (m *CommandAckResponse) GetMessage() string {
-	if m != nil && m.Message != nil {
-		return *m.Message
+func (x *CommandAckResponse) GetMessage() string {
+	if x != nil && x.Message != nil {
+		return *x.Message
 	}
 	return ""
 }
 
-func (m *CommandAckResponse) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandAckResponse) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
 // changes on active consumer
 type CommandActiveConsumerChange struct {
-	ConsumerId           *uint64  `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
-	IsActive             *bool    `protobuf:"varint,2,opt,name=is_active,json=isActive,def=0" json:"is_active,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ConsumerId *uint64 `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
+	IsActive   *bool   `protobuf:"varint,2,opt,name=is_active,json=isActive,def=0" json:"is_active,omitempty"`
 }
 
-func (m *CommandActiveConsumerChange) Reset()         { *m = CommandActiveConsumerChange{} }
-func (m *CommandActiveConsumerChange) String() string { return proto.CompactTextString(m) }
-func (*CommandActiveConsumerChange) ProtoMessage()    {}
-func (*CommandActiveConsumerChange) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{28}
-}
-func (m *CommandActiveConsumerChange) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandActiveConsumerChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandActiveConsumerChange.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for CommandActiveConsumerChange fields.
+const (
+	Default_CommandActiveConsumerChange_IsActive = bool(false)
+)
+
+func (x *CommandActiveConsumerChange) Reset() {
+	*x = CommandActiveConsumerChange{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[28]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandActiveConsumerChange) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandActiveConsumerChange.Merge(m, src)
-}
-func (m *CommandActiveConsumerChange) XXX_Size() int {
-	return m.Size()
-}
-func (m *CommandActiveConsumerChange) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandActiveConsumerChange.DiscardUnknown(m)
+
+func (x *CommandActiveConsumerChange) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandActiveConsumerChange proto.InternalMessageInfo
+func (*CommandActiveConsumerChange) ProtoMessage() {}
+
+func (x *CommandActiveConsumerChange) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[28]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandActiveConsumerChange_IsActive bool = false
+// Deprecated: Use CommandActiveConsumerChange.ProtoReflect.Descriptor instead.
+func (*CommandActiveConsumerChange) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{28}
+}
 
-func (m *CommandActiveConsumerChange) GetConsumerId() uint64 {
-	if m != nil && m.ConsumerId != nil {
-		return *m.ConsumerId
+func (x *CommandActiveConsumerChange) GetConsumerId() uint64 {
+	if x != nil && x.ConsumerId != nil {
+		return *x.ConsumerId
 	}
 	return 0
 }
 
-func (m *CommandActiveConsumerChange) GetIsActive() bool {
-	if m != nil && m.IsActive != nil {
-		return *m.IsActive
+func (x *CommandActiveConsumerChange) GetIsActive() bool {
+	if x != nil && x.IsActive != nil {
+		return *x.IsActive
 	}
 	return Default_CommandActiveConsumerChange_IsActive
 }
 
 type CommandFlow struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	ConsumerId *uint64 `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
 	// Max number of messages to prefetch, in addition
 	// of any number previously specified
-	MessagePermits       *uint32  `protobuf:"varint,2,req,name=messagePermits" json:"messagePermits,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	MessagePermits *uint32 `protobuf:"varint,2,req,name=messagePermits" json:"messagePermits,omitempty"`
 }
 
-func (m *CommandFlow) Reset()         { *m = CommandFlow{} }
-func (m *CommandFlow) String() string { return proto.CompactTextString(m) }
-func (*CommandFlow) ProtoMessage()    {}
-func (*CommandFlow) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{29}
-}
-func (m *CommandFlow) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandFlow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandFlow.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandFlow) Reset() {
+	*x = CommandFlow{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[29]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandFlow) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandFlow.Merge(m, src)
-}
-func (m *CommandFlow) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandFlow) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandFlow) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandFlow.DiscardUnknown(m)
+
+func (*CommandFlow) ProtoMessage() {}
+
+func (x *CommandFlow) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[29]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandFlow proto.InternalMessageInfo
+// Deprecated: Use CommandFlow.ProtoReflect.Descriptor instead.
+func (*CommandFlow) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{29}
+}
 
-func (m *CommandFlow) GetConsumerId() uint64 {
-	if m != nil && m.ConsumerId != nil {
-		return *m.ConsumerId
+func (x *CommandFlow) GetConsumerId() uint64 {
+	if x != nil && x.ConsumerId != nil {
+		return *x.ConsumerId
 	}
 	return 0
 }
 
-func (m *CommandFlow) GetMessagePermits() uint32 {
-	if m != nil && m.MessagePermits != nil {
-		return *m.MessagePermits
+func (x *CommandFlow) GetMessagePermits() uint32 {
+	if x != nil && x.MessagePermits != nil {
+		return *x.MessagePermits
 	}
 	return 0
 }
 
 type CommandUnsubscribe struct {
-	ConsumerId           *uint64  `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
-	RequestId            *uint64  `protobuf:"varint,2,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ConsumerId *uint64 `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
+	RequestId  *uint64 `protobuf:"varint,2,req,name=request_id,json=requestId" json:"request_id,omitempty"`
 }
 
-func (m *CommandUnsubscribe) Reset()         { *m = CommandUnsubscribe{} }
-func (m *CommandUnsubscribe) String() string { return proto.CompactTextString(m) }
-func (*CommandUnsubscribe) ProtoMessage()    {}
-func (*CommandUnsubscribe) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{30}
-}
-func (m *CommandUnsubscribe) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandUnsubscribe) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandUnsubscribe.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandUnsubscribe) Reset() {
+	*x = CommandUnsubscribe{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[30]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandUnsubscribe) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandUnsubscribe.Merge(m, src)
-}
-func (m *CommandUnsubscribe) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandUnsubscribe) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandUnsubscribe) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandUnsubscribe.DiscardUnknown(m)
+
+func (*CommandUnsubscribe) ProtoMessage() {}
+
+func (x *CommandUnsubscribe) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[30]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandUnsubscribe proto.InternalMessageInfo
+// Deprecated: Use CommandUnsubscribe.ProtoReflect.Descriptor instead.
+func (*CommandUnsubscribe) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{30}
+}
 
-func (m *CommandUnsubscribe) GetConsumerId() uint64 {
-	if m != nil && m.ConsumerId != nil {
-		return *m.ConsumerId
+func (x *CommandUnsubscribe) GetConsumerId() uint64 {
+	if x != nil && x.ConsumerId != nil {
+		return *x.ConsumerId
 	}
 	return 0
 }
 
-func (m *CommandUnsubscribe) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandUnsubscribe) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
 // Reset an existing consumer to a particular message id
 type CommandSeek struct {
-	ConsumerId           *uint64        `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
-	RequestId            *uint64        `protobuf:"varint,2,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	MessageId            *MessageIdData `protobuf:"bytes,3,opt,name=message_id,json=messageId" json:"message_id,omitempty"`
-	MessagePublishTime   *uint64        `protobuf:"varint,4,opt,name=message_publish_time,json=messagePublishTime" json:"message_publish_time,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
-	XXX_unrecognized     []byte         `json:"-"`
-	XXX_sizecache        int32          `json:"-"`
-}
-
-func (m *CommandSeek) Reset()         { *m = CommandSeek{} }
-func (m *CommandSeek) String() string { return proto.CompactTextString(m) }
-func (*CommandSeek) ProtoMessage()    {}
-func (*CommandSeek) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{31}
-}
-func (m *CommandSeek) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandSeek) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandSeek.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ConsumerId         *uint64        `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
+	RequestId          *uint64        `protobuf:"varint,2,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+	MessageId          *MessageIdData `protobuf:"bytes,3,opt,name=message_id,json=messageId" json:"message_id,omitempty"`
+	MessagePublishTime *uint64        `protobuf:"varint,4,opt,name=message_publish_time,json=messagePublishTime" json:"message_publish_time,omitempty"`
 }
-func (m *CommandSeek) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandSeek.Merge(m, src)
+
+func (x *CommandSeek) Reset() {
+	*x = CommandSeek{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[31]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *CommandSeek) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandSeek) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandSeek) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandSeek.DiscardUnknown(m)
+
+func (*CommandSeek) ProtoMessage() {}
+
+func (x *CommandSeek) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[31]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandSeek proto.InternalMessageInfo
+// Deprecated: Use CommandSeek.ProtoReflect.Descriptor instead.
+func (*CommandSeek) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{31}
+}
 
-func (m *CommandSeek) GetConsumerId() uint64 {
-	if m != nil && m.ConsumerId != nil {
-		return *m.ConsumerId
+func (x *CommandSeek) GetConsumerId() uint64 {
+	if x != nil && x.ConsumerId != nil {
+		return *x.ConsumerId
 	}
 	return 0
 }
 
-func (m *CommandSeek) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandSeek) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandSeek) GetMessageId() *MessageIdData {
-	if m != nil {
-		return m.MessageId
+func (x *CommandSeek) GetMessageId() *MessageIdData {
+	if x != nil {
+		return x.MessageId
 	}
 	return nil
 }
 
-func (m *CommandSeek) GetMessagePublishTime() uint64 {
-	if m != nil && m.MessagePublishTime != nil {
-		return *m.MessagePublishTime
+func (x *CommandSeek) GetMessagePublishTime() uint64 {
+	if x != nil && x.MessagePublishTime != nil {
+		return *x.MessagePublishTime
 	}
 	return 0
 }
@@ -4018,284 +4343,286 @@ func (m *CommandSeek) GetMessagePublishTime() uint64 {
 // has been forcefully terminated and there are no more
 // messages left to consume
 type CommandReachedEndOfTopic struct {
-	ConsumerId           *uint64  `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ConsumerId *uint64 `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
 }
 
-func (m *CommandReachedEndOfTopic) Reset()         { *m = CommandReachedEndOfTopic{} }
-func (m *CommandReachedEndOfTopic) String() string { return proto.CompactTextString(m) }
-func (*CommandReachedEndOfTopic) ProtoMessage()    {}
-func (*CommandReachedEndOfTopic) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{32}
-}
-func (m *CommandReachedEndOfTopic) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandReachedEndOfTopic) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandReachedEndOfTopic.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandReachedEndOfTopic) Reset() {
+	*x = CommandReachedEndOfTopic{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[32]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandReachedEndOfTopic) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandReachedEndOfTopic.Merge(m, src)
-}
-func (m *CommandReachedEndOfTopic) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandReachedEndOfTopic) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandReachedEndOfTopic) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandReachedEndOfTopic.DiscardUnknown(m)
+
+func (*CommandReachedEndOfTopic) ProtoMessage() {}
+
+func (x *CommandReachedEndOfTopic) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[32]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandReachedEndOfTopic proto.InternalMessageInfo
+// Deprecated: Use CommandReachedEndOfTopic.ProtoReflect.Descriptor instead.
+func (*CommandReachedEndOfTopic) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{32}
+}
 
-func (m *CommandReachedEndOfTopic) GetConsumerId() uint64 {
-	if m != nil && m.ConsumerId != nil {
-		return *m.ConsumerId
+func (x *CommandReachedEndOfTopic) GetConsumerId() uint64 {
+	if x != nil && x.ConsumerId != nil {
+		return *x.ConsumerId
 	}
 	return 0
 }
 
 type CommandCloseProducer struct {
-	ProducerId           *uint64  `protobuf:"varint,1,req,name=producer_id,json=producerId" json:"producer_id,omitempty"`
-	RequestId            *uint64  `protobuf:"varint,2,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ProducerId *uint64 `protobuf:"varint,1,req,name=producer_id,json=producerId" json:"producer_id,omitempty"`
+	RequestId  *uint64 `protobuf:"varint,2,req,name=request_id,json=requestId" json:"request_id,omitempty"`
 }
 
-func (m *CommandCloseProducer) Reset()         { *m = CommandCloseProducer{} }
-func (m *CommandCloseProducer) String() string { return proto.CompactTextString(m) }
-func (*CommandCloseProducer) ProtoMessage()    {}
-func (*CommandCloseProducer) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{33}
-}
-func (m *CommandCloseProducer) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandCloseProducer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandCloseProducer.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandCloseProducer) Reset() {
+	*x = CommandCloseProducer{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[33]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandCloseProducer) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandCloseProducer.Merge(m, src)
-}
-func (m *CommandCloseProducer) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandCloseProducer) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandCloseProducer) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandCloseProducer.DiscardUnknown(m)
+
+func (*CommandCloseProducer) ProtoMessage() {}
+
+func (x *CommandCloseProducer) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[33]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandCloseProducer proto.InternalMessageInfo
+// Deprecated: Use CommandCloseProducer.ProtoReflect.Descriptor instead.
+func (*CommandCloseProducer) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{33}
+}
 
-func (m *CommandCloseProducer) GetProducerId() uint64 {
-	if m != nil && m.ProducerId != nil {
-		return *m.ProducerId
+func (x *CommandCloseProducer) GetProducerId() uint64 {
+	if x != nil && x.ProducerId != nil {
+		return *x.ProducerId
 	}
 	return 0
 }
 
-func (m *CommandCloseProducer) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandCloseProducer) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
 type CommandCloseConsumer struct {
-	ConsumerId           *uint64  `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
-	RequestId            *uint64  `protobuf:"varint,2,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ConsumerId *uint64 `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
+	RequestId  *uint64 `protobuf:"varint,2,req,name=request_id,json=requestId" json:"request_id,omitempty"`
 }
 
-func (m *CommandCloseConsumer) Reset()         { *m = CommandCloseConsumer{} }
-func (m *CommandCloseConsumer) String() string { return proto.CompactTextString(m) }
-func (*CommandCloseConsumer) ProtoMessage()    {}
-func (*CommandCloseConsumer) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{34}
-}
-func (m *CommandCloseConsumer) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandCloseConsumer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandCloseConsumer.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandCloseConsumer) Reset() {
+	*x = CommandCloseConsumer{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[34]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandCloseConsumer) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandCloseConsumer.Merge(m, src)
-}
-func (m *CommandCloseConsumer) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandCloseConsumer) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandCloseConsumer) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandCloseConsumer.DiscardUnknown(m)
+
+func (*CommandCloseConsumer) ProtoMessage() {}
+
+func (x *CommandCloseConsumer) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[34]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandCloseConsumer proto.InternalMessageInfo
+// Deprecated: Use CommandCloseConsumer.ProtoReflect.Descriptor instead.
+func (*CommandCloseConsumer) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{34}
+}
 
-func (m *CommandCloseConsumer) GetConsumerId() uint64 {
-	if m != nil && m.ConsumerId != nil {
-		return *m.ConsumerId
+func (x *CommandCloseConsumer) GetConsumerId() uint64 {
+	if x != nil && x.ConsumerId != nil {
+		return *x.ConsumerId
 	}
 	return 0
 }
 
-func (m *CommandCloseConsumer) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandCloseConsumer) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
 type CommandRedeliverUnacknowledgedMessages struct {
-	ConsumerId           *uint64          `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
-	MessageIds           []*MessageIdData `protobuf:"bytes,2,rep,name=message_ids,json=messageIds" json:"message_ids,omitempty"`
-	ConsumerEpoch        *uint64          `protobuf:"varint,3,opt,name=consumer_epoch,json=consumerEpoch" json:"consumer_epoch,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
-	XXX_unrecognized     []byte           `json:"-"`
-	XXX_sizecache        int32            `json:"-"`
-}
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 
-func (m *CommandRedeliverUnacknowledgedMessages) Reset() {
-	*m = CommandRedeliverUnacknowledgedMessages{}
+	ConsumerId    *uint64          `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
+	MessageIds    []*MessageIdData `protobuf:"bytes,2,rep,name=message_ids,json=messageIds" json:"message_ids,omitempty"`
+	ConsumerEpoch *uint64          `protobuf:"varint,3,opt,name=consumer_epoch,json=consumerEpoch" json:"consumer_epoch,omitempty"`
 }
-func (m *CommandRedeliverUnacknowledgedMessages) String() string { return proto.CompactTextString(m) }
-func (*CommandRedeliverUnacknowledgedMessages) ProtoMessage()    {}
-func (*CommandRedeliverUnacknowledgedMessages) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{35}
-}
-func (m *CommandRedeliverUnacknowledgedMessages) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandRedeliverUnacknowledgedMessages) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandRedeliverUnacknowledgedMessages.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+
+func (x *CommandRedeliverUnacknowledgedMessages) Reset() {
+	*x = CommandRedeliverUnacknowledgedMessages{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[35]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandRedeliverUnacknowledgedMessages) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandRedeliverUnacknowledgedMessages.Merge(m, src)
-}
-func (m *CommandRedeliverUnacknowledgedMessages) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandRedeliverUnacknowledgedMessages) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandRedeliverUnacknowledgedMessages) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandRedeliverUnacknowledgedMessages.DiscardUnknown(m)
+
+func (*CommandRedeliverUnacknowledgedMessages) ProtoMessage() {}
+
+func (x *CommandRedeliverUnacknowledgedMessages) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[35]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandRedeliverUnacknowledgedMessages proto.InternalMessageInfo
+// Deprecated: Use CommandRedeliverUnacknowledgedMessages.ProtoReflect.Descriptor instead.
+func (*CommandRedeliverUnacknowledgedMessages) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{35}
+}
 
-func (m *CommandRedeliverUnacknowledgedMessages) GetConsumerId() uint64 {
-	if m != nil && m.ConsumerId != nil {
-		return *m.ConsumerId
+func (x *CommandRedeliverUnacknowledgedMessages) GetConsumerId() uint64 {
+	if x != nil && x.ConsumerId != nil {
+		return *x.ConsumerId
 	}
 	return 0
 }
 
-func (m *CommandRedeliverUnacknowledgedMessages) GetMessageIds() []*MessageIdData {
-	if m != nil {
-		return m.MessageIds
+func (x *CommandRedeliverUnacknowledgedMessages) GetMessageIds() []*MessageIdData {
+	if x != nil {
+		return x.MessageIds
 	}
 	return nil
 }
 
-func (m *CommandRedeliverUnacknowledgedMessages) GetConsumerEpoch() uint64 {
-	if m != nil && m.ConsumerEpoch != nil {
-		return *m.ConsumerEpoch
+func (x *CommandRedeliverUnacknowledgedMessages) GetConsumerEpoch() uint64 {
+	if x != nil && x.ConsumerEpoch != nil {
+		return *x.ConsumerEpoch
 	}
 	return 0
 }
 
 type CommandSuccess struct {
-	RequestId            *uint64  `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	Schema               *Schema  `protobuf:"bytes,2,opt,name=schema" json:"schema,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequestId *uint64 `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+	Schema    *Schema `protobuf:"bytes,2,opt,name=schema" json:"schema,omitempty"`
 }
 
-func (m *CommandSuccess) Reset()         { *m = CommandSuccess{} }
-func (m *CommandSuccess) String() string { return proto.CompactTextString(m) }
-func (*CommandSuccess) ProtoMessage()    {}
-func (*CommandSuccess) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{36}
-}
-func (m *CommandSuccess) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandSuccess) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandSuccess.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandSuccess) Reset() {
+	*x = CommandSuccess{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[36]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandSuccess) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandSuccess.Merge(m, src)
-}
-func (m *CommandSuccess) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandSuccess) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandSuccess) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandSuccess.DiscardUnknown(m)
+
+func (*CommandSuccess) ProtoMessage() {}
+
+func (x *CommandSuccess) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[36]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandSuccess proto.InternalMessageInfo
+// Deprecated: Use CommandSuccess.ProtoReflect.Descriptor instead.
+func (*CommandSuccess) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{36}
+}
 
-func (m *CommandSuccess) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandSuccess) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandSuccess) GetSchema() *Schema {
-	if m != nil {
-		return m.Schema
+func (x *CommandSuccess) GetSchema() *Schema {
+	if x != nil {
+		return x.Schema
 	}
 	return nil
 }
 
 /// Response from CommandProducer
 type CommandProducerSuccess struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	RequestId    *uint64 `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
 	ProducerName *string `protobuf:"bytes,2,req,name=producer_name,json=producerName" json:"producer_name,omitempty"`
 	// The last sequence id that was stored by this producer in the previous session
@@ -4308,149 +4635,148 @@ type CommandProducerSuccess struct {
 	// If producer is not "ready", the client will avoid to timeout the request
 	// for creating the producer. Instead it will wait indefinitely until it gets
 	// a subsequent  `CommandProducerSuccess` with `producer_ready==true`.
-	ProducerReady        *bool    `protobuf:"varint,6,opt,name=producer_ready,json=producerReady,def=1" json:"producer_ready,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	ProducerReady *bool `protobuf:"varint,6,opt,name=producer_ready,json=producerReady,def=1" json:"producer_ready,omitempty"`
 }
 
-func (m *CommandProducerSuccess) Reset()         { *m = CommandProducerSuccess{} }
-func (m *CommandProducerSuccess) String() string { return proto.CompactTextString(m) }
-func (*CommandProducerSuccess) ProtoMessage()    {}
-func (*CommandProducerSuccess) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{37}
-}
-func (m *CommandProducerSuccess) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandProducerSuccess) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandProducerSuccess.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for CommandProducerSuccess fields.
+const (
+	Default_CommandProducerSuccess_LastSequenceId = int64(-1)
+	Default_CommandProducerSuccess_ProducerReady  = bool(true)
+)
+
+func (x *CommandProducerSuccess) Reset() {
+	*x = CommandProducerSuccess{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[37]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandProducerSuccess) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandProducerSuccess.Merge(m, src)
-}
-func (m *CommandProducerSuccess) XXX_Size() int {
-	return m.Size()
-}
-func (m *CommandProducerSuccess) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandProducerSuccess.DiscardUnknown(m)
+
+func (x *CommandProducerSuccess) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandProducerSuccess proto.InternalMessageInfo
+func (*CommandProducerSuccess) ProtoMessage() {}
 
-const Default_CommandProducerSuccess_LastSequenceId int64 = -1
-const Default_CommandProducerSuccess_ProducerReady bool = true
+func (x *CommandProducerSuccess) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[37]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CommandProducerSuccess.ProtoReflect.Descriptor instead.
+func (*CommandProducerSuccess) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{37}
+}
 
-func (m *CommandProducerSuccess) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandProducerSuccess) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandProducerSuccess) GetProducerName() string {
-	if m != nil && m.ProducerName != nil {
-		return *m.ProducerName
+func (x *CommandProducerSuccess) GetProducerName() string {
+	if x != nil && x.ProducerName != nil {
+		return *x.ProducerName
 	}
 	return ""
 }
 
-func (m *CommandProducerSuccess) GetLastSequenceId() int64 {
-	if m != nil && m.LastSequenceId != nil {
-		return *m.LastSequenceId
+func (x *CommandProducerSuccess) GetLastSequenceId() int64 {
+	if x != nil && x.LastSequenceId != nil {
+		return *x.LastSequenceId
 	}
 	return Default_CommandProducerSuccess_LastSequenceId
 }
 
-func (m *CommandProducerSuccess) GetSchemaVersion() []byte {
-	if m != nil {
-		return m.SchemaVersion
+func (x *CommandProducerSuccess) GetSchemaVersion() []byte {
+	if x != nil {
+		return x.SchemaVersion
 	}
 	return nil
 }
 
-func (m *CommandProducerSuccess) GetTopicEpoch() uint64 {
-	if m != nil && m.TopicEpoch != nil {
-		return *m.TopicEpoch
+func (x *CommandProducerSuccess) GetTopicEpoch() uint64 {
+	if x != nil && x.TopicEpoch != nil {
+		return *x.TopicEpoch
 	}
 	return 0
 }
 
-func (m *CommandProducerSuccess) GetProducerReady() bool {
-	if m != nil && m.ProducerReady != nil {
-		return *m.ProducerReady
+func (x *CommandProducerSuccess) GetProducerReady() bool {
+	if x != nil && x.ProducerReady != nil {
+		return *x.ProducerReady
 	}
 	return Default_CommandProducerSuccess_ProducerReady
 }
 
 type CommandError struct {
-	RequestId            *uint64      `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	Error                *ServerError `protobuf:"varint,2,req,name=error,enum=pulsar.proto.ServerError" json:"error,omitempty"`
-	Message              *string      `protobuf:"bytes,3,req,name=message" json:"message,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequestId *uint64      `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+	Error     *ServerError `protobuf:"varint,2,req,name=error,enum=pulsar.proto.ServerError" json:"error,omitempty"`
+	Message   *string      `protobuf:"bytes,3,req,name=message" json:"message,omitempty"`
 }
 
-func (m *CommandError) Reset()         { *m = CommandError{} }
-func (m *CommandError) String() string { return proto.CompactTextString(m) }
-func (*CommandError) ProtoMessage()    {}
-func (*CommandError) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{38}
-}
-func (m *CommandError) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandError.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandError) Reset() {
+	*x = CommandError{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[38]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandError) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandError.Merge(m, src)
-}
-func (m *CommandError) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandError) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandError) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandError.DiscardUnknown(m)
+
+func (*CommandError) ProtoMessage() {}
+
+func (x *CommandError) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[38]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandError proto.InternalMessageInfo
+// Deprecated: Use CommandError.ProtoReflect.Descriptor instead.
+func (*CommandError) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{38}
+}
 
-func (m *CommandError) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandError) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandError) GetError() ServerError {
-	if m != nil && m.Error != nil {
-		return *m.Error
+func (x *CommandError) GetError() ServerError {
+	if x != nil && x.Error != nil {
+		return *x.Error
 	}
 	return ServerError_UnknownError
 }
 
-func (m *CommandError) GetMessage() string {
-	if m != nil && m.Message != nil {
-		return *m.Message
+func (x *CommandError) GetMessage() string {
+	if x != nil && x.Message != nil {
+		return *x.Message
 	}
 	return ""
 }
@@ -4459,141 +4785,143 @@ func (m *CommandError) GetMessage() string {
 // When either client or broker doesn't receive commands for certain
 // amount of time, they will send a Ping probe.
 type CommandPing struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (m *CommandPing) Reset()         { *m = CommandPing{} }
-func (m *CommandPing) String() string { return proto.CompactTextString(m) }
-func (*CommandPing) ProtoMessage()    {}
-func (*CommandPing) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{39}
-}
-func (m *CommandPing) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandPing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandPing.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandPing) Reset() {
+	*x = CommandPing{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[39]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandPing) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandPing.Merge(m, src)
-}
-func (m *CommandPing) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandPing) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandPing) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandPing.DiscardUnknown(m)
+
+func (*CommandPing) ProtoMessage() {}
+
+func (x *CommandPing) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[39]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandPing proto.InternalMessageInfo
+// Deprecated: Use CommandPing.ProtoReflect.Descriptor instead.
+func (*CommandPing) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{39}
+}
 
 type CommandPong struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (m *CommandPong) Reset()         { *m = CommandPong{} }
-func (m *CommandPong) String() string { return proto.CompactTextString(m) }
-func (*CommandPong) ProtoMessage()    {}
-func (*CommandPong) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{40}
-}
-func (m *CommandPong) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandPong) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandPong.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandPong) Reset() {
+	*x = CommandPong{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[40]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandPong) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandPong.Merge(m, src)
-}
-func (m *CommandPong) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandPong) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandPong) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandPong.DiscardUnknown(m)
+
+func (*CommandPong) ProtoMessage() {}
+
+func (x *CommandPong) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[40]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandPong proto.InternalMessageInfo
+// Deprecated: Use CommandPong.ProtoReflect.Descriptor instead.
+func (*CommandPong) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{40}
+}
 
 type CommandConsumerStats struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	RequestId *uint64 `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
 	// required string topic_name         = 2;
 	// required string subscription_name  = 3;
-	ConsumerId           *uint64  `protobuf:"varint,4,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	ConsumerId *uint64 `protobuf:"varint,4,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
 }
 
-func (m *CommandConsumerStats) Reset()         { *m = CommandConsumerStats{} }
-func (m *CommandConsumerStats) String() string { return proto.CompactTextString(m) }
-func (*CommandConsumerStats) ProtoMessage()    {}
-func (*CommandConsumerStats) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{41}
-}
-func (m *CommandConsumerStats) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandConsumerStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandConsumerStats.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandConsumerStats) Reset() {
+	*x = CommandConsumerStats{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[41]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandConsumerStats) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandConsumerStats.Merge(m, src)
-}
-func (m *CommandConsumerStats) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandConsumerStats) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandConsumerStats) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandConsumerStats.DiscardUnknown(m)
+
+func (*CommandConsumerStats) ProtoMessage() {}
+
+func (x *CommandConsumerStats) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[41]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandConsumerStats proto.InternalMessageInfo
+// Deprecated: Use CommandConsumerStats.ProtoReflect.Descriptor instead.
+func (*CommandConsumerStats) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{41}
+}
 
-func (m *CommandConsumerStats) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandConsumerStats) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandConsumerStats) GetConsumerId() uint64 {
-	if m != nil && m.ConsumerId != nil {
-		return *m.ConsumerId
+func (x *CommandConsumerStats) GetConsumerId() uint64 {
+	if x != nil && x.ConsumerId != nil {
+		return *x.ConsumerId
 	}
 	return 0
 }
 
 type CommandConsumerStatsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	RequestId    *uint64      `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
 	ErrorCode    *ServerError `protobuf:"varint,2,opt,name=error_code,json=errorCode,enum=pulsar.proto.ServerError" json:"error_code,omitempty"`
 	ErrorMessage *string      `protobuf:"bytes,3,opt,name=error_message,json=errorMessage" json:"error_message,omitempty"`
@@ -4622,357 +4950,360 @@ type CommandConsumerStatsResponse struct {
 	/// Number of messages in the subscription backlog
 	MsgBacklog *uint64 `protobuf:"varint,15,opt,name=msgBacklog" json:"msgBacklog,omitempty"`
 	/// Total rate of messages ack. msg/s
-	MessageAckRate       *float64 `protobuf:"fixed64,16,opt,name=messageAckRate" json:"messageAckRate,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	MessageAckRate *float64 `protobuf:"fixed64,16,opt,name=messageAckRate" json:"messageAckRate,omitempty"`
 }
 
-func (m *CommandConsumerStatsResponse) Reset()         { *m = CommandConsumerStatsResponse{} }
-func (m *CommandConsumerStatsResponse) String() string { return proto.CompactTextString(m) }
-func (*CommandConsumerStatsResponse) ProtoMessage()    {}
-func (*CommandConsumerStatsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{42}
-}
-func (m *CommandConsumerStatsResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandConsumerStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandConsumerStatsResponse.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandConsumerStatsResponse) Reset() {
+	*x = CommandConsumerStatsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[42]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandConsumerStatsResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandConsumerStatsResponse.Merge(m, src)
-}
-func (m *CommandConsumerStatsResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *CommandConsumerStatsResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandConsumerStatsResponse.DiscardUnknown(m)
+
+func (x *CommandConsumerStatsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandConsumerStatsResponse proto.InternalMessageInfo
+func (*CommandConsumerStatsResponse) ProtoMessage() {}
 
-func (m *CommandConsumerStatsResponse) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandConsumerStatsResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[42]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	return 0
+	return mi.MessageOf(x)
 }
 
-func (m *CommandConsumerStatsResponse) GetErrorCode() ServerError {
-	if m != nil && m.ErrorCode != nil {
-		return *m.ErrorCode
+// Deprecated: Use CommandConsumerStatsResponse.ProtoReflect.Descriptor instead.
+func (*CommandConsumerStatsResponse) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{42}
+}
+
+func (x *CommandConsumerStatsResponse) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
+	}
+	return 0
+}
+
+func (x *CommandConsumerStatsResponse) GetErrorCode() ServerError {
+	if x != nil && x.ErrorCode != nil {
+		return *x.ErrorCode
 	}
 	return ServerError_UnknownError
 }
 
-func (m *CommandConsumerStatsResponse) GetErrorMessage() string {
-	if m != nil && m.ErrorMessage != nil {
-		return *m.ErrorMessage
+func (x *CommandConsumerStatsResponse) GetErrorMessage() string {
+	if x != nil && x.ErrorMessage != nil {
+		return *x.ErrorMessage
 	}
 	return ""
 }
 
-func (m *CommandConsumerStatsResponse) GetMsgRateOut() float64 {
-	if m != nil && m.MsgRateOut != nil {
-		return *m.MsgRateOut
+func (x *CommandConsumerStatsResponse) GetMsgRateOut() float64 {
+	if x != nil && x.MsgRateOut != nil {
+		return *x.MsgRateOut
 	}
 	return 0
 }
 
-func (m *CommandConsumerStatsResponse) GetMsgThroughputOut() float64 {
-	if m != nil && m.MsgThroughputOut != nil {
-		return *m.MsgThroughputOut
+func (x *CommandConsumerStatsResponse) GetMsgThroughputOut() float64 {
+	if x != nil && x.MsgThroughputOut != nil {
+		return *x.MsgThroughputOut
 	}
 	return 0
 }
 
-func (m *CommandConsumerStatsResponse) GetMsgRateRedeliver() float64 {
-	if m != nil && m.MsgRateRedeliver != nil {
-		return *m.MsgRateRedeliver
+func (x *CommandConsumerStatsResponse) GetMsgRateRedeliver() float64 {
+	if x != nil && x.MsgRateRedeliver != nil {
+		return *x.MsgRateRedeliver
 	}
 	return 0
 }
 
-func (m *CommandConsumerStatsResponse) GetConsumerName() string {
-	if m != nil && m.ConsumerName != nil {
-		return *m.ConsumerName
+func (x *CommandConsumerStatsResponse) GetConsumerName() string {
+	if x != nil && x.ConsumerName != nil {
+		return *x.ConsumerName
 	}
 	return ""
 }
 
-func (m *CommandConsumerStatsResponse) GetAvailablePermits() uint64 {
-	if m != nil && m.AvailablePermits != nil {
-		return *m.AvailablePermits
+func (x *CommandConsumerStatsResponse) GetAvailablePermits() uint64 {
+	if x != nil && x.AvailablePermits != nil {
+		return *x.AvailablePermits
 	}
 	return 0
 }
 
-func (m *CommandConsumerStatsResponse) GetUnackedMessages() uint64 {
-	if m != nil && m.UnackedMessages != nil {
-		return *m.UnackedMessages
+func (x *CommandConsumerStatsResponse) GetUnackedMessages() uint64 {
+	if x != nil && x.UnackedMessages != nil {
+		return *x.UnackedMessages
 	}
 	return 0
 }
 
-func (m *CommandConsumerStatsResponse) GetBlockedConsumerOnUnackedMsgs() bool {
-	if m != nil && m.BlockedConsumerOnUnackedMsgs != nil {
-		return *m.BlockedConsumerOnUnackedMsgs
+func (x *CommandConsumerStatsResponse) GetBlockedConsumerOnUnackedMsgs() bool {
+	if x != nil && x.BlockedConsumerOnUnackedMsgs != nil {
+		return *x.BlockedConsumerOnUnackedMsgs
 	}
 	return false
 }
 
-func (m *CommandConsumerStatsResponse) GetAddress() string {
-	if m != nil && m.Address != nil {
-		return *m.Address
+func (x *CommandConsumerStatsResponse) GetAddress() string {
+	if x != nil && x.Address != nil {
+		return *x.Address
 	}
 	return ""
 }
 
-func (m *CommandConsumerStatsResponse) GetConnectedSince() string {
-	if m != nil && m.ConnectedSince != nil {
-		return *m.ConnectedSince
+func (x *CommandConsumerStatsResponse) GetConnectedSince() string {
+	if x != nil && x.ConnectedSince != nil {
+		return *x.ConnectedSince
 	}
 	return ""
 }
 
-func (m *CommandConsumerStatsResponse) GetType() string {
-	if m != nil && m.Type != nil {
-		return *m.Type
+func (x *CommandConsumerStatsResponse) GetType() string {
+	if x != nil && x.Type != nil {
+		return *x.Type
 	}
 	return ""
 }
 
-func (m *CommandConsumerStatsResponse) GetMsgRateExpired() float64 {
-	if m != nil && m.MsgRateExpired != nil {
-		return *m.MsgRateExpired
+func (x *CommandConsumerStatsResponse) GetMsgRateExpired() float64 {
+	if x != nil && x.MsgRateExpired != nil {
+		return *x.MsgRateExpired
 	}
 	return 0
 }
 
-func (m *CommandConsumerStatsResponse) GetMsgBacklog() uint64 {
-	if m != nil && m.MsgBacklog != nil {
-		return *m.MsgBacklog
+func (x *CommandConsumerStatsResponse) GetMsgBacklog() uint64 {
+	if x != nil && x.MsgBacklog != nil {
+		return *x.MsgBacklog
 	}
 	return 0
 }
 
-func (m *CommandConsumerStatsResponse) GetMessageAckRate() float64 {
-	if m != nil && m.MessageAckRate != nil {
-		return *m.MessageAckRate
+func (x *CommandConsumerStatsResponse) GetMessageAckRate() float64 {
+	if x != nil && x.MessageAckRate != nil {
+		return *x.MessageAckRate
 	}
 	return 0
 }
 
 type CommandGetLastMessageId struct {
-	ConsumerId           *uint64  `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
-	RequestId            *uint64  `protobuf:"varint,2,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ConsumerId *uint64 `protobuf:"varint,1,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
+	RequestId  *uint64 `protobuf:"varint,2,req,name=request_id,json=requestId" json:"request_id,omitempty"`
 }
 
-func (m *CommandGetLastMessageId) Reset()         { *m = CommandGetLastMessageId{} }
-func (m *CommandGetLastMessageId) String() string { return proto.CompactTextString(m) }
-func (*CommandGetLastMessageId) ProtoMessage()    {}
-func (*CommandGetLastMessageId) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{43}
-}
-func (m *CommandGetLastMessageId) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandGetLastMessageId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandGetLastMessageId.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandGetLastMessageId) Reset() {
+	*x = CommandGetLastMessageId{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[43]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandGetLastMessageId) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandGetLastMessageId.Merge(m, src)
-}
-func (m *CommandGetLastMessageId) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandGetLastMessageId) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandGetLastMessageId) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandGetLastMessageId.DiscardUnknown(m)
+
+func (*CommandGetLastMessageId) ProtoMessage() {}
+
+func (x *CommandGetLastMessageId) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[43]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandGetLastMessageId proto.InternalMessageInfo
+// Deprecated: Use CommandGetLastMessageId.ProtoReflect.Descriptor instead.
+func (*CommandGetLastMessageId) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{43}
+}
 
-func (m *CommandGetLastMessageId) GetConsumerId() uint64 {
-	if m != nil && m.ConsumerId != nil {
-		return *m.ConsumerId
+func (x *CommandGetLastMessageId) GetConsumerId() uint64 {
+	if x != nil && x.ConsumerId != nil {
+		return *x.ConsumerId
 	}
 	return 0
 }
 
-func (m *CommandGetLastMessageId) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandGetLastMessageId) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
 type CommandGetLastMessageIdResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	LastMessageId              *MessageIdData `protobuf:"bytes,1,req,name=last_message_id,json=lastMessageId" json:"last_message_id,omitempty"`
 	RequestId                  *uint64        `protobuf:"varint,2,req,name=request_id,json=requestId" json:"request_id,omitempty"`
 	ConsumerMarkDeletePosition *MessageIdData `protobuf:"bytes,3,opt,name=consumer_mark_delete_position,json=consumerMarkDeletePosition" json:"consumer_mark_delete_position,omitempty"`
-	XXX_NoUnkeyedLiteral       struct{}       `json:"-"`
-	XXX_unrecognized           []byte         `json:"-"`
-	XXX_sizecache              int32          `json:"-"`
 }
 
-func (m *CommandGetLastMessageIdResponse) Reset()         { *m = CommandGetLastMessageIdResponse{} }
-func (m *CommandGetLastMessageIdResponse) String() string { return proto.CompactTextString(m) }
-func (*CommandGetLastMessageIdResponse) ProtoMessage()    {}
-func (*CommandGetLastMessageIdResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{44}
-}
-func (m *CommandGetLastMessageIdResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandGetLastMessageIdResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandGetLastMessageIdResponse.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandGetLastMessageIdResponse) Reset() {
+	*x = CommandGetLastMessageIdResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[44]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandGetLastMessageIdResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandGetLastMessageIdResponse.Merge(m, src)
-}
-func (m *CommandGetLastMessageIdResponse) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandGetLastMessageIdResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandGetLastMessageIdResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandGetLastMessageIdResponse.DiscardUnknown(m)
+
+func (*CommandGetLastMessageIdResponse) ProtoMessage() {}
+
+func (x *CommandGetLastMessageIdResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[44]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandGetLastMessageIdResponse proto.InternalMessageInfo
+// Deprecated: Use CommandGetLastMessageIdResponse.ProtoReflect.Descriptor instead.
+func (*CommandGetLastMessageIdResponse) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{44}
+}
 
-func (m *CommandGetLastMessageIdResponse) GetLastMessageId() *MessageIdData {
-	if m != nil {
-		return m.LastMessageId
+func (x *CommandGetLastMessageIdResponse) GetLastMessageId() *MessageIdData {
+	if x != nil {
+		return x.LastMessageId
 	}
 	return nil
 }
 
-func (m *CommandGetLastMessageIdResponse) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandGetLastMessageIdResponse) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandGetLastMessageIdResponse) GetConsumerMarkDeletePosition() *MessageIdData {
-	if m != nil {
-		return m.ConsumerMarkDeletePosition
+func (x *CommandGetLastMessageIdResponse) GetConsumerMarkDeletePosition() *MessageIdData {
+	if x != nil {
+		return x.ConsumerMarkDeletePosition
 	}
 	return nil
 }
 
 type CommandGetTopicsOfNamespace struct {
-	RequestId            *uint64                           `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	Namespace            *string                           `protobuf:"bytes,2,req,name=namespace" json:"namespace,omitempty"`
-	Mode                 *CommandGetTopicsOfNamespace_Mode `protobuf:"varint,3,opt,name=mode,enum=pulsar.proto.CommandGetTopicsOfNamespace_Mode,def=0" json:"mode,omitempty"`
-	TopicsPattern        *string                           `protobuf:"bytes,4,opt,name=topics_pattern,json=topicsPattern" json:"topics_pattern,omitempty"`
-	TopicsHash           *string                           `protobuf:"bytes,5,opt,name=topics_hash,json=topicsHash" json:"topics_hash,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
-	XXX_unrecognized     []byte                            `json:"-"`
-	XXX_sizecache        int32                             `json:"-"`
-}
-
-func (m *CommandGetTopicsOfNamespace) Reset()         { *m = CommandGetTopicsOfNamespace{} }
-func (m *CommandGetTopicsOfNamespace) String() string { return proto.CompactTextString(m) }
-func (*CommandGetTopicsOfNamespace) ProtoMessage()    {}
-func (*CommandGetTopicsOfNamespace) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{45}
-}
-func (m *CommandGetTopicsOfNamespace) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandGetTopicsOfNamespace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandGetTopicsOfNamespace.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *CommandGetTopicsOfNamespace) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandGetTopicsOfNamespace.Merge(m, src)
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequestId     *uint64                           `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+	Namespace     *string                           `protobuf:"bytes,2,req,name=namespace" json:"namespace,omitempty"`
+	Mode          *CommandGetTopicsOfNamespace_Mode `protobuf:"varint,3,opt,name=mode,enum=pulsar.proto.CommandGetTopicsOfNamespace_Mode,def=0" json:"mode,omitempty"`
+	TopicsPattern *string                           `protobuf:"bytes,4,opt,name=topics_pattern,json=topicsPattern" json:"topics_pattern,omitempty"`
+	TopicsHash    *string                           `protobuf:"bytes,5,opt,name=topics_hash,json=topicsHash" json:"topics_hash,omitempty"`
 }
-func (m *CommandGetTopicsOfNamespace) XXX_Size() int {
-	return m.Size()
+
+// Default values for CommandGetTopicsOfNamespace fields.
+const (
+	Default_CommandGetTopicsOfNamespace_Mode = CommandGetTopicsOfNamespace_PERSISTENT
+)
+
+func (x *CommandGetTopicsOfNamespace) Reset() {
+	*x = CommandGetTopicsOfNamespace{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[45]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *CommandGetTopicsOfNamespace) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandGetTopicsOfNamespace.DiscardUnknown(m)
+
+func (x *CommandGetTopicsOfNamespace) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandGetTopicsOfNamespace proto.InternalMessageInfo
+func (*CommandGetTopicsOfNamespace) ProtoMessage() {}
+
+func (x *CommandGetTopicsOfNamespace) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[45]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandGetTopicsOfNamespace_Mode CommandGetTopicsOfNamespace_Mode = CommandGetTopicsOfNamespace_PERSISTENT
+// Deprecated: Use CommandGetTopicsOfNamespace.ProtoReflect.Descriptor instead.
+func (*CommandGetTopicsOfNamespace) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{45}
+}
 
-func (m *CommandGetTopicsOfNamespace) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandGetTopicsOfNamespace) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandGetTopicsOfNamespace) GetNamespace() string {
-	if m != nil && m.Namespace != nil {
-		return *m.Namespace
+func (x *CommandGetTopicsOfNamespace) GetNamespace() string {
+	if x != nil && x.Namespace != nil {
+		return *x.Namespace
 	}
 	return ""
 }
 
-func (m *CommandGetTopicsOfNamespace) GetMode() CommandGetTopicsOfNamespace_Mode {
-	if m != nil && m.Mode != nil {
-		return *m.Mode
+func (x *CommandGetTopicsOfNamespace) GetMode() CommandGetTopicsOfNamespace_Mode {
+	if x != nil && x.Mode != nil {
+		return *x.Mode
 	}
 	return Default_CommandGetTopicsOfNamespace_Mode
 }
 
-func (m *CommandGetTopicsOfNamespace) GetTopicsPattern() string {
-	if m != nil && m.TopicsPattern != nil {
-		return *m.TopicsPattern
+func (x *CommandGetTopicsOfNamespace) GetTopicsPattern() string {
+	if x != nil && x.TopicsPattern != nil {
+		return *x.TopicsPattern
 	}
 	return ""
 }
 
-func (m *CommandGetTopicsOfNamespace) GetTopicsHash() string {
-	if m != nil && m.TopicsHash != nil {
-		return *m.TopicsHash
+func (x *CommandGetTopicsOfNamespace) GetTopicsHash() string {
+	if x != nil && x.TopicsHash != nil {
+		return *x.TopicsHash
 	}
 	return ""
 }
 
 type CommandGetTopicsOfNamespaceResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	RequestId *uint64  `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
 	Topics    []string `protobuf:"bytes,2,rep,name=topics" json:"topics,omitempty"`
 	// true iff the topic list was filtered by the pattern supplied by the client
@@ -4980,1772 +5311,1814 @@ type CommandGetTopicsOfNamespaceResponse struct {
 	// hash computed from the names of matching topics
 	TopicsHash *string `protobuf:"bytes,4,opt,name=topics_hash,json=topicsHash" json:"topics_hash,omitempty"`
 	// if false, topics is empty and the list of matching topics has not changed
-	Changed              *bool    `protobuf:"varint,5,opt,name=changed,def=1" json:"changed,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Changed *bool `protobuf:"varint,5,opt,name=changed,def=1" json:"changed,omitempty"`
 }
 
-func (m *CommandGetTopicsOfNamespaceResponse) Reset()         { *m = CommandGetTopicsOfNamespaceResponse{} }
-func (m *CommandGetTopicsOfNamespaceResponse) String() string { return proto.CompactTextString(m) }
-func (*CommandGetTopicsOfNamespaceResponse) ProtoMessage()    {}
-func (*CommandGetTopicsOfNamespaceResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{46}
-}
-func (m *CommandGetTopicsOfNamespaceResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandGetTopicsOfNamespaceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandGetTopicsOfNamespaceResponse.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for CommandGetTopicsOfNamespaceResponse fields.
+const (
+	Default_CommandGetTopicsOfNamespaceResponse_Filtered = bool(false)
+	Default_CommandGetTopicsOfNamespaceResponse_Changed  = bool(true)
+)
+
+func (x *CommandGetTopicsOfNamespaceResponse) Reset() {
+	*x = CommandGetTopicsOfNamespaceResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[46]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandGetTopicsOfNamespaceResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandGetTopicsOfNamespaceResponse.Merge(m, src)
-}
-func (m *CommandGetTopicsOfNamespaceResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *CommandGetTopicsOfNamespaceResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandGetTopicsOfNamespaceResponse.DiscardUnknown(m)
+
+func (x *CommandGetTopicsOfNamespaceResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandGetTopicsOfNamespaceResponse proto.InternalMessageInfo
+func (*CommandGetTopicsOfNamespaceResponse) ProtoMessage() {}
 
-const Default_CommandGetTopicsOfNamespaceResponse_Filtered bool = false
-const Default_CommandGetTopicsOfNamespaceResponse_Changed bool = true
+func (x *CommandGetTopicsOfNamespaceResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[46]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CommandGetTopicsOfNamespaceResponse.ProtoReflect.Descriptor instead.
+func (*CommandGetTopicsOfNamespaceResponse) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{46}
+}
 
-func (m *CommandGetTopicsOfNamespaceResponse) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandGetTopicsOfNamespaceResponse) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandGetTopicsOfNamespaceResponse) GetTopics() []string {
-	if m != nil {
-		return m.Topics
+func (x *CommandGetTopicsOfNamespaceResponse) GetTopics() []string {
+	if x != nil {
+		return x.Topics
 	}
 	return nil
 }
 
-func (m *CommandGetTopicsOfNamespaceResponse) GetFiltered() bool {
-	if m != nil && m.Filtered != nil {
-		return *m.Filtered
+func (x *CommandGetTopicsOfNamespaceResponse) GetFiltered() bool {
+	if x != nil && x.Filtered != nil {
+		return *x.Filtered
 	}
 	return Default_CommandGetTopicsOfNamespaceResponse_Filtered
 }
 
-func (m *CommandGetTopicsOfNamespaceResponse) GetTopicsHash() string {
-	if m != nil && m.TopicsHash != nil {
-		return *m.TopicsHash
+func (x *CommandGetTopicsOfNamespaceResponse) GetTopicsHash() string {
+	if x != nil && x.TopicsHash != nil {
+		return *x.TopicsHash
 	}
 	return ""
 }
 
-func (m *CommandGetTopicsOfNamespaceResponse) GetChanged() bool {
-	if m != nil && m.Changed != nil {
-		return *m.Changed
+func (x *CommandGetTopicsOfNamespaceResponse) GetChanged() bool {
+	if x != nil && x.Changed != nil {
+		return *x.Changed
 	}
 	return Default_CommandGetTopicsOfNamespaceResponse_Changed
 }
 
 type CommandWatchTopicList struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
 	RequestId     *uint64 `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
 	WatcherId     *uint64 `protobuf:"varint,2,req,name=watcher_id,json=watcherId" json:"watcher_id,omitempty"`
 	Namespace     *string `protobuf:"bytes,3,req,name=namespace" json:"namespace,omitempty"`
 	TopicsPattern *string `protobuf:"bytes,4,req,name=topics_pattern,json=topicsPattern" json:"topics_pattern,omitempty"`
 	// Only present when the client reconnects:
-	TopicsHash           *string  `protobuf:"bytes,5,opt,name=topics_hash,json=topicsHash" json:"topics_hash,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	TopicsHash *string `protobuf:"bytes,5,opt,name=topics_hash,json=topicsHash" json:"topics_hash,omitempty"`
 }
 
-func (m *CommandWatchTopicList) Reset()         { *m = CommandWatchTopicList{} }
-func (m *CommandWatchTopicList) String() string { return proto.CompactTextString(m) }
-func (*CommandWatchTopicList) ProtoMessage()    {}
-func (*CommandWatchTopicList) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{47}
-}
-func (m *CommandWatchTopicList) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandWatchTopicList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandWatchTopicList.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandWatchTopicList) Reset() {
+	*x = CommandWatchTopicList{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[47]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandWatchTopicList) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandWatchTopicList.Merge(m, src)
-}
-func (m *CommandWatchTopicList) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandWatchTopicList) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandWatchTopicList) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandWatchTopicList.DiscardUnknown(m)
+
+func (*CommandWatchTopicList) ProtoMessage() {}
+
+func (x *CommandWatchTopicList) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[47]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandWatchTopicList proto.InternalMessageInfo
+// Deprecated: Use CommandWatchTopicList.ProtoReflect.Descriptor instead.
+func (*CommandWatchTopicList) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{47}
+}
 
-func (m *CommandWatchTopicList) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandWatchTopicList) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandWatchTopicList) GetWatcherId() uint64 {
-	if m != nil && m.WatcherId != nil {
-		return *m.WatcherId
+func (x *CommandWatchTopicList) GetWatcherId() uint64 {
+	if x != nil && x.WatcherId != nil {
+		return *x.WatcherId
 	}
 	return 0
 }
 
-func (m *CommandWatchTopicList) GetNamespace() string {
-	if m != nil && m.Namespace != nil {
-		return *m.Namespace
+func (x *CommandWatchTopicList) GetNamespace() string {
+	if x != nil && x.Namespace != nil {
+		return *x.Namespace
 	}
 	return ""
 }
 
-func (m *CommandWatchTopicList) GetTopicsPattern() string {
-	if m != nil && m.TopicsPattern != nil {
-		return *m.TopicsPattern
+func (x *CommandWatchTopicList) GetTopicsPattern() string {
+	if x != nil && x.TopicsPattern != nil {
+		return *x.TopicsPattern
 	}
 	return ""
 }
 
-func (m *CommandWatchTopicList) GetTopicsHash() string {
-	if m != nil && m.TopicsHash != nil {
-		return *m.TopicsHash
+func (x *CommandWatchTopicList) GetTopicsHash() string {
+	if x != nil && x.TopicsHash != nil {
+		return *x.TopicsHash
 	}
 	return ""
 }
 
 type CommandWatchTopicListSuccess struct {
-	RequestId            *uint64  `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	WatcherId            *uint64  `protobuf:"varint,2,req,name=watcher_id,json=watcherId" json:"watcher_id,omitempty"`
-	Topic                []string `protobuf:"bytes,3,rep,name=topic" json:"topic,omitempty"`
-	TopicsHash           *string  `protobuf:"bytes,4,req,name=topics_hash,json=topicsHash" json:"topics_hash,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *CommandWatchTopicListSuccess) Reset()         { *m = CommandWatchTopicListSuccess{} }
-func (m *CommandWatchTopicListSuccess) String() string { return proto.CompactTextString(m) }
-func (*CommandWatchTopicListSuccess) ProtoMessage()    {}
-func (*CommandWatchTopicListSuccess) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{48}
-}
-func (m *CommandWatchTopicListSuccess) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandWatchTopicListSuccess) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandWatchTopicListSuccess.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequestId  *uint64  `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+	WatcherId  *uint64  `protobuf:"varint,2,req,name=watcher_id,json=watcherId" json:"watcher_id,omitempty"`
+	Topic      []string `protobuf:"bytes,3,rep,name=topic" json:"topic,omitempty"`
+	TopicsHash *string  `protobuf:"bytes,4,req,name=topics_hash,json=topicsHash" json:"topics_hash,omitempty"`
 }
-func (m *CommandWatchTopicListSuccess) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandWatchTopicListSuccess.Merge(m, src)
+
+func (x *CommandWatchTopicListSuccess) Reset() {
+	*x = CommandWatchTopicListSuccess{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[48]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *CommandWatchTopicListSuccess) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandWatchTopicListSuccess) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandWatchTopicListSuccess) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandWatchTopicListSuccess.DiscardUnknown(m)
+
+func (*CommandWatchTopicListSuccess) ProtoMessage() {}
+
+func (x *CommandWatchTopicListSuccess) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[48]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandWatchTopicListSuccess proto.InternalMessageInfo
+// Deprecated: Use CommandWatchTopicListSuccess.ProtoReflect.Descriptor instead.
+func (*CommandWatchTopicListSuccess) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{48}
+}
 
-func (m *CommandWatchTopicListSuccess) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandWatchTopicListSuccess) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandWatchTopicListSuccess) GetWatcherId() uint64 {
-	if m != nil && m.WatcherId != nil {
-		return *m.WatcherId
+func (x *CommandWatchTopicListSuccess) GetWatcherId() uint64 {
+	if x != nil && x.WatcherId != nil {
+		return *x.WatcherId
 	}
 	return 0
 }
 
-func (m *CommandWatchTopicListSuccess) GetTopic() []string {
-	if m != nil {
-		return m.Topic
+func (x *CommandWatchTopicListSuccess) GetTopic() []string {
+	if x != nil {
+		return x.Topic
 	}
 	return nil
 }
 
-func (m *CommandWatchTopicListSuccess) GetTopicsHash() string {
-	if m != nil && m.TopicsHash != nil {
-		return *m.TopicsHash
+func (x *CommandWatchTopicListSuccess) GetTopicsHash() string {
+	if x != nil && x.TopicsHash != nil {
+		return *x.TopicsHash
 	}
 	return ""
 }
 
 type CommandWatchTopicUpdate struct {
-	WatcherId            *uint64  `protobuf:"varint,1,req,name=watcher_id,json=watcherId" json:"watcher_id,omitempty"`
-	NewTopics            []string `protobuf:"bytes,2,rep,name=new_topics,json=newTopics" json:"new_topics,omitempty"`
-	DeletedTopics        []string `protobuf:"bytes,3,rep,name=deleted_topics,json=deletedTopics" json:"deleted_topics,omitempty"`
-	TopicsHash           *string  `protobuf:"bytes,4,req,name=topics_hash,json=topicsHash" json:"topics_hash,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *CommandWatchTopicUpdate) Reset()         { *m = CommandWatchTopicUpdate{} }
-func (m *CommandWatchTopicUpdate) String() string { return proto.CompactTextString(m) }
-func (*CommandWatchTopicUpdate) ProtoMessage()    {}
-func (*CommandWatchTopicUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{49}
-}
-func (m *CommandWatchTopicUpdate) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandWatchTopicUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandWatchTopicUpdate.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	WatcherId     *uint64  `protobuf:"varint,1,req,name=watcher_id,json=watcherId" json:"watcher_id,omitempty"`
+	NewTopics     []string `protobuf:"bytes,2,rep,name=new_topics,json=newTopics" json:"new_topics,omitempty"`
+	DeletedTopics []string `protobuf:"bytes,3,rep,name=deleted_topics,json=deletedTopics" json:"deleted_topics,omitempty"`
+	TopicsHash    *string  `protobuf:"bytes,4,req,name=topics_hash,json=topicsHash" json:"topics_hash,omitempty"`
 }
-func (m *CommandWatchTopicUpdate) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandWatchTopicUpdate.Merge(m, src)
+
+func (x *CommandWatchTopicUpdate) Reset() {
+	*x = CommandWatchTopicUpdate{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[49]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *CommandWatchTopicUpdate) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandWatchTopicUpdate) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandWatchTopicUpdate) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandWatchTopicUpdate.DiscardUnknown(m)
+
+func (*CommandWatchTopicUpdate) ProtoMessage() {}
+
+func (x *CommandWatchTopicUpdate) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[49]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandWatchTopicUpdate proto.InternalMessageInfo
+// Deprecated: Use CommandWatchTopicUpdate.ProtoReflect.Descriptor instead.
+func (*CommandWatchTopicUpdate) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{49}
+}
 
-func (m *CommandWatchTopicUpdate) GetWatcherId() uint64 {
-	if m != nil && m.WatcherId != nil {
-		return *m.WatcherId
+func (x *CommandWatchTopicUpdate) GetWatcherId() uint64 {
+	if x != nil && x.WatcherId != nil {
+		return *x.WatcherId
 	}
 	return 0
 }
 
-func (m *CommandWatchTopicUpdate) GetNewTopics() []string {
-	if m != nil {
-		return m.NewTopics
+func (x *CommandWatchTopicUpdate) GetNewTopics() []string {
+	if x != nil {
+		return x.NewTopics
 	}
 	return nil
 }
 
-func (m *CommandWatchTopicUpdate) GetDeletedTopics() []string {
-	if m != nil {
-		return m.DeletedTopics
+func (x *CommandWatchTopicUpdate) GetDeletedTopics() []string {
+	if x != nil {
+		return x.DeletedTopics
 	}
 	return nil
 }
 
-func (m *CommandWatchTopicUpdate) GetTopicsHash() string {
-	if m != nil && m.TopicsHash != nil {
-		return *m.TopicsHash
+func (x *CommandWatchTopicUpdate) GetTopicsHash() string {
+	if x != nil && x.TopicsHash != nil {
+		return *x.TopicsHash
 	}
 	return ""
 }
 
 type CommandWatchTopicListClose struct {
-	RequestId            *uint64  `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	WatcherId            *uint64  `protobuf:"varint,2,req,name=watcher_id,json=watcherId" json:"watcher_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequestId *uint64 `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+	WatcherId *uint64 `protobuf:"varint,2,req,name=watcher_id,json=watcherId" json:"watcher_id,omitempty"`
 }
 
-func (m *CommandWatchTopicListClose) Reset()         { *m = CommandWatchTopicListClose{} }
-func (m *CommandWatchTopicListClose) String() string { return proto.CompactTextString(m) }
-func (*CommandWatchTopicListClose) ProtoMessage()    {}
-func (*CommandWatchTopicListClose) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{50}
-}
-func (m *CommandWatchTopicListClose) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandWatchTopicListClose) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandWatchTopicListClose.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandWatchTopicListClose) Reset() {
+	*x = CommandWatchTopicListClose{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[50]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandWatchTopicListClose) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandWatchTopicListClose.Merge(m, src)
-}
-func (m *CommandWatchTopicListClose) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandWatchTopicListClose) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandWatchTopicListClose) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandWatchTopicListClose.DiscardUnknown(m)
+
+func (*CommandWatchTopicListClose) ProtoMessage() {}
+
+func (x *CommandWatchTopicListClose) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[50]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandWatchTopicListClose proto.InternalMessageInfo
+// Deprecated: Use CommandWatchTopicListClose.ProtoReflect.Descriptor instead.
+func (*CommandWatchTopicListClose) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{50}
+}
 
-func (m *CommandWatchTopicListClose) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandWatchTopicListClose) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandWatchTopicListClose) GetWatcherId() uint64 {
-	if m != nil && m.WatcherId != nil {
-		return *m.WatcherId
+func (x *CommandWatchTopicListClose) GetWatcherId() uint64 {
+	if x != nil && x.WatcherId != nil {
+		return *x.WatcherId
 	}
 	return 0
 }
 
 type CommandGetSchema struct {
-	RequestId            *uint64  `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	Topic                *string  `protobuf:"bytes,2,req,name=topic" json:"topic,omitempty"`
-	SchemaVersion        []byte   `protobuf:"bytes,3,opt,name=schema_version,json=schemaVersion" json:"schema_version,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequestId     *uint64 `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+	Topic         *string `protobuf:"bytes,2,req,name=topic" json:"topic,omitempty"`
+	SchemaVersion []byte  `protobuf:"bytes,3,opt,name=schema_version,json=schemaVersion" json:"schema_version,omitempty"`
 }
 
-func (m *CommandGetSchema) Reset()         { *m = CommandGetSchema{} }
-func (m *CommandGetSchema) String() string { return proto.CompactTextString(m) }
-func (*CommandGetSchema) ProtoMessage()    {}
-func (*CommandGetSchema) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{51}
-}
-func (m *CommandGetSchema) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandGetSchema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandGetSchema.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandGetSchema) Reset() {
+	*x = CommandGetSchema{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[51]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandGetSchema) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandGetSchema.Merge(m, src)
-}
-func (m *CommandGetSchema) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandGetSchema) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandGetSchema) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandGetSchema.DiscardUnknown(m)
+
+func (*CommandGetSchema) ProtoMessage() {}
+
+func (x *CommandGetSchema) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[51]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandGetSchema proto.InternalMessageInfo
+// Deprecated: Use CommandGetSchema.ProtoReflect.Descriptor instead.
+func (*CommandGetSchema) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{51}
+}
 
-func (m *CommandGetSchema) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandGetSchema) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandGetSchema) GetTopic() string {
-	if m != nil && m.Topic != nil {
-		return *m.Topic
+func (x *CommandGetSchema) GetTopic() string {
+	if x != nil && x.Topic != nil {
+		return *x.Topic
 	}
 	return ""
 }
 
-func (m *CommandGetSchema) GetSchemaVersion() []byte {
-	if m != nil {
-		return m.SchemaVersion
+func (x *CommandGetSchema) GetSchemaVersion() []byte {
+	if x != nil {
+		return x.SchemaVersion
 	}
 	return nil
 }
 
 type CommandGetSchemaResponse struct {
-	RequestId            *uint64      `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	ErrorCode            *ServerError `protobuf:"varint,2,opt,name=error_code,json=errorCode,enum=pulsar.proto.ServerError" json:"error_code,omitempty"`
-	ErrorMessage         *string      `protobuf:"bytes,3,opt,name=error_message,json=errorMessage" json:"error_message,omitempty"`
-	Schema               *Schema      `protobuf:"bytes,4,opt,name=schema" json:"schema,omitempty"`
-	SchemaVersion        []byte       `protobuf:"bytes,5,opt,name=schema_version,json=schemaVersion" json:"schema_version,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
-}
-
-func (m *CommandGetSchemaResponse) Reset()         { *m = CommandGetSchemaResponse{} }
-func (m *CommandGetSchemaResponse) String() string { return proto.CompactTextString(m) }
-func (*CommandGetSchemaResponse) ProtoMessage()    {}
-func (*CommandGetSchemaResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{52}
-}
-func (m *CommandGetSchemaResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandGetSchemaResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandGetSchemaResponse.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequestId     *uint64      `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+	ErrorCode     *ServerError `protobuf:"varint,2,opt,name=error_code,json=errorCode,enum=pulsar.proto.ServerError" json:"error_code,omitempty"`
+	ErrorMessage  *string      `protobuf:"bytes,3,opt,name=error_message,json=errorMessage" json:"error_message,omitempty"`
+	Schema        *Schema      `protobuf:"bytes,4,opt,name=schema" json:"schema,omitempty"`
+	SchemaVersion []byte       `protobuf:"bytes,5,opt,name=schema_version,json=schemaVersion" json:"schema_version,omitempty"`
 }
-func (m *CommandGetSchemaResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandGetSchemaResponse.Merge(m, src)
+
+func (x *CommandGetSchemaResponse) Reset() {
+	*x = CommandGetSchemaResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[52]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *CommandGetSchemaResponse) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandGetSchemaResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandGetSchemaResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandGetSchemaResponse.DiscardUnknown(m)
+
+func (*CommandGetSchemaResponse) ProtoMessage() {}
+
+func (x *CommandGetSchemaResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[52]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandGetSchemaResponse proto.InternalMessageInfo
+// Deprecated: Use CommandGetSchemaResponse.ProtoReflect.Descriptor instead.
+func (*CommandGetSchemaResponse) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{52}
+}
 
-func (m *CommandGetSchemaResponse) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandGetSchemaResponse) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandGetSchemaResponse) GetErrorCode() ServerError {
-	if m != nil && m.ErrorCode != nil {
-		return *m.ErrorCode
+func (x *CommandGetSchemaResponse) GetErrorCode() ServerError {
+	if x != nil && x.ErrorCode != nil {
+		return *x.ErrorCode
 	}
 	return ServerError_UnknownError
 }
 
-func (m *CommandGetSchemaResponse) GetErrorMessage() string {
-	if m != nil && m.ErrorMessage != nil {
-		return *m.ErrorMessage
+func (x *CommandGetSchemaResponse) GetErrorMessage() string {
+	if x != nil && x.ErrorMessage != nil {
+		return *x.ErrorMessage
 	}
 	return ""
 }
 
-func (m *CommandGetSchemaResponse) GetSchema() *Schema {
-	if m != nil {
-		return m.Schema
+func (x *CommandGetSchemaResponse) GetSchema() *Schema {
+	if x != nil {
+		return x.Schema
 	}
 	return nil
 }
 
-func (m *CommandGetSchemaResponse) GetSchemaVersion() []byte {
-	if m != nil {
-		return m.SchemaVersion
+func (x *CommandGetSchemaResponse) GetSchemaVersion() []byte {
+	if x != nil {
+		return x.SchemaVersion
 	}
 	return nil
 }
 
 type CommandGetOrCreateSchema struct {
-	RequestId            *uint64  `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	Topic                *string  `protobuf:"bytes,2,req,name=topic" json:"topic,omitempty"`
-	Schema               *Schema  `protobuf:"bytes,3,req,name=schema" json:"schema,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequestId *uint64 `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+	Topic     *string `protobuf:"bytes,2,req,name=topic" json:"topic,omitempty"`
+	Schema    *Schema `protobuf:"bytes,3,req,name=schema" json:"schema,omitempty"`
 }
 
-func (m *CommandGetOrCreateSchema) Reset()         { *m = CommandGetOrCreateSchema{} }
-func (m *CommandGetOrCreateSchema) String() string { return proto.CompactTextString(m) }
-func (*CommandGetOrCreateSchema) ProtoMessage()    {}
-func (*CommandGetOrCreateSchema) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{53}
-}
-func (m *CommandGetOrCreateSchema) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandGetOrCreateSchema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandGetOrCreateSchema.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandGetOrCreateSchema) Reset() {
+	*x = CommandGetOrCreateSchema{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[53]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandGetOrCreateSchema) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandGetOrCreateSchema.Merge(m, src)
-}
-func (m *CommandGetOrCreateSchema) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandGetOrCreateSchema) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandGetOrCreateSchema) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandGetOrCreateSchema.DiscardUnknown(m)
+
+func (*CommandGetOrCreateSchema) ProtoMessage() {}
+
+func (x *CommandGetOrCreateSchema) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[53]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandGetOrCreateSchema proto.InternalMessageInfo
+// Deprecated: Use CommandGetOrCreateSchema.ProtoReflect.Descriptor instead.
+func (*CommandGetOrCreateSchema) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{53}
+}
 
-func (m *CommandGetOrCreateSchema) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandGetOrCreateSchema) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandGetOrCreateSchema) GetTopic() string {
-	if m != nil && m.Topic != nil {
-		return *m.Topic
+func (x *CommandGetOrCreateSchema) GetTopic() string {
+	if x != nil && x.Topic != nil {
+		return *x.Topic
 	}
 	return ""
 }
 
-func (m *CommandGetOrCreateSchema) GetSchema() *Schema {
-	if m != nil {
-		return m.Schema
+func (x *CommandGetOrCreateSchema) GetSchema() *Schema {
+	if x != nil {
+		return x.Schema
 	}
 	return nil
 }
 
 type CommandGetOrCreateSchemaResponse struct {
-	RequestId            *uint64      `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	ErrorCode            *ServerError `protobuf:"varint,2,opt,name=error_code,json=errorCode,enum=pulsar.proto.ServerError" json:"error_code,omitempty"`
-	ErrorMessage         *string      `protobuf:"bytes,3,opt,name=error_message,json=errorMessage" json:"error_message,omitempty"`
-	SchemaVersion        []byte       `protobuf:"bytes,4,opt,name=schema_version,json=schemaVersion" json:"schema_version,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
-}
-
-func (m *CommandGetOrCreateSchemaResponse) Reset()         { *m = CommandGetOrCreateSchemaResponse{} }
-func (m *CommandGetOrCreateSchemaResponse) String() string { return proto.CompactTextString(m) }
-func (*CommandGetOrCreateSchemaResponse) ProtoMessage()    {}
-func (*CommandGetOrCreateSchemaResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{54}
-}
-func (m *CommandGetOrCreateSchemaResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandGetOrCreateSchemaResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandGetOrCreateSchemaResponse.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequestId     *uint64      `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+	ErrorCode     *ServerError `protobuf:"varint,2,opt,name=error_code,json=errorCode,enum=pulsar.proto.ServerError" json:"error_code,omitempty"`
+	ErrorMessage  *string      `protobuf:"bytes,3,opt,name=error_message,json=errorMessage" json:"error_message,omitempty"`
+	SchemaVersion []byte       `protobuf:"bytes,4,opt,name=schema_version,json=schemaVersion" json:"schema_version,omitempty"`
 }
-func (m *CommandGetOrCreateSchemaResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandGetOrCreateSchemaResponse.Merge(m, src)
+
+func (x *CommandGetOrCreateSchemaResponse) Reset() {
+	*x = CommandGetOrCreateSchemaResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[54]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *CommandGetOrCreateSchemaResponse) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandGetOrCreateSchemaResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandGetOrCreateSchemaResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandGetOrCreateSchemaResponse.DiscardUnknown(m)
+
+func (*CommandGetOrCreateSchemaResponse) ProtoMessage() {}
+
+func (x *CommandGetOrCreateSchemaResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[54]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandGetOrCreateSchemaResponse proto.InternalMessageInfo
+// Deprecated: Use CommandGetOrCreateSchemaResponse.ProtoReflect.Descriptor instead.
+func (*CommandGetOrCreateSchemaResponse) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{54}
+}
 
-func (m *CommandGetOrCreateSchemaResponse) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandGetOrCreateSchemaResponse) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandGetOrCreateSchemaResponse) GetErrorCode() ServerError {
-	if m != nil && m.ErrorCode != nil {
-		return *m.ErrorCode
+func (x *CommandGetOrCreateSchemaResponse) GetErrorCode() ServerError {
+	if x != nil && x.ErrorCode != nil {
+		return *x.ErrorCode
 	}
 	return ServerError_UnknownError
 }
 
-func (m *CommandGetOrCreateSchemaResponse) GetErrorMessage() string {
-	if m != nil && m.ErrorMessage != nil {
-		return *m.ErrorMessage
+func (x *CommandGetOrCreateSchemaResponse) GetErrorMessage() string {
+	if x != nil && x.ErrorMessage != nil {
+		return *x.ErrorMessage
 	}
 	return ""
 }
 
-func (m *CommandGetOrCreateSchemaResponse) GetSchemaVersion() []byte {
-	if m != nil {
-		return m.SchemaVersion
+func (x *CommandGetOrCreateSchemaResponse) GetSchemaVersion() []byte {
+	if x != nil {
+		return x.SchemaVersion
 	}
 	return nil
 }
 
 type CommandTcClientConnectRequest struct {
-	RequestId            *uint64  `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	TcId                 *uint64  `protobuf:"varint,2,req,name=tc_id,json=tcId,def=0" json:"tc_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequestId *uint64 `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+	TcId      *uint64 `protobuf:"varint,2,req,name=tc_id,json=tcId,def=0" json:"tc_id,omitempty"`
 }
 
-func (m *CommandTcClientConnectRequest) Reset()         { *m = CommandTcClientConnectRequest{} }
-func (m *CommandTcClientConnectRequest) String() string { return proto.CompactTextString(m) }
-func (*CommandTcClientConnectRequest) ProtoMessage()    {}
-func (*CommandTcClientConnectRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{55}
-}
-func (m *CommandTcClientConnectRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandTcClientConnectRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandTcClientConnectRequest.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for CommandTcClientConnectRequest fields.
+const (
+	Default_CommandTcClientConnectRequest_TcId = uint64(0)
+)
+
+func (x *CommandTcClientConnectRequest) Reset() {
+	*x = CommandTcClientConnectRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[55]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandTcClientConnectRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandTcClientConnectRequest.Merge(m, src)
-}
-func (m *CommandTcClientConnectRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *CommandTcClientConnectRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandTcClientConnectRequest.DiscardUnknown(m)
+
+func (x *CommandTcClientConnectRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandTcClientConnectRequest proto.InternalMessageInfo
+func (*CommandTcClientConnectRequest) ProtoMessage() {}
+
+func (x *CommandTcClientConnectRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[55]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandTcClientConnectRequest_TcId uint64 = 0
+// Deprecated: Use CommandTcClientConnectRequest.ProtoReflect.Descriptor instead.
+func (*CommandTcClientConnectRequest) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{55}
+}
 
-func (m *CommandTcClientConnectRequest) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandTcClientConnectRequest) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandTcClientConnectRequest) GetTcId() uint64 {
-	if m != nil && m.TcId != nil {
-		return *m.TcId
+func (x *CommandTcClientConnectRequest) GetTcId() uint64 {
+	if x != nil && x.TcId != nil {
+		return *x.TcId
 	}
 	return Default_CommandTcClientConnectRequest_TcId
 }
 
 type CommandTcClientConnectResponse struct {
-	RequestId            *uint64      `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	Error                *ServerError `protobuf:"varint,2,opt,name=error,enum=pulsar.proto.ServerError" json:"error,omitempty"`
-	Message              *string      `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequestId *uint64      `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+	Error     *ServerError `protobuf:"varint,2,opt,name=error,enum=pulsar.proto.ServerError" json:"error,omitempty"`
+	Message   *string      `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"`
 }
 
-func (m *CommandTcClientConnectResponse) Reset()         { *m = CommandTcClientConnectResponse{} }
-func (m *CommandTcClientConnectResponse) String() string { return proto.CompactTextString(m) }
-func (*CommandTcClientConnectResponse) ProtoMessage()    {}
-func (*CommandTcClientConnectResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{56}
-}
-func (m *CommandTcClientConnectResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandTcClientConnectResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandTcClientConnectResponse.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+func (x *CommandTcClientConnectResponse) Reset() {
+	*x = CommandTcClientConnectResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[56]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandTcClientConnectResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandTcClientConnectResponse.Merge(m, src)
-}
-func (m *CommandTcClientConnectResponse) XXX_Size() int {
-	return m.Size()
+
+func (x *CommandTcClientConnectResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
-func (m *CommandTcClientConnectResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandTcClientConnectResponse.DiscardUnknown(m)
+
+func (*CommandTcClientConnectResponse) ProtoMessage() {}
+
+func (x *CommandTcClientConnectResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[56]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-var xxx_messageInfo_CommandTcClientConnectResponse proto.InternalMessageInfo
+// Deprecated: Use CommandTcClientConnectResponse.ProtoReflect.Descriptor instead.
+func (*CommandTcClientConnectResponse) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{56}
+}
 
-func (m *CommandTcClientConnectResponse) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandTcClientConnectResponse) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandTcClientConnectResponse) GetError() ServerError {
-	if m != nil && m.Error != nil {
-		return *m.Error
+func (x *CommandTcClientConnectResponse) GetError() ServerError {
+	if x != nil && x.Error != nil {
+		return *x.Error
 	}
 	return ServerError_UnknownError
 }
 
-func (m *CommandTcClientConnectResponse) GetMessage() string {
-	if m != nil && m.Message != nil {
-		return *m.Message
+func (x *CommandTcClientConnectResponse) GetMessage() string {
+	if x != nil && x.Message != nil {
+		return *x.Message
 	}
 	return ""
 }
 
 type CommandNewTxn struct {
-	RequestId            *uint64  `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	TxnTtlSeconds        *uint64  `protobuf:"varint,2,opt,name=txn_ttl_seconds,json=txnTtlSeconds,def=0" json:"txn_ttl_seconds,omitempty"`
-	TcId                 *uint64  `protobuf:"varint,3,opt,name=tc_id,json=tcId,def=0" json:"tc_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequestId     *uint64 `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+	TxnTtlSeconds *uint64 `protobuf:"varint,2,opt,name=txn_ttl_seconds,json=txnTtlSeconds,def=0" json:"txn_ttl_seconds,omitempty"`
+	TcId          *uint64 `protobuf:"varint,3,opt,name=tc_id,json=tcId,def=0" json:"tc_id,omitempty"`
 }
 
-func (m *CommandNewTxn) Reset()         { *m = CommandNewTxn{} }
-func (m *CommandNewTxn) String() string { return proto.CompactTextString(m) }
-func (*CommandNewTxn) ProtoMessage()    {}
-func (*CommandNewTxn) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{57}
-}
-func (m *CommandNewTxn) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandNewTxn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandNewTxn.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
+// Default values for CommandNewTxn fields.
+const (
+	Default_CommandNewTxn_TxnTtlSeconds = uint64(0)
+	Default_CommandNewTxn_TcId          = uint64(0)
+)
+
+func (x *CommandNewTxn) Reset() {
+	*x = CommandNewTxn{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[57]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
 }
-func (m *CommandNewTxn) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandNewTxn.Merge(m, src)
-}
-func (m *CommandNewTxn) XXX_Size() int {
-	return m.Size()
-}
-func (m *CommandNewTxn) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandNewTxn.DiscardUnknown(m)
+
+func (x *CommandNewTxn) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandNewTxn proto.InternalMessageInfo
+func (*CommandNewTxn) ProtoMessage() {}
+
+func (x *CommandNewTxn) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[57]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandNewTxn_TxnTtlSeconds uint64 = 0
-const Default_CommandNewTxn_TcId uint64 = 0
+// Deprecated: Use CommandNewTxn.ProtoReflect.Descriptor instead.
+func (*CommandNewTxn) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{57}
+}
 
-func (m *CommandNewTxn) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandNewTxn) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandNewTxn) GetTxnTtlSeconds() uint64 {
-	if m != nil && m.TxnTtlSeconds != nil {
-		return *m.TxnTtlSeconds
+func (x *CommandNewTxn) GetTxnTtlSeconds() uint64 {
+	if x != nil && x.TxnTtlSeconds != nil {
+		return *x.TxnTtlSeconds
 	}
 	return Default_CommandNewTxn_TxnTtlSeconds
 }
 
-func (m *CommandNewTxn) GetTcId() uint64 {
-	if m != nil && m.TcId != nil {
-		return *m.TcId
+func (x *CommandNewTxn) GetTcId() uint64 {
+	if x != nil && x.TcId != nil {
+		return *x.TcId
 	}
 	return Default_CommandNewTxn_TcId
 }
 
 type CommandNewTxnResponse struct {
-	RequestId            *uint64      `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	TxnidLeastBits       *uint64      `protobuf:"varint,2,opt,name=txnid_least_bits,json=txnidLeastBits,def=0" json:"txnid_least_bits,omitempty"`
-	TxnidMostBits        *uint64      `protobuf:"varint,3,opt,name=txnid_most_bits,json=txnidMostBits,def=0" json:"txnid_most_bits,omitempty"`
-	Error                *ServerError `protobuf:"varint,4,opt,name=error,enum=pulsar.proto.ServerError" json:"error,omitempty"`
-	Message              *string      `protobuf:"bytes,5,opt,name=message" json:"message,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
-}
-
-func (m *CommandNewTxnResponse) Reset()         { *m = CommandNewTxnResponse{} }
-func (m *CommandNewTxnResponse) String() string { return proto.CompactTextString(m) }
-func (*CommandNewTxnResponse) ProtoMessage()    {}
-func (*CommandNewTxnResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{58}
-}
-func (m *CommandNewTxnResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandNewTxnResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandNewTxnResponse.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *CommandNewTxnResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandNewTxnResponse.Merge(m, src)
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequestId      *uint64      `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+	TxnidLeastBits *uint64      `protobuf:"varint,2,opt,name=txnid_least_bits,json=txnidLeastBits,def=0" json:"txnid_least_bits,omitempty"`
+	TxnidMostBits  *uint64      `protobuf:"varint,3,opt,name=txnid_most_bits,json=txnidMostBits,def=0" json:"txnid_most_bits,omitempty"`
+	Error          *ServerError `protobuf:"varint,4,opt,name=error,enum=pulsar.proto.ServerError" json:"error,omitempty"`
+	Message        *string      `protobuf:"bytes,5,opt,name=message" json:"message,omitempty"`
 }
-func (m *CommandNewTxnResponse) XXX_Size() int {
-	return m.Size()
+
+// Default values for CommandNewTxnResponse fields.
+const (
+	Default_CommandNewTxnResponse_TxnidLeastBits = uint64(0)
+	Default_CommandNewTxnResponse_TxnidMostBits  = uint64(0)
+)
+
+func (x *CommandNewTxnResponse) Reset() {
+	*x = CommandNewTxnResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[58]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *CommandNewTxnResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandNewTxnResponse.DiscardUnknown(m)
+
+func (x *CommandNewTxnResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandNewTxnResponse proto.InternalMessageInfo
+func (*CommandNewTxnResponse) ProtoMessage() {}
+
+func (x *CommandNewTxnResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[58]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
 
-const Default_CommandNewTxnResponse_TxnidLeastBits uint64 = 0
-const Default_CommandNewTxnResponse_TxnidMostBits uint64 = 0
+// Deprecated: Use CommandNewTxnResponse.ProtoReflect.Descriptor instead.
+func (*CommandNewTxnResponse) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{58}
+}
 
-func (m *CommandNewTxnResponse) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandNewTxnResponse) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
 }
 
-func (m *CommandNewTxnResponse) GetTxnidLeastBits() uint64 {
-	if m != nil && m.TxnidLeastBits != nil {
-		return *m.TxnidLeastBits
+func (x *CommandNewTxnResponse) GetTxnidLeastBits() uint64 {
+	if x != nil && x.TxnidLeastBits != nil {
+		return *x.TxnidLeastBits
 	}
 	return Default_CommandNewTxnResponse_TxnidLeastBits
 }
 
-func (m *CommandNewTxnResponse) GetTxnidMostBits() uint64 {
-	if m != nil && m.TxnidMostBits != nil {
-		return *m.TxnidMostBits
+func (x *CommandNewTxnResponse) GetTxnidMostBits() uint64 {
+	if x != nil && x.TxnidMostBits != nil {
+		return *x.TxnidMostBits
 	}
 	return Default_CommandNewTxnResponse_TxnidMostBits
 }
 
-func (m *CommandNewTxnResponse) GetError() ServerError {
-	if m != nil && m.Error != nil {
-		return *m.Error
+func (x *CommandNewTxnResponse) GetError() ServerError {
+	if x != nil && x.Error != nil {
+		return *x.Error
 	}
 	return ServerError_UnknownError
 }
 
-func (m *CommandNewTxnResponse) GetMessage() string {
-	if m != nil && m.Message != nil {
-		return *m.Message
+func (x *CommandNewTxnResponse) GetMessage() string {
+	if x != nil && x.Message != nil {
+		return *x.Message
 	}
 	return ""
 }
 
 type CommandAddPartitionToTxn struct {
-	RequestId            *uint64  `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
-	TxnidLeastBits       *uint64  `protobuf:"varint,2,opt,name=txnid_least_bits,json=txnidLeastBits,def=0" json:"txnid_least_bits,omitempty"`
-	TxnidMostBits        *uint64  `protobuf:"varint,3,opt,name=txnid_most_bits,json=txnidMostBits,def=0" json:"txnid_most_bits,omitempty"`
-	Partitions           []string `protobuf:"bytes,4,rep,name=partitions" json:"partitions,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *CommandAddPartitionToTxn) Reset()         { *m = CommandAddPartitionToTxn{} }
-func (m *CommandAddPartitionToTxn) String() string { return proto.CompactTextString(m) }
-func (*CommandAddPartitionToTxn) ProtoMessage()    {}
-func (*CommandAddPartitionToTxn) Descriptor() ([]byte, []int) {
-	return fileDescriptor_39529ba7ad9caeb8, []int{59}
-}
-func (m *CommandAddPartitionToTxn) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CommandAddPartitionToTxn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CommandAddPartitionToTxn.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *CommandAddPartitionToTxn) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommandAddPartitionToTxn.Merge(m, src)
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RequestId      *uint64  `protobuf:"varint,1,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+	TxnidLeastBits *uint64  `protobuf:"varint,2,opt,name=txnid_least_bits,json=txnidLeastBits,def=0" json:"txnid_least_bits,omitempty"`
+	TxnidMostBits  *uint64  `protobuf:"varint,3,opt,name=txnid_most_bits,json=txnidMostBits,def=0" json:"txnid_most_bits,omitempty"`
+	Partitions     []string `protobuf:"bytes,4,rep,name=partitions" json:"partitions,omitempty"`
 }
-func (m *CommandAddPartitionToTxn) XXX_Size() int {
-	return m.Size()
+
+// Default values for CommandAddPartitionToTxn fields.
+const (
+	Default_CommandAddPartitionToTxn_TxnidLeastBits = uint64(0)
+	Default_CommandAddPartitionToTxn_TxnidMostBits  = uint64(0)
+)
+
+func (x *CommandAddPartitionToTxn) Reset() {
+	*x = CommandAddPartitionToTxn{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_PulsarApi_proto_msgTypes[59]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
 }
-func (m *CommandAddPartitionToTxn) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommandAddPartitionToTxn.DiscardUnknown(m)
+
+func (x *CommandAddPartitionToTxn) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-var xxx_messageInfo_CommandAddPartitionToTxn proto.InternalMessageInfo
+func (*CommandAddPartitionToTxn) ProtoMessage() {}
 
-const Default_CommandAddPartitionToTxn_TxnidLeastBits uint64 = 0
-const Default_CommandAddPartitionToTxn_TxnidMostBits uint64 = 0
+func (x *CommandAddPartitionToTxn) ProtoReflect() protoreflect.Message {
+	mi := &file_PulsarApi_proto_msgTypes[59]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CommandAddPartitionToTxn.ProtoReflect.Descriptor instead.
+func (*CommandAddPartitionToTxn) Descriptor() ([]byte, []int) {
+	return file_PulsarApi_proto_rawDescGZIP(), []int{59}
+}
 
-func (m *CommandAddPartitionToTxn) GetRequestId() uint64 {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
+func (x *CommandAddPartitionToTxn) GetRequestId() uint64 {
+	if x != nil && x.RequestId != nil {
+		return *x.RequestId
 	}
 	return 0
... 27612 lines suppressed ...