pkg/pb/PulsarApi.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: PulsarApi.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

// 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

type CompressionType int32

const (
	CompressionType_NONE   CompressionType = 0
	CompressionType_LZ4    CompressionType = 1
	CompressionType_ZLIB   CompressionType = 2
	CompressionType_ZSTD   CompressionType = 3
	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,
}

func (x CompressionType) Enum() *CompressionType {
	p := new(CompressionType)
	*p = x
	return p
}
func (x CompressionType) String() string {
	return proto.EnumName(CompressionType_name, int32(x))
}
func (x *CompressionType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(CompressionType_value, data, "CompressionType")
	if err != nil {
		return err
	}
	*x = CompressionType(value)
	return nil
}
func (CompressionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{0}
}

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
	// 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
)

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",
}
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,
}

func (x ServerError) Enum() *ServerError {
	p := new(ServerError)
	*p = x
	return p
}
func (x ServerError) String() string {
	return proto.EnumName(ServerError_name, int32(x))
}
func (x *ServerError) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ServerError_value, data, "ServerError")
	if err != nil {
		return err
	}
	*x = ServerError(value)
	return nil
}
func (ServerError) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{1}
}

type AuthMethod int32

const (
	AuthMethod_AuthMethodNone   AuthMethod = 0
	AuthMethod_AuthMethodYcaV1  AuthMethod = 1
	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,
}

func (x AuthMethod) Enum() *AuthMethod {
	p := new(AuthMethod)
	*p = x
	return p
}
func (x AuthMethod) String() string {
	return proto.EnumName(AuthMethod_name, int32(x))
}
func (x *AuthMethod) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(AuthMethod_value, data, "AuthMethod")
	if err != nil {
		return err
	}
	*x = AuthMethod(value)
	return nil
}
func (AuthMethod) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{2}
}

// Each protocol version identify new features that are
// incrementally added to the protocol
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
	// Added CommandActiveConsumerChange
	// Added CommandGetTopicsOfNamespace
	ProtocolVersion_v13 ProtocolVersion = 13
	ProtocolVersion_v14 ProtocolVersion = 14
)

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",
}
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,
}

func (x ProtocolVersion) Enum() *ProtocolVersion {
	p := new(ProtocolVersion)
	*p = x
	return p
}
func (x ProtocolVersion) String() string {
	return proto.EnumName(ProtocolVersion_name, int32(x))
}
func (x *ProtocolVersion) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ProtocolVersion_value, data, "ProtocolVersion")
	if err != nil {
		return err
	}
	*x = ProtocolVersion(value)
	return nil
}
func (ProtocolVersion) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{3}
}

type Schema_Type int32

const (
	Schema_None      Schema_Type = 0
	Schema_String    Schema_Type = 1
	Schema_Json      Schema_Type = 2
	Schema_Protobuf  Schema_Type = 3
	Schema_Avro      Schema_Type = 4
	Schema_Bool      Schema_Type = 5
	Schema_Int8      Schema_Type = 6
	Schema_Int16     Schema_Type = 7
	Schema_Int32     Schema_Type = 8
	Schema_Int64     Schema_Type = 9
	Schema_Float     Schema_Type = 10
	Schema_Double    Schema_Type = 11
	Schema_Date      Schema_Type = 12
	Schema_Time      Schema_Type = 13
	Schema_Timestamp Schema_Type = 14
	Schema_KeyValue  Schema_Type = 15
)

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",
}
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,
}

func (x Schema_Type) Enum() *Schema_Type {
	p := new(Schema_Type)
	*p = x
	return p
}
func (x Schema_Type) String() string {
	return proto.EnumName(Schema_Type_name, int32(x))
}
func (x *Schema_Type) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Schema_Type_value, data, "Schema_Type")
	if err != nil {
		return err
	}
	*x = Schema_Type(value)
	return nil
}
func (Schema_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{0, 0}
}

type CommandSubscribe_SubType int32

const (
	CommandSubscribe_Exclusive  CommandSubscribe_SubType = 0
	CommandSubscribe_Shared     CommandSubscribe_SubType = 1
	CommandSubscribe_Failover   CommandSubscribe_SubType = 2
	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,
}

func (x CommandSubscribe_SubType) Enum() *CommandSubscribe_SubType {
	p := new(CommandSubscribe_SubType)
	*p = x
	return p
}
func (x CommandSubscribe_SubType) String() string {
	return proto.EnumName(CommandSubscribe_SubType_name, int32(x))
}
func (x *CommandSubscribe_SubType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(CommandSubscribe_SubType_value, data, "CommandSubscribe_SubType")
	if err != nil {
		return err
	}
	*x = CommandSubscribe_SubType(value)
	return nil
}
func (CommandSubscribe_SubType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{12, 0}
}

type CommandSubscribe_InitialPosition int32

const (
	CommandSubscribe_Latest   CommandSubscribe_InitialPosition = 0
	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,
}

func (x CommandSubscribe_InitialPosition) Enum() *CommandSubscribe_InitialPosition {
	p := new(CommandSubscribe_InitialPosition)
	*p = x
	return p
}
func (x CommandSubscribe_InitialPosition) String() string {
	return proto.EnumName(CommandSubscribe_InitialPosition_name, int32(x))
}
func (x *CommandSubscribe_InitialPosition) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(CommandSubscribe_InitialPosition_value, data, "CommandSubscribe_InitialPosition")
	if err != nil {
		return err
	}
	*x = CommandSubscribe_InitialPosition(value)
	return nil
}
func (CommandSubscribe_InitialPosition) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{12, 1}
}

type CommandPartitionedTopicMetadataResponse_LookupType int32

const (
	CommandPartitionedTopicMetadataResponse_Success CommandPartitionedTopicMetadataResponse_LookupType = 0
	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,
}

func (x CommandPartitionedTopicMetadataResponse_LookupType) Enum() *CommandPartitionedTopicMetadataResponse_LookupType {
	p := new(CommandPartitionedTopicMetadataResponse_LookupType)
	*p = x
	return p
}
func (x CommandPartitionedTopicMetadataResponse_LookupType) String() string {
	return proto.EnumName(CommandPartitionedTopicMetadataResponse_LookupType_name, int32(x))
}
func (x *CommandPartitionedTopicMetadataResponse_LookupType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(CommandPartitionedTopicMetadataResponse_LookupType_value, data, "CommandPartitionedTopicMetadataResponse_LookupType")
	if err != nil {
		return err
	}
	*x = CommandPartitionedTopicMetadataResponse_LookupType(value)
	return nil
}
func (CommandPartitionedTopicMetadataResponse_LookupType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{14, 0}
}

type CommandLookupTopicResponse_LookupType int32

const (
	CommandLookupTopicResponse_Redirect CommandLookupTopicResponse_LookupType = 0
	CommandLookupTopicResponse_Connect  CommandLookupTopicResponse_LookupType = 1
	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,
}

func (x CommandLookupTopicResponse_LookupType) Enum() *CommandLookupTopicResponse_LookupType {
	p := new(CommandLookupTopicResponse_LookupType)
	*p = x
	return p
}
func (x CommandLookupTopicResponse_LookupType) String() string {
	return proto.EnumName(CommandLookupTopicResponse_LookupType_name, int32(x))
}
func (x *CommandLookupTopicResponse_LookupType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(CommandLookupTopicResponse_LookupType_value, data, "CommandLookupTopicResponse_LookupType")
	if err != nil {
		return err
	}
	*x = CommandLookupTopicResponse_LookupType(value)
	return nil
}
func (CommandLookupTopicResponse_LookupType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{16, 0}
}

type CommandAck_AckType int32

const (
	CommandAck_Individual CommandAck_AckType = 0
	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,
}

func (x CommandAck_AckType) Enum() *CommandAck_AckType {
	p := new(CommandAck_AckType)
	*p = x
	return p
}
func (x CommandAck_AckType) String() string {
	return proto.EnumName(CommandAck_AckType_name, int32(x))
}
func (x *CommandAck_AckType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(CommandAck_AckType_value, data, "CommandAck_AckType")
	if err != nil {
		return err
	}
	*x = CommandAck_AckType(value)
	return nil
}
func (CommandAck_AckType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{22, 0}
}

// Acks can contain a flag to indicate the consumer
// received an invalid message that got discarded
// before being passed on to the application.
type CommandAck_ValidationError int32

const (
	CommandAck_UncompressedSizeCorruption CommandAck_ValidationError = 0
	CommandAck_DecompressionError         CommandAck_ValidationError = 1
	CommandAck_ChecksumMismatch           CommandAck_ValidationError = 2
	CommandAck_BatchDeSerializeError      CommandAck_ValidationError = 3
	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,
}

func (x CommandAck_ValidationError) Enum() *CommandAck_ValidationError {
	p := new(CommandAck_ValidationError)
	*p = x
	return p
}
func (x CommandAck_ValidationError) String() string {
	return proto.EnumName(CommandAck_ValidationError_name, int32(x))
}
func (x *CommandAck_ValidationError) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(CommandAck_ValidationError_value, data, "CommandAck_ValidationError")
	if err != nil {
		return err
	}
	*x = CommandAck_ValidationError(value)
	return nil
}
func (CommandAck_ValidationError) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{22, 1}
}

type CommandGetTopicsOfNamespace_Mode int32

const (
	CommandGetTopicsOfNamespace_PERSISTENT     CommandGetTopicsOfNamespace_Mode = 0
	CommandGetTopicsOfNamespace_NON_PERSISTENT CommandGetTopicsOfNamespace_Mode = 1
	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,
}

func (x CommandGetTopicsOfNamespace_Mode) Enum() *CommandGetTopicsOfNamespace_Mode {
	p := new(CommandGetTopicsOfNamespace_Mode)
	*p = x
	return p
}
func (x CommandGetTopicsOfNamespace_Mode) String() string {
	return proto.EnumName(CommandGetTopicsOfNamespace_Mode_name, int32(x))
}
func (x *CommandGetTopicsOfNamespace_Mode) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(CommandGetTopicsOfNamespace_Mode_value, data, "CommandGetTopicsOfNamespace_Mode")
	if err != nil {
		return err
	}
	*x = CommandGetTopicsOfNamespace_Mode(value)
	return nil
}
func (CommandGetTopicsOfNamespace_Mode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{40, 0}
}

type BaseCommand_Type int32

const (
	BaseCommand_CONNECT                           BaseCommand_Type = 2
	BaseCommand_CONNECTED                         BaseCommand_Type = 3
	BaseCommand_SUBSCRIBE                         BaseCommand_Type = 4
	BaseCommand_PRODUCER                          BaseCommand_Type = 5
	BaseCommand_SEND                              BaseCommand_Type = 6
	BaseCommand_SEND_RECEIPT                      BaseCommand_Type = 7
	BaseCommand_SEND_ERROR                        BaseCommand_Type = 8
	BaseCommand_MESSAGE                           BaseCommand_Type = 9
	BaseCommand_ACK                               BaseCommand_Type = 10
	BaseCommand_FLOW                              BaseCommand_Type = 11
	BaseCommand_UNSUBSCRIBE                       BaseCommand_Type = 12
	BaseCommand_SUCCESS                           BaseCommand_Type = 13
	BaseCommand_ERROR                             BaseCommand_Type = 14
	BaseCommand_CLOSE_PRODUCER                    BaseCommand_Type = 15
	BaseCommand_CLOSE_CONSUMER                    BaseCommand_Type = 16
	BaseCommand_PRODUCER_SUCCESS                  BaseCommand_Type = 17
	BaseCommand_PING                              BaseCommand_Type = 18
	BaseCommand_PONG                              BaseCommand_Type = 19
	BaseCommand_REDELIVER_UNACKNOWLEDGED_MESSAGES BaseCommand_Type = 20
	BaseCommand_PARTITIONED_METADATA              BaseCommand_Type = 21
	BaseCommand_PARTITIONED_METADATA_RESPONSE     BaseCommand_Type = 22
	BaseCommand_LOOKUP                            BaseCommand_Type = 23
	BaseCommand_LOOKUP_RESPONSE                   BaseCommand_Type = 24
	BaseCommand_CONSUMER_STATS                    BaseCommand_Type = 25
	BaseCommand_CONSUMER_STATS_RESPONSE           BaseCommand_Type = 26
	BaseCommand_REACHED_END_OF_TOPIC              BaseCommand_Type = 27
	BaseCommand_SEEK                              BaseCommand_Type = 28
	BaseCommand_GET_LAST_MESSAGE_ID               BaseCommand_Type = 29
	BaseCommand_GET_LAST_MESSAGE_ID_RESPONSE      BaseCommand_Type = 30
	BaseCommand_ACTIVE_CONSUMER_CHANGE            BaseCommand_Type = 31
	BaseCommand_GET_TOPICS_OF_NAMESPACE           BaseCommand_Type = 32
	BaseCommand_GET_TOPICS_OF_NAMESPACE_RESPONSE  BaseCommand_Type = 33
	BaseCommand_GET_SCHEMA                        BaseCommand_Type = 34
	BaseCommand_GET_SCHEMA_RESPONSE               BaseCommand_Type = 35
	BaseCommand_AUTH_CHALLENGE                    BaseCommand_Type = 36
	BaseCommand_AUTH_RESPONSE                     BaseCommand_Type = 37
)

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",
}
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,
}

func (x BaseCommand_Type) Enum() *BaseCommand_Type {
	p := new(BaseCommand_Type)
	*p = x
	return p
}
func (x BaseCommand_Type) String() string {
	return proto.EnumName(BaseCommand_Type_name, int32(x))
}
func (x *BaseCommand_Type) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(BaseCommand_Type_value, data, "BaseCommand_Type")
	if err != nil {
		return err
	}
	*x = BaseCommand_Type(value)
	return nil
}
func (BaseCommand_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{44, 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_PulsarApi_976de857822f53b5, []int{0}
}
func (m *Schema) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Schema.Unmarshal(m, b)
}
func (m *Schema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Schema.Marshal(b, m, deterministic)
}
func (dst *Schema) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Schema.Merge(dst, src)
}
func (m *Schema) XXX_Size() int {
	return xxx_messageInfo_Schema.Size(m)
}
func (m *Schema) XXX_DiscardUnknown() {
	xxx_messageInfo_Schema.DiscardUnknown(m)
}

var xxx_messageInfo_Schema proto.InternalMessageInfo

func (m *Schema) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *Schema) GetSchemaData() []byte {
	if m != nil {
		return m.SchemaData
	}
	return nil
}

func (m *Schema) GetType() Schema_Type {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return Schema_None
}

func (m *Schema) GetProperties() []*KeyValue {
	if m != nil {
		return m.Properties
	}
	return nil
}

type MessageIdData struct {
	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"`
	BatchIndex           *int32   `protobuf:"varint,4,opt,name=batch_index,json=batchIndex,def=-1" json:"batch_index,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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_PulsarApi_976de857822f53b5, []int{1}
}
func (m *MessageIdData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageIdData.Unmarshal(m, b)
}
func (m *MessageIdData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageIdData.Marshal(b, m, deterministic)
}
func (dst *MessageIdData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageIdData.Merge(dst, src)
}
func (m *MessageIdData) XXX_Size() int {
	return xxx_messageInfo_MessageIdData.Size(m)
}
func (m *MessageIdData) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageIdData.DiscardUnknown(m)
}

var xxx_messageInfo_MessageIdData proto.InternalMessageInfo

const Default_MessageIdData_Partition int32 = -1
const Default_MessageIdData_BatchIndex int32 = -1

func (m *MessageIdData) GetLedgerId() uint64 {
	if m != nil && m.LedgerId != nil {
		return *m.LedgerId
	}
	return 0
}

func (m *MessageIdData) GetEntryId() uint64 {
	if m != nil && m.EntryId != nil {
		return *m.EntryId
	}
	return 0
}

func (m *MessageIdData) GetPartition() int32 {
	if m != nil && m.Partition != nil {
		return *m.Partition
	}
	return Default_MessageIdData_Partition
}

func (m *MessageIdData) GetBatchIndex() int32 {
	if m != nil && m.BatchIndex != nil {
		return *m.BatchIndex
	}
	return Default_MessageIdData_BatchIndex
}

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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{2}
}
func (m *KeyValue) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KeyValue.Unmarshal(m, b)
}
func (m *KeyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KeyValue.Marshal(b, m, deterministic)
}
func (dst *KeyValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeyValue.Merge(dst, src)
}
func (m *KeyValue) XXX_Size() int {
	return xxx_messageInfo_KeyValue.Size(m)
}
func (m *KeyValue) XXX_DiscardUnknown() {
	xxx_messageInfo_KeyValue.DiscardUnknown(m)
}

var xxx_messageInfo_KeyValue proto.InternalMessageInfo

func (m *KeyValue) GetKey() string {
	if m != nil && m.Key != nil {
		return *m.Key
	}
	return ""
}

func (m *KeyValue) GetValue() string {
	if m != nil && m.Value != nil {
		return *m.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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{3}
}
func (m *KeyLongValue) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KeyLongValue.Unmarshal(m, b)
}
func (m *KeyLongValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KeyLongValue.Marshal(b, m, deterministic)
}
func (dst *KeyLongValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeyLongValue.Merge(dst, src)
}
func (m *KeyLongValue) XXX_Size() int {
	return xxx_messageInfo_KeyLongValue.Size(m)
}
func (m *KeyLongValue) XXX_DiscardUnknown() {
	xxx_messageInfo_KeyLongValue.DiscardUnknown(m)
}

var xxx_messageInfo_KeyLongValue proto.InternalMessageInfo

func (m *KeyLongValue) GetKey() string {
	if m != nil && m.Key != nil {
		return *m.Key
	}
	return ""
}

func (m *KeyLongValue) GetValue() uint64 {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{4}
}
func (m *EncryptionKeys) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EncryptionKeys.Unmarshal(m, b)
}
func (m *EncryptionKeys) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EncryptionKeys.Marshal(b, m, deterministic)
}
func (dst *EncryptionKeys) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EncryptionKeys.Merge(dst, src)
}
func (m *EncryptionKeys) XXX_Size() int {
	return xxx_messageInfo_EncryptionKeys.Size(m)
}
func (m *EncryptionKeys) XXX_DiscardUnknown() {
	xxx_messageInfo_EncryptionKeys.DiscardUnknown(m)
}

var xxx_messageInfo_EncryptionKeys proto.InternalMessageInfo

func (m *EncryptionKeys) GetKey() string {
	if m != nil && m.Key != nil {
		return *m.Key
	}
	return ""
}

func (m *EncryptionKeys) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *EncryptionKeys) GetMetadata() []*KeyValue {
	if m != nil {
		return m.Metadata
	}
	return nil
}

type MessageMetadata struct {
	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"`
	Properties   []*KeyValue `protobuf:"bytes,4,rep,name=properties" json:"properties,omitempty"`
	// Property set on replicated message,
	// includes the source cluster name
	ReplicatedFrom *string `protobuf:"bytes,5,opt,name=replicated_from,json=replicatedFrom" json:"replicated_from,omitempty"`
	// key to decide partition for the msg
	PartitionKey *string `protobuf:"bytes,6,opt,name=partition_key,json=partitionKey" json:"partition_key,omitempty"`
	// Override namespace's replication
	ReplicateTo      []string         `protobuf:"bytes,7,rep,name=replicate_to,json=replicateTo" json:"replicate_to,omitempty"`
	Compression      *CompressionType `protobuf:"varint,8,opt,name=compression,enum=pulsar.proto.CompressionType,def=0" json:"compression,omitempty"`
	UncompressedSize *uint32          `protobuf:"varint,9,opt,name=uncompressed_size,json=uncompressedSize,def=0" json:"uncompressed_size,omitempty"`
	// Removed below checksum field from Metadata as
	// it should be part of send-command which keeps checksum of header + payload
	// optional sfixed64 checksum = 10;
	// differentiate single and batch message metadata
	NumMessagesInBatch *int32 `protobuf:"varint,11,opt,name=num_messages_in_batch,json=numMessagesInBatch,def=1" json:"num_messages_in_batch,omitempty"`
	// the timestamp that this event occurs. it is typically set by applications.
	// if this field is omitted, `publish_time` can be used for the purpose of `event_time`.
	EventTime *uint64 `protobuf:"varint,12,opt,name=event_time,json=eventTime,def=0" json:"event_time,omitempty"`
	// Contains encryption key name, encrypted key and metadata to describe the key
	EncryptionKeys []*EncryptionKeys `protobuf:"bytes,13,rep,name=encryption_keys,json=encryptionKeys" json:"encryption_keys,omitempty"`
	// Algorithm used to encrypt data key
	EncryptionAlgo *string `protobuf:"bytes,14,opt,name=encryption_algo,json=encryptionAlgo" json:"encryption_algo,omitempty"`
	// Additional parameters required by encryption
	EncryptionParam        []byte `protobuf:"bytes,15,opt,name=encryption_param,json=encryptionParam" json:"encryption_param,omitempty"`
	SchemaVersion          []byte `protobuf:"bytes,16,opt,name=schema_version,json=schemaVersion" json:"schema_version,omitempty"`
	PartitionKeyB64Encoded *bool  `protobuf:"varint,17,opt,name=partition_key_b64_encoded,json=partitionKeyB64Encoded,def=0" json:"partition_key_b64_encoded,omitempty"`
	// Specific a key to overwrite the message key which used for ordering dispatch in Key_Shared mode.
	OrderingKey []byte `protobuf:"bytes,18,opt,name=ordering_key,json=orderingKey" json:"ordering_key,omitempty"`
	// Mark the message to be delivered at or after the specified timestamp
	DeliverAtTime *int64 `protobuf:"varint,19,opt,name=deliver_at_time,json=deliverAtTime" json:"deliver_at_time,omitempty"`
	// Identify whether a message is a "marker" message used for
	// internal metadata instead of application published data.
	// Markers will generally not be propagated back to clients
	MarkerType           *int32   `protobuf:"varint,20,opt,name=marker_type,json=markerType" json:"marker_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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_PulsarApi_976de857822f53b5, []int{5}
}
func (m *MessageMetadata) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageMetadata.Unmarshal(m, b)
}
func (m *MessageMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageMetadata.Marshal(b, m, deterministic)
}
func (dst *MessageMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageMetadata.Merge(dst, src)
}
func (m *MessageMetadata) XXX_Size() int {
	return xxx_messageInfo_MessageMetadata.Size(m)
}
func (m *MessageMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_MessageMetadata proto.InternalMessageInfo

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

func (m *MessageMetadata) GetProducerName() string {
	if m != nil && m.ProducerName != nil {
		return *m.ProducerName
	}
	return ""
}

func (m *MessageMetadata) GetSequenceId() uint64 {
	if m != nil && m.SequenceId != nil {
		return *m.SequenceId
	}
	return 0
}

func (m *MessageMetadata) GetPublishTime() uint64 {
	if m != nil && m.PublishTime != nil {
		return *m.PublishTime
	}
	return 0
}

func (m *MessageMetadata) GetProperties() []*KeyValue {
	if m != nil {
		return m.Properties
	}
	return nil
}

func (m *MessageMetadata) GetReplicatedFrom() string {
	if m != nil && m.ReplicatedFrom != nil {
		return *m.ReplicatedFrom
	}
	return ""
}

func (m *MessageMetadata) GetPartitionKey() string {
	if m != nil && m.PartitionKey != nil {
		return *m.PartitionKey
	}
	return ""
}

func (m *MessageMetadata) GetReplicateTo() []string {
	if m != nil {
		return m.ReplicateTo
	}
	return nil
}

func (m *MessageMetadata) GetCompression() CompressionType {
	if m != nil && m.Compression != nil {
		return *m.Compression
	}
	return Default_MessageMetadata_Compression
}

func (m *MessageMetadata) GetUncompressedSize() uint32 {
	if m != nil && m.UncompressedSize != nil {
		return *m.UncompressedSize
	}
	return Default_MessageMetadata_UncompressedSize
}

func (m *MessageMetadata) GetNumMessagesInBatch() int32 {
	if m != nil && m.NumMessagesInBatch != nil {
		return *m.NumMessagesInBatch
	}
	return Default_MessageMetadata_NumMessagesInBatch
}

func (m *MessageMetadata) GetEventTime() uint64 {
	if m != nil && m.EventTime != nil {
		return *m.EventTime
	}
	return Default_MessageMetadata_EventTime
}

func (m *MessageMetadata) GetEncryptionKeys() []*EncryptionKeys {
	if m != nil {
		return m.EncryptionKeys
	}
	return nil
}

func (m *MessageMetadata) GetEncryptionAlgo() string {
	if m != nil && m.EncryptionAlgo != nil {
		return *m.EncryptionAlgo
	}
	return ""
}

func (m *MessageMetadata) GetEncryptionParam() []byte {
	if m != nil {
		return m.EncryptionParam
	}
	return nil
}

func (m *MessageMetadata) GetSchemaVersion() []byte {
	if m != nil {
		return m.SchemaVersion
	}
	return nil
}

func (m *MessageMetadata) GetPartitionKeyB64Encoded() bool {
	if m != nil && m.PartitionKeyB64Encoded != nil {
		return *m.PartitionKeyB64Encoded
	}
	return Default_MessageMetadata_PartitionKeyB64Encoded
}

func (m *MessageMetadata) GetOrderingKey() []byte {
	if m != nil {
		return m.OrderingKey
	}
	return nil
}

func (m *MessageMetadata) GetDeliverAtTime() int64 {
	if m != nil && m.DeliverAtTime != nil {
		return *m.DeliverAtTime
	}
	return 0
}

func (m *MessageMetadata) GetMarkerType() int32 {
	if m != nil && m.MarkerType != nil {
		return *m.MarkerType
	}
	return 0
}

type SingleMessageMetadata struct {
	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"`
	CompactedOut *bool       `protobuf:"varint,4,opt,name=compacted_out,json=compactedOut,def=0" json:"compacted_out,omitempty"`
	// the timestamp that this event occurs. it is typically set by applications.
	// if this field is omitted, `publish_time` can be used for the purpose of `event_time`.
	EventTime              *uint64 `protobuf:"varint,5,opt,name=event_time,json=eventTime,def=0" json:"event_time,omitempty"`
	PartitionKeyB64Encoded *bool   `protobuf:"varint,6,opt,name=partition_key_b64_encoded,json=partitionKeyB64Encoded,def=0" json:"partition_key_b64_encoded,omitempty"`
	// Specific a key to overwrite the message key which used for ordering dispatch in Key_Shared mode.
	OrderingKey          []byte   `protobuf:"bytes,7,opt,name=ordering_key,json=orderingKey" json:"ordering_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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_PulsarApi_976de857822f53b5, []int{6}
}
func (m *SingleMessageMetadata) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SingleMessageMetadata.Unmarshal(m, b)
}
func (m *SingleMessageMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SingleMessageMetadata.Marshal(b, m, deterministic)
}
func (dst *SingleMessageMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SingleMessageMetadata.Merge(dst, src)
}
func (m *SingleMessageMetadata) XXX_Size() int {
	return xxx_messageInfo_SingleMessageMetadata.Size(m)
}
func (m *SingleMessageMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_SingleMessageMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_SingleMessageMetadata proto.InternalMessageInfo

const Default_SingleMessageMetadata_CompactedOut bool = false
const Default_SingleMessageMetadata_EventTime uint64 = 0
const Default_SingleMessageMetadata_PartitionKeyB64Encoded bool = false

func (m *SingleMessageMetadata) GetProperties() []*KeyValue {
	if m != nil {
		return m.Properties
	}
	return nil
}

func (m *SingleMessageMetadata) GetPartitionKey() string {
	if m != nil && m.PartitionKey != nil {
		return *m.PartitionKey
	}
	return ""
}

func (m *SingleMessageMetadata) GetPayloadSize() int32 {
	if m != nil && m.PayloadSize != nil {
		return *m.PayloadSize
	}
	return 0
}

func (m *SingleMessageMetadata) GetCompactedOut() bool {
	if m != nil && m.CompactedOut != nil {
		return *m.CompactedOut
	}
	return Default_SingleMessageMetadata_CompactedOut
}

func (m *SingleMessageMetadata) GetEventTime() uint64 {
	if m != nil && m.EventTime != nil {
		return *m.EventTime
	}
	return Default_SingleMessageMetadata_EventTime
}

func (m *SingleMessageMetadata) GetPartitionKeyB64Encoded() bool {
	if m != nil && m.PartitionKeyB64Encoded != nil {
		return *m.PartitionKeyB64Encoded
	}
	return Default_SingleMessageMetadata_PartitionKeyB64Encoded
}

func (m *SingleMessageMetadata) GetOrderingKey() []byte {
	if m != nil {
		return m.OrderingKey
	}
	return nil
}

type CommandConnect struct {
	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"`
	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"`
	// Client can ask to be proxyied to a specific broker
	// This is only honored by a Pulsar proxy
	ProxyToBrokerUrl *string `protobuf:"bytes,6,opt,name=proxy_to_broker_url,json=proxyToBrokerUrl" json:"proxy_to_broker_url,omitempty"`
	// Original principal that was verified by
	// a Pulsar proxy. In this case the auth info above
	// will be the auth of the proxy itself
	OriginalPrincipal *string `protobuf:"bytes,7,opt,name=original_principal,json=originalPrincipal" json:"original_principal,omitempty"`
	// Original auth role and auth Method that was passed
	// to the proxy. In this case the auth info above
	// will be the auth of the proxy itself
	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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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_PulsarApi_976de857822f53b5, []int{7}
}
func (m *CommandConnect) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandConnect.Unmarshal(m, b)
}
func (m *CommandConnect) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandConnect.Marshal(b, m, deterministic)
}
func (dst *CommandConnect) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandConnect.Merge(dst, src)
}
func (m *CommandConnect) XXX_Size() int {
	return xxx_messageInfo_CommandConnect.Size(m)
}
func (m *CommandConnect) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandConnect.DiscardUnknown(m)
}

var xxx_messageInfo_CommandConnect proto.InternalMessageInfo

const Default_CommandConnect_ProtocolVersion int32 = 0

func (m *CommandConnect) GetClientVersion() string {
	if m != nil && m.ClientVersion != nil {
		return *m.ClientVersion
	}
	return ""
}

func (m *CommandConnect) GetAuthMethod() AuthMethod {
	if m != nil && m.AuthMethod != nil {
		return *m.AuthMethod
	}
	return AuthMethod_AuthMethodNone
}

func (m *CommandConnect) GetAuthMethodName() string {
	if m != nil && m.AuthMethodName != nil {
		return *m.AuthMethodName
	}
	return ""
}

func (m *CommandConnect) GetAuthData() []byte {
	if m != nil {
		return m.AuthData
	}
	return nil
}

func (m *CommandConnect) GetProtocolVersion() int32 {
	if m != nil && m.ProtocolVersion != nil {
		return *m.ProtocolVersion
	}
	return Default_CommandConnect_ProtocolVersion
}

func (m *CommandConnect) GetProxyToBrokerUrl() string {
	if m != nil && m.ProxyToBrokerUrl != nil {
		return *m.ProxyToBrokerUrl
	}
	return ""
}

func (m *CommandConnect) GetOriginalPrincipal() string {
	if m != nil && m.OriginalPrincipal != nil {
		return *m.OriginalPrincipal
	}
	return ""
}

func (m *CommandConnect) GetOriginalAuthData() string {
	if m != nil && m.OriginalAuthData != nil {
		return *m.OriginalAuthData
	}
	return ""
}

func (m *CommandConnect) GetOriginalAuthMethod() string {
	if m != nil && m.OriginalAuthMethod != nil {
		return *m.OriginalAuthMethod
	}
	return ""
}

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"`
	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_PulsarApi_976de857822f53b5, []int{8}
}
func (m *CommandConnected) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandConnected.Unmarshal(m, b)
}
func (m *CommandConnected) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandConnected.Marshal(b, m, deterministic)
}
func (dst *CommandConnected) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandConnected.Merge(dst, src)
}
func (m *CommandConnected) XXX_Size() int {
	return xxx_messageInfo_CommandConnected.Size(m)
}
func (m *CommandConnected) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandConnected.DiscardUnknown(m)
}

var xxx_messageInfo_CommandConnected proto.InternalMessageInfo

const Default_CommandConnected_ProtocolVersion int32 = 0

func (m *CommandConnected) GetServerVersion() string {
	if m != nil && m.ServerVersion != nil {
		return *m.ServerVersion
	}
	return ""
}

func (m *CommandConnected) GetProtocolVersion() int32 {
	if m != nil && m.ProtocolVersion != nil {
		return *m.ProtocolVersion
	}
	return Default_CommandConnected_ProtocolVersion
}

func (m *CommandConnected) GetMaxMessageSize() int32 {
	if m != nil && m.MaxMessageSize != nil {
		return *m.MaxMessageSize
	}
	return 0
}

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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{9}
}
func (m *CommandAuthResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandAuthResponse.Unmarshal(m, b)
}
func (m *CommandAuthResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandAuthResponse.Marshal(b, m, deterministic)
}
func (dst *CommandAuthResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandAuthResponse.Merge(dst, src)
}
func (m *CommandAuthResponse) XXX_Size() int {
	return xxx_messageInfo_CommandAuthResponse.Size(m)
}
func (m *CommandAuthResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandAuthResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CommandAuthResponse proto.InternalMessageInfo

const Default_CommandAuthResponse_ProtocolVersion int32 = 0

func (m *CommandAuthResponse) GetClientVersion() string {
	if m != nil && m.ClientVersion != nil {
		return *m.ClientVersion
	}
	return ""
}

func (m *CommandAuthResponse) GetResponse() *AuthData {
	if m != nil {
		return m.Response
	}
	return nil
}

func (m *CommandAuthResponse) GetProtocolVersion() int32 {
	if m != nil && m.ProtocolVersion != nil {
		return *m.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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{10}
}
func (m *CommandAuthChallenge) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandAuthChallenge.Unmarshal(m, b)
}
func (m *CommandAuthChallenge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandAuthChallenge.Marshal(b, m, deterministic)
}
func (dst *CommandAuthChallenge) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandAuthChallenge.Merge(dst, src)
}
func (m *CommandAuthChallenge) XXX_Size() int {
	return xxx_messageInfo_CommandAuthChallenge.Size(m)
}
func (m *CommandAuthChallenge) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandAuthChallenge.DiscardUnknown(m)
}

var xxx_messageInfo_CommandAuthChallenge proto.InternalMessageInfo

const Default_CommandAuthChallenge_ProtocolVersion int32 = 0

func (m *CommandAuthChallenge) GetServerVersion() string {
	if m != nil && m.ServerVersion != nil {
		return *m.ServerVersion
	}
	return ""
}

func (m *CommandAuthChallenge) GetChallenge() *AuthData {
	if m != nil {
		return m.Challenge
	}
	return nil
}

func (m *CommandAuthChallenge) GetProtocolVersion() int32 {
	if m != nil && m.ProtocolVersion != nil {
		return *m.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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{11}
}
func (m *AuthData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AuthData.Unmarshal(m, b)
}
func (m *AuthData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AuthData.Marshal(b, m, deterministic)
}
func (dst *AuthData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AuthData.Merge(dst, src)
}
func (m *AuthData) XXX_Size() int {
	return xxx_messageInfo_AuthData.Size(m)
}
func (m *AuthData) XXX_DiscardUnknown() {
	xxx_messageInfo_AuthData.DiscardUnknown(m)
}

var xxx_messageInfo_AuthData proto.InternalMessageInfo

func (m *AuthData) GetAuthMethodName() string {
	if m != nil && m.AuthMethodName != nil {
		return *m.AuthMethodName
	}
	return ""
}

func (m *AuthData) GetAuthData() []byte {
	if m != nil {
		return m.AuthData
	}
	return nil
}

type CommandSubscribe struct {
	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"`
	ConsumerId    *uint64                   `protobuf:"varint,4,req,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
	RequestId     *uint64                   `protobuf:"varint,5,req,name=request_id,json=requestId" json:"request_id,omitempty"`
	ConsumerName  *string                   `protobuf:"bytes,6,opt,name=consumer_name,json=consumerName" json:"consumer_name,omitempty"`
	PriorityLevel *int32                    `protobuf:"varint,7,opt,name=priority_level,json=priorityLevel" json:"priority_level,omitempty"`
	// Signal wether the subscription should be backed by a
	// durable cursor or not
	Durable *bool `protobuf:"varint,8,opt,name=durable,def=1" json:"durable,omitempty"`
	// If specified, the subscription will position the cursor
	// markd-delete position  on the particular message id and
	// will send messages from that point
	StartMessageId *MessageIdData `protobuf:"bytes,9,opt,name=start_message_id,json=startMessageId" json:"start_message_id,omitempty"`
	// / Add optional metadata key=value to this consumer
	Metadata      []*KeyValue `protobuf:"bytes,10,rep,name=metadata" json:"metadata,omitempty"`
	ReadCompacted *bool       `protobuf:"varint,11,opt,name=read_compacted,json=readCompacted" json:"read_compacted,omitempty"`
	Schema        *Schema     `protobuf:"bytes,12,opt,name=schema" json:"schema,omitempty"`
	// Signal wthether the subscription will initialize on latest
	// or not -- earliest
	InitialPosition *CommandSubscribe_InitialPosition `protobuf:"varint,13,opt,name=initialPosition,enum=pulsar.proto.CommandSubscribe_InitialPosition,def=0" json:"initialPosition,omitempty"`
	// Mark the subscription as "replicated". Pulsar will make sure
	// to periodically sync the state of replicated subscriptions
	// across different clusters (when using geo-replication).
	ReplicateSubscriptionState *bool    `protobuf:"varint,14,opt,name=replicate_subscription_state,json=replicateSubscriptionState" json:"replicate_subscription_state,omitempty"`
	XXX_NoUnkeyedLiteral       struct{} `json:"-"`
	XXX_unrecognized           []byte   `json:"-"`
	XXX_sizecache              int32    `json:"-"`
}

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_PulsarApi_976de857822f53b5, []int{12}
}
func (m *CommandSubscribe) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandSubscribe.Unmarshal(m, b)
}
func (m *CommandSubscribe) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandSubscribe.Marshal(b, m, deterministic)
}
func (dst *CommandSubscribe) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandSubscribe.Merge(dst, src)
}
func (m *CommandSubscribe) XXX_Size() int {
	return xxx_messageInfo_CommandSubscribe.Size(m)
}
func (m *CommandSubscribe) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandSubscribe.DiscardUnknown(m)
}

var xxx_messageInfo_CommandSubscribe proto.InternalMessageInfo

const Default_CommandSubscribe_Durable bool = true
const Default_CommandSubscribe_InitialPosition CommandSubscribe_InitialPosition = CommandSubscribe_Latest

func (m *CommandSubscribe) GetTopic() string {
	if m != nil && m.Topic != nil {
		return *m.Topic
	}
	return ""
}

func (m *CommandSubscribe) GetSubscription() string {
	if m != nil && m.Subscription != nil {
		return *m.Subscription
	}
	return ""
}

func (m *CommandSubscribe) GetSubType() CommandSubscribe_SubType {
	if m != nil && m.SubType != nil {
		return *m.SubType
	}
	return CommandSubscribe_Exclusive
}

func (m *CommandSubscribe) GetConsumerId() uint64 {
	if m != nil && m.ConsumerId != nil {
		return *m.ConsumerId
	}
	return 0
}

func (m *CommandSubscribe) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

func (m *CommandSubscribe) GetConsumerName() string {
	if m != nil && m.ConsumerName != nil {
		return *m.ConsumerName
	}
	return ""
}

func (m *CommandSubscribe) GetPriorityLevel() int32 {
	if m != nil && m.PriorityLevel != nil {
		return *m.PriorityLevel
	}
	return 0
}

func (m *CommandSubscribe) GetDurable() bool {
	if m != nil && m.Durable != nil {
		return *m.Durable
	}
	return Default_CommandSubscribe_Durable
}

func (m *CommandSubscribe) GetStartMessageId() *MessageIdData {
	if m != nil {
		return m.StartMessageId
	}
	return nil
}

func (m *CommandSubscribe) GetMetadata() []*KeyValue {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *CommandSubscribe) GetReadCompacted() bool {
	if m != nil && m.ReadCompacted != nil {
		return *m.ReadCompacted
	}
	return false
}

func (m *CommandSubscribe) GetSchema() *Schema {
	if m != nil {
		return m.Schema
	}
	return nil
}

func (m *CommandSubscribe) GetInitialPosition() CommandSubscribe_InitialPosition {
	if m != nil && m.InitialPosition != nil {
		return *m.InitialPosition
	}
	return Default_CommandSubscribe_InitialPosition
}

func (m *CommandSubscribe) GetReplicateSubscriptionState() bool {
	if m != nil && m.ReplicateSubscriptionState != nil {
		return *m.ReplicateSubscriptionState
	}
	return false
}

type CommandPartitionedTopicMetadata struct {
	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
	// Original principal that was verified by
	// a Pulsar proxy.
	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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{13}
}
func (m *CommandPartitionedTopicMetadata) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandPartitionedTopicMetadata.Unmarshal(m, b)
}
func (m *CommandPartitionedTopicMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandPartitionedTopicMetadata.Marshal(b, m, deterministic)
}
func (dst *CommandPartitionedTopicMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandPartitionedTopicMetadata.Merge(dst, src)
}
func (m *CommandPartitionedTopicMetadata) XXX_Size() int {
	return xxx_messageInfo_CommandPartitionedTopicMetadata.Size(m)
}
func (m *CommandPartitionedTopicMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandPartitionedTopicMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_CommandPartitionedTopicMetadata proto.InternalMessageInfo

func (m *CommandPartitionedTopicMetadata) GetTopic() string {
	if m != nil && m.Topic != nil {
		return *m.Topic
	}
	return ""
}

func (m *CommandPartitionedTopicMetadata) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

func (m *CommandPartitionedTopicMetadata) GetOriginalPrincipal() string {
	if m != nil && m.OriginalPrincipal != nil {
		return *m.OriginalPrincipal
	}
	return ""
}

func (m *CommandPartitionedTopicMetadata) GetOriginalAuthData() string {
	if m != nil && m.OriginalAuthData != nil {
		return *m.OriginalAuthData
	}
	return ""
}

func (m *CommandPartitionedTopicMetadata) GetOriginalAuthMethod() string {
	if m != nil && m.OriginalAuthMethod != nil {
		return *m.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:"-"`
}

func (m *CommandPartitionedTopicMetadataResponse) Reset() {
	*m = CommandPartitionedTopicMetadataResponse{}
}
func (m *CommandPartitionedTopicMetadataResponse) String() string { return proto.CompactTextString(m) }
func (*CommandPartitionedTopicMetadataResponse) ProtoMessage()    {}
func (*CommandPartitionedTopicMetadataResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{14}
}
func (m *CommandPartitionedTopicMetadataResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandPartitionedTopicMetadataResponse.Unmarshal(m, b)
}
func (m *CommandPartitionedTopicMetadataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandPartitionedTopicMetadataResponse.Marshal(b, m, deterministic)
}
func (dst *CommandPartitionedTopicMetadataResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandPartitionedTopicMetadataResponse.Merge(dst, src)
}
func (m *CommandPartitionedTopicMetadataResponse) XXX_Size() int {
	return xxx_messageInfo_CommandPartitionedTopicMetadataResponse.Size(m)
}
func (m *CommandPartitionedTopicMetadataResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandPartitionedTopicMetadataResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CommandPartitionedTopicMetadataResponse proto.InternalMessageInfo

func (m *CommandPartitionedTopicMetadataResponse) GetPartitions() uint32 {
	if m != nil && m.Partitions != nil {
		return *m.Partitions
	}
	return 0
}

func (m *CommandPartitionedTopicMetadataResponse) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

func (m *CommandPartitionedTopicMetadataResponse) GetResponse() CommandPartitionedTopicMetadataResponse_LookupType {
	if m != nil && m.Response != nil {
		return *m.Response
	}
	return CommandPartitionedTopicMetadataResponse_Success
}

func (m *CommandPartitionedTopicMetadataResponse) GetError() ServerError {
	if m != nil && m.Error != nil {
		return *m.Error
	}
	return ServerError_UnknownError
}

func (m *CommandPartitionedTopicMetadataResponse) GetMessage() string {
	if m != nil && m.Message != nil {
		return *m.Message
	}
	return ""
}

type CommandLookupTopic struct {
	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"`
	// TODO - Remove original_principal, original_auth_data, original_auth_method
	// Original principal that was verified by
	// a Pulsar proxy.
	OriginalPrincipal *string `protobuf:"bytes,4,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,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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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_PulsarApi_976de857822f53b5, []int{15}
}
func (m *CommandLookupTopic) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandLookupTopic.Unmarshal(m, b)
}
func (m *CommandLookupTopic) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandLookupTopic.Marshal(b, m, deterministic)
}
func (dst *CommandLookupTopic) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandLookupTopic.Merge(dst, src)
}
func (m *CommandLookupTopic) XXX_Size() int {
	return xxx_messageInfo_CommandLookupTopic.Size(m)
}
func (m *CommandLookupTopic) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandLookupTopic.DiscardUnknown(m)
}

var xxx_messageInfo_CommandLookupTopic proto.InternalMessageInfo

const Default_CommandLookupTopic_Authoritative bool = false

func (m *CommandLookupTopic) GetTopic() string {
	if m != nil && m.Topic != nil {
		return *m.Topic
	}
	return ""
}

func (m *CommandLookupTopic) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

func (m *CommandLookupTopic) GetAuthoritative() bool {
	if m != nil && m.Authoritative != nil {
		return *m.Authoritative
	}
	return Default_CommandLookupTopic_Authoritative
}

func (m *CommandLookupTopic) GetOriginalPrincipal() string {
	if m != nil && m.OriginalPrincipal != nil {
		return *m.OriginalPrincipal
	}
	return ""
}

func (m *CommandLookupTopic) GetOriginalAuthData() string {
	if m != nil && m.OriginalAuthData != nil {
		return *m.OriginalAuthData
	}
	return ""
}

func (m *CommandLookupTopic) GetOriginalAuthMethod() string {
	if m != nil && m.OriginalAuthMethod != nil {
		return *m.OriginalAuthMethod
	}
	return ""
}

type CommandLookupTopicResponse struct {
	BrokerServiceUrl    *string                                `protobuf:"bytes,1,opt,name=brokerServiceUrl" json:"brokerServiceUrl,omitempty"`
	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"`
	Authoritative       *bool                                  `protobuf:"varint,5,opt,name=authoritative,def=0" json:"authoritative,omitempty"`
	Error               *ServerError                           `protobuf:"varint,6,opt,name=error,enum=pulsar.proto.ServerError" json:"error,omitempty"`
	Message             *string                                `protobuf:"bytes,7,opt,name=message" json:"message,omitempty"`
	// 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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{16}
}
func (m *CommandLookupTopicResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandLookupTopicResponse.Unmarshal(m, b)
}
func (m *CommandLookupTopicResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandLookupTopicResponse.Marshal(b, m, deterministic)
}
func (dst *CommandLookupTopicResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandLookupTopicResponse.Merge(dst, src)
}
func (m *CommandLookupTopicResponse) XXX_Size() int {
	return xxx_messageInfo_CommandLookupTopicResponse.Size(m)
}
func (m *CommandLookupTopicResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandLookupTopicResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CommandLookupTopicResponse proto.InternalMessageInfo

const Default_CommandLookupTopicResponse_Authoritative bool = false
const Default_CommandLookupTopicResponse_ProxyThroughServiceUrl bool = false

func (m *CommandLookupTopicResponse) GetBrokerServiceUrl() string {
	if m != nil && m.BrokerServiceUrl != nil {
		return *m.BrokerServiceUrl
	}
	return ""
}

func (m *CommandLookupTopicResponse) GetBrokerServiceUrlTls() string {
	if m != nil && m.BrokerServiceUrlTls != nil {
		return *m.BrokerServiceUrlTls
	}
	return ""
}

func (m *CommandLookupTopicResponse) GetResponse() CommandLookupTopicResponse_LookupType {
	if m != nil && m.Response != nil {
		return *m.Response
	}
	return CommandLookupTopicResponse_Redirect
}

func (m *CommandLookupTopicResponse) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

func (m *CommandLookupTopicResponse) GetAuthoritative() bool {
	if m != nil && m.Authoritative != nil {
		return *m.Authoritative
	}
	return Default_CommandLookupTopicResponse_Authoritative
}

func (m *CommandLookupTopicResponse) GetError() ServerError {
	if m != nil && m.Error != nil {
		return *m.Error
	}
	return ServerError_UnknownError
}

func (m *CommandLookupTopicResponse) GetMessage() string {
	if m != nil && m.Message != nil {
		return *m.Message
	}
	return ""
}

func (m *CommandLookupTopicResponse) GetProxyThroughServiceUrl() bool {
	if m != nil && m.ProxyThroughServiceUrl != nil {
		return *m.ProxyThroughServiceUrl
	}
	return Default_CommandLookupTopicResponse_ProxyThroughServiceUrl
}

// / 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 {
	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"`
	// / If a producer name is specified, the name will be used,
	// / otherwise the broker will generate a unique name
	ProducerName *string `protobuf:"bytes,4,opt,name=producer_name,json=producerName" json:"producer_name,omitempty"`
	Encrypted    *bool   `protobuf:"varint,5,opt,name=encrypted,def=0" json:"encrypted,omitempty"`
	// / Add optional metadata key=value to this producer
	Metadata             []*KeyValue `protobuf:"bytes,6,rep,name=metadata" json:"metadata,omitempty"`
	Schema               *Schema     `protobuf:"bytes,7,opt,name=schema" json:"schema,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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_PulsarApi_976de857822f53b5, []int{17}
}
func (m *CommandProducer) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandProducer.Unmarshal(m, b)
}
func (m *CommandProducer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandProducer.Marshal(b, m, deterministic)
}
func (dst *CommandProducer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandProducer.Merge(dst, src)
}
func (m *CommandProducer) XXX_Size() int {
	return xxx_messageInfo_CommandProducer.Size(m)
}
func (m *CommandProducer) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandProducer.DiscardUnknown(m)
}

var xxx_messageInfo_CommandProducer proto.InternalMessageInfo

const Default_CommandProducer_Encrypted bool = false

func (m *CommandProducer) GetTopic() string {
	if m != nil && m.Topic != nil {
		return *m.Topic
	}
	return ""
}

func (m *CommandProducer) GetProducerId() uint64 {
	if m != nil && m.ProducerId != nil {
		return *m.ProducerId
	}
	return 0
}

func (m *CommandProducer) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

func (m *CommandProducer) GetProducerName() string {
	if m != nil && m.ProducerName != nil {
		return *m.ProducerName
	}
	return ""
}

func (m *CommandProducer) GetEncrypted() bool {
	if m != nil && m.Encrypted != nil {
		return *m.Encrypted
	}
	return Default_CommandProducer_Encrypted
}

func (m *CommandProducer) GetMetadata() []*KeyValue {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *CommandProducer) GetSchema() *Schema {
	if m != nil {
		return m.Schema
	}
	return nil
}

type CommandSend 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"`
	NumMessages          *int32   `protobuf:"varint,3,opt,name=num_messages,json=numMessages,def=1" json:"num_messages,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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_PulsarApi_976de857822f53b5, []int{18}
}
func (m *CommandSend) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandSend.Unmarshal(m, b)
}
func (m *CommandSend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandSend.Marshal(b, m, deterministic)
}
func (dst *CommandSend) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandSend.Merge(dst, src)
}
func (m *CommandSend) XXX_Size() int {
	return xxx_messageInfo_CommandSend.Size(m)
}
func (m *CommandSend) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandSend.DiscardUnknown(m)
}

var xxx_messageInfo_CommandSend proto.InternalMessageInfo

const Default_CommandSend_NumMessages int32 = 1

func (m *CommandSend) GetProducerId() uint64 {
	if m != nil && m.ProducerId != nil {
		return *m.ProducerId
	}
	return 0
}

func (m *CommandSend) GetSequenceId() uint64 {
	if m != nil && m.SequenceId != nil {
		return *m.SequenceId
	}
	return 0
}

func (m *CommandSend) GetNumMessages() int32 {
	if m != nil && m.NumMessages != nil {
		return *m.NumMessages
	}
	return Default_CommandSend_NumMessages
}

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"`
	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_PulsarApi_976de857822f53b5, []int{19}
}
func (m *CommandSendReceipt) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandSendReceipt.Unmarshal(m, b)
}
func (m *CommandSendReceipt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandSendReceipt.Marshal(b, m, deterministic)
}
func (dst *CommandSendReceipt) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandSendReceipt.Merge(dst, src)
}
func (m *CommandSendReceipt) XXX_Size() int {
	return xxx_messageInfo_CommandSendReceipt.Size(m)
}
func (m *CommandSendReceipt) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandSendReceipt.DiscardUnknown(m)
}

var xxx_messageInfo_CommandSendReceipt proto.InternalMessageInfo

func (m *CommandSendReceipt) GetProducerId() uint64 {
	if m != nil && m.ProducerId != nil {
		return *m.ProducerId
	}
	return 0
}

func (m *CommandSendReceipt) GetSequenceId() uint64 {
	if m != nil && m.SequenceId != nil {
		return *m.SequenceId
	}
	return 0
}

func (m *CommandSendReceipt) GetMessageId() *MessageIdData {
	if m != nil {
		return m.MessageId
	}
	return nil
}

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_PulsarApi_976de857822f53b5, []int{20}
}
func (m *CommandSendError) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandSendError.Unmarshal(m, b)
}
func (m *CommandSendError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandSendError.Marshal(b, m, deterministic)
}
func (dst *CommandSendError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandSendError.Merge(dst, src)
}
func (m *CommandSendError) XXX_Size() int {
	return xxx_messageInfo_CommandSendError.Size(m)
}
func (m *CommandSendError) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandSendError.DiscardUnknown(m)
}

var xxx_messageInfo_CommandSendError proto.InternalMessageInfo

func (m *CommandSendError) GetProducerId() uint64 {
	if m != nil && m.ProducerId != nil {
		return *m.ProducerId
	}
	return 0
}

func (m *CommandSendError) GetSequenceId() uint64 {
	if m != nil && m.SequenceId != nil {
		return *m.SequenceId
	}
	return 0
}

func (m *CommandSendError) GetError() ServerError {
	if m != nil && m.Error != nil {
		return *m.Error
	}
	return ServerError_UnknownError
}

func (m *CommandSendError) GetMessage() string {
	if m != nil && m.Message != nil {
		return *m.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"`
	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_PulsarApi_976de857822f53b5, []int{21}
}
func (m *CommandMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandMessage.Unmarshal(m, b)
}
func (m *CommandMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandMessage.Marshal(b, m, deterministic)
}
func (dst *CommandMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandMessage.Merge(dst, src)
}
func (m *CommandMessage) XXX_Size() int {
	return xxx_messageInfo_CommandMessage.Size(m)
}
func (m *CommandMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandMessage.DiscardUnknown(m)
}

var xxx_messageInfo_CommandMessage proto.InternalMessageInfo

const Default_CommandMessage_RedeliveryCount uint32 = 0

func (m *CommandMessage) GetConsumerId() uint64 {
	if m != nil && m.ConsumerId != nil {
		return *m.ConsumerId
	}
	return 0
}

func (m *CommandMessage) GetMessageId() *MessageIdData {
	if m != nil {
		return m.MessageId
	}
	return nil
}

func (m *CommandMessage) GetRedeliveryCount() uint32 {
	if m != nil && m.RedeliveryCount != nil {
		return *m.RedeliveryCount
	}
	return Default_CommandMessage_RedeliveryCount
}

type CommandAck struct {
	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"`
	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_PulsarApi_976de857822f53b5, []int{22}
}
func (m *CommandAck) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandAck.Unmarshal(m, b)
}
func (m *CommandAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandAck.Marshal(b, m, deterministic)
}
func (dst *CommandAck) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandAck.Merge(dst, src)
}
func (m *CommandAck) XXX_Size() int {
	return xxx_messageInfo_CommandAck.Size(m)
}
func (m *CommandAck) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandAck.DiscardUnknown(m)
}

var xxx_messageInfo_CommandAck proto.InternalMessageInfo

func (m *CommandAck) GetConsumerId() uint64 {
	if m != nil && m.ConsumerId != nil {
		return *m.ConsumerId
	}
	return 0
}

func (m *CommandAck) GetAckType() CommandAck_AckType {
	if m != nil && m.AckType != nil {
		return *m.AckType
	}
	return CommandAck_Individual
}

func (m *CommandAck) GetMessageId() []*MessageIdData {
	if m != nil {
		return m.MessageId
	}
	return nil
}

func (m *CommandAck) GetValidationError() CommandAck_ValidationError {
	if m != nil && m.ValidationError != nil {
		return *m.ValidationError
	}
	return CommandAck_UncompressedSizeCorruption
}

func (m *CommandAck) GetProperties() []*KeyLongValue {
	if m != nil {
		return m.Properties
	}
	return nil
}

// 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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{23}
}
func (m *CommandActiveConsumerChange) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandActiveConsumerChange.Unmarshal(m, b)
}
func (m *CommandActiveConsumerChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandActiveConsumerChange.Marshal(b, m, deterministic)
}
func (dst *CommandActiveConsumerChange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandActiveConsumerChange.Merge(dst, src)
}
func (m *CommandActiveConsumerChange) XXX_Size() int {
	return xxx_messageInfo_CommandActiveConsumerChange.Size(m)
}
func (m *CommandActiveConsumerChange) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandActiveConsumerChange.DiscardUnknown(m)
}

var xxx_messageInfo_CommandActiveConsumerChange proto.InternalMessageInfo

const Default_CommandActiveConsumerChange_IsActive bool = false

func (m *CommandActiveConsumerChange) GetConsumerId() uint64 {
	if m != nil && m.ConsumerId != nil {
		return *m.ConsumerId
	}
	return 0
}

func (m *CommandActiveConsumerChange) GetIsActive() bool {
	if m != nil && m.IsActive != nil {
		return *m.IsActive
	}
	return Default_CommandActiveConsumerChange_IsActive
}

type CommandFlow struct {
	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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{24}
}
func (m *CommandFlow) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandFlow.Unmarshal(m, b)
}
func (m *CommandFlow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandFlow.Marshal(b, m, deterministic)
}
func (dst *CommandFlow) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandFlow.Merge(dst, src)
}
func (m *CommandFlow) XXX_Size() int {
	return xxx_messageInfo_CommandFlow.Size(m)
}
func (m *CommandFlow) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandFlow.DiscardUnknown(m)
}

var xxx_messageInfo_CommandFlow proto.InternalMessageInfo

func (m *CommandFlow) GetConsumerId() uint64 {
	if m != nil && m.ConsumerId != nil {
		return *m.ConsumerId
	}
	return 0
}

func (m *CommandFlow) GetMessagePermits() uint32 {
	if m != nil && m.MessagePermits != nil {
		return *m.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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{25}
}
func (m *CommandUnsubscribe) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandUnsubscribe.Unmarshal(m, b)
}
func (m *CommandUnsubscribe) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandUnsubscribe.Marshal(b, m, deterministic)
}
func (dst *CommandUnsubscribe) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandUnsubscribe.Merge(dst, src)
}
func (m *CommandUnsubscribe) XXX_Size() int {
	return xxx_messageInfo_CommandUnsubscribe.Size(m)
}
func (m *CommandUnsubscribe) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandUnsubscribe.DiscardUnknown(m)
}

var xxx_messageInfo_CommandUnsubscribe proto.InternalMessageInfo

func (m *CommandUnsubscribe) GetConsumerId() uint64 {
	if m != nil && m.ConsumerId != nil {
		return *m.ConsumerId
	}
	return 0
}

func (m *CommandUnsubscribe) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.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_PulsarApi_976de857822f53b5, []int{26}
}
func (m *CommandSeek) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandSeek.Unmarshal(m, b)
}
func (m *CommandSeek) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandSeek.Marshal(b, m, deterministic)
}
func (dst *CommandSeek) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandSeek.Merge(dst, src)
}
func (m *CommandSeek) XXX_Size() int {
	return xxx_messageInfo_CommandSeek.Size(m)
}
func (m *CommandSeek) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandSeek.DiscardUnknown(m)
}

var xxx_messageInfo_CommandSeek proto.InternalMessageInfo

func (m *CommandSeek) GetConsumerId() uint64 {
	if m != nil && m.ConsumerId != nil {
		return *m.ConsumerId
	}
	return 0
}

func (m *CommandSeek) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

func (m *CommandSeek) GetMessageId() *MessageIdData {
	if m != nil {
		return m.MessageId
	}
	return nil
}

func (m *CommandSeek) GetMessagePublishTime() uint64 {
	if m != nil && m.MessagePublishTime != nil {
		return *m.MessagePublishTime
	}
	return 0
}

// Message sent by broker to client when a topic
// 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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{27}
}
func (m *CommandReachedEndOfTopic) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandReachedEndOfTopic.Unmarshal(m, b)
}
func (m *CommandReachedEndOfTopic) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandReachedEndOfTopic.Marshal(b, m, deterministic)
}
func (dst *CommandReachedEndOfTopic) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandReachedEndOfTopic.Merge(dst, src)
}
func (m *CommandReachedEndOfTopic) XXX_Size() int {
	return xxx_messageInfo_CommandReachedEndOfTopic.Size(m)
}
func (m *CommandReachedEndOfTopic) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandReachedEndOfTopic.DiscardUnknown(m)
}

var xxx_messageInfo_CommandReachedEndOfTopic proto.InternalMessageInfo

func (m *CommandReachedEndOfTopic) GetConsumerId() uint64 {
	if m != nil && m.ConsumerId != nil {
		return *m.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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{28}
}
func (m *CommandCloseProducer) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandCloseProducer.Unmarshal(m, b)
}
func (m *CommandCloseProducer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandCloseProducer.Marshal(b, m, deterministic)
}
func (dst *CommandCloseProducer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandCloseProducer.Merge(dst, src)
}
func (m *CommandCloseProducer) XXX_Size() int {
	return xxx_messageInfo_CommandCloseProducer.Size(m)
}
func (m *CommandCloseProducer) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandCloseProducer.DiscardUnknown(m)
}

var xxx_messageInfo_CommandCloseProducer proto.InternalMessageInfo

func (m *CommandCloseProducer) GetProducerId() uint64 {
	if m != nil && m.ProducerId != nil {
		return *m.ProducerId
	}
	return 0
}

func (m *CommandCloseProducer) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{29}
}
func (m *CommandCloseConsumer) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandCloseConsumer.Unmarshal(m, b)
}
func (m *CommandCloseConsumer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandCloseConsumer.Marshal(b, m, deterministic)
}
func (dst *CommandCloseConsumer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandCloseConsumer.Merge(dst, src)
}
func (m *CommandCloseConsumer) XXX_Size() int {
	return xxx_messageInfo_CommandCloseConsumer.Size(m)
}
func (m *CommandCloseConsumer) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandCloseConsumer.DiscardUnknown(m)
}

var xxx_messageInfo_CommandCloseConsumer proto.InternalMessageInfo

func (m *CommandCloseConsumer) GetConsumerId() uint64 {
	if m != nil && m.ConsumerId != nil {
		return *m.ConsumerId
	}
	return 0
}

func (m *CommandCloseConsumer) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.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"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *CommandRedeliverUnacknowledgedMessages) Reset() {
	*m = CommandRedeliverUnacknowledgedMessages{}
}
func (m *CommandRedeliverUnacknowledgedMessages) String() string { return proto.CompactTextString(m) }
func (*CommandRedeliverUnacknowledgedMessages) ProtoMessage()    {}
func (*CommandRedeliverUnacknowledgedMessages) Descriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{30}
}
func (m *CommandRedeliverUnacknowledgedMessages) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandRedeliverUnacknowledgedMessages.Unmarshal(m, b)
}
func (m *CommandRedeliverUnacknowledgedMessages) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandRedeliverUnacknowledgedMessages.Marshal(b, m, deterministic)
}
func (dst *CommandRedeliverUnacknowledgedMessages) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandRedeliverUnacknowledgedMessages.Merge(dst, src)
}
func (m *CommandRedeliverUnacknowledgedMessages) XXX_Size() int {
	return xxx_messageInfo_CommandRedeliverUnacknowledgedMessages.Size(m)
}
func (m *CommandRedeliverUnacknowledgedMessages) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandRedeliverUnacknowledgedMessages.DiscardUnknown(m)
}

var xxx_messageInfo_CommandRedeliverUnacknowledgedMessages proto.InternalMessageInfo

func (m *CommandRedeliverUnacknowledgedMessages) GetConsumerId() uint64 {
	if m != nil && m.ConsumerId != nil {
		return *m.ConsumerId
	}
	return 0
}

func (m *CommandRedeliverUnacknowledgedMessages) GetMessageIds() []*MessageIdData {
	if m != nil {
		return m.MessageIds
	}
	return nil
}

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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{31}
}
func (m *CommandSuccess) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandSuccess.Unmarshal(m, b)
}
func (m *CommandSuccess) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandSuccess.Marshal(b, m, deterministic)
}
func (dst *CommandSuccess) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandSuccess.Merge(dst, src)
}
func (m *CommandSuccess) XXX_Size() int {
	return xxx_messageInfo_CommandSuccess.Size(m)
}
func (m *CommandSuccess) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandSuccess.DiscardUnknown(m)
}

var xxx_messageInfo_CommandSuccess proto.InternalMessageInfo

func (m *CommandSuccess) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

func (m *CommandSuccess) GetSchema() *Schema {
	if m != nil {
		return m.Schema
	}
	return nil
}

// / Response from CommandProducer
type CommandProducerSuccess struct {
	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
	// This will only be meaningful if deduplication has been enabled.
	LastSequenceId       *int64   `protobuf:"varint,3,opt,name=last_sequence_id,json=lastSequenceId,def=-1" json:"last_sequence_id,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 *CommandProducerSuccess) Reset()         { *m = CommandProducerSuccess{} }
func (m *CommandProducerSuccess) String() string { return proto.CompactTextString(m) }
func (*CommandProducerSuccess) ProtoMessage()    {}
func (*CommandProducerSuccess) Descriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{32}
}
func (m *CommandProducerSuccess) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandProducerSuccess.Unmarshal(m, b)
}
func (m *CommandProducerSuccess) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandProducerSuccess.Marshal(b, m, deterministic)
}
func (dst *CommandProducerSuccess) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandProducerSuccess.Merge(dst, src)
}
func (m *CommandProducerSuccess) XXX_Size() int {
	return xxx_messageInfo_CommandProducerSuccess.Size(m)
}
func (m *CommandProducerSuccess) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandProducerSuccess.DiscardUnknown(m)
}

var xxx_messageInfo_CommandProducerSuccess proto.InternalMessageInfo

const Default_CommandProducerSuccess_LastSequenceId int64 = -1

func (m *CommandProducerSuccess) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

func (m *CommandProducerSuccess) GetProducerName() string {
	if m != nil && m.ProducerName != nil {
		return *m.ProducerName
	}
	return ""
}

func (m *CommandProducerSuccess) GetLastSequenceId() int64 {
	if m != nil && m.LastSequenceId != nil {
		return *m.LastSequenceId
	}
	return Default_CommandProducerSuccess_LastSequenceId
}

func (m *CommandProducerSuccess) GetSchemaVersion() []byte {
	if m != nil {
		return m.SchemaVersion
	}
	return nil
}

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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{33}
}
func (m *CommandError) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandError.Unmarshal(m, b)
}
func (m *CommandError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandError.Marshal(b, m, deterministic)
}
func (dst *CommandError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandError.Merge(dst, src)
}
func (m *CommandError) XXX_Size() int {
	return xxx_messageInfo_CommandError.Size(m)
}
func (m *CommandError) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandError.DiscardUnknown(m)
}

var xxx_messageInfo_CommandError proto.InternalMessageInfo

func (m *CommandError) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

func (m *CommandError) GetError() ServerError {
	if m != nil && m.Error != nil {
		return *m.Error
	}
	return ServerError_UnknownError
}

func (m *CommandError) GetMessage() string {
	if m != nil && m.Message != nil {
		return *m.Message
	}
	return ""
}

// Commands to probe the state of connection.
// 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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{34}
}
func (m *CommandPing) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandPing.Unmarshal(m, b)
}
func (m *CommandPing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandPing.Marshal(b, m, deterministic)
}
func (dst *CommandPing) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandPing.Merge(dst, src)
}
func (m *CommandPing) XXX_Size() int {
	return xxx_messageInfo_CommandPing.Size(m)
}
func (m *CommandPing) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandPing.DiscardUnknown(m)
}

var xxx_messageInfo_CommandPing proto.InternalMessageInfo

type CommandPong struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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_PulsarApi_976de857822f53b5, []int{35}
}
func (m *CommandPong) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandPong.Unmarshal(m, b)
}
func (m *CommandPong) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandPong.Marshal(b, m, deterministic)
}
func (dst *CommandPong) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandPong.Merge(dst, src)
}
func (m *CommandPong) XXX_Size() int {
	return xxx_messageInfo_CommandPong.Size(m)
}
func (m *CommandPong) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandPong.DiscardUnknown(m)
}

var xxx_messageInfo_CommandPong proto.InternalMessageInfo

type CommandConsumerStats struct {
	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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{36}
}
func (m *CommandConsumerStats) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandConsumerStats.Unmarshal(m, b)
}
func (m *CommandConsumerStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandConsumerStats.Marshal(b, m, deterministic)
}
func (dst *CommandConsumerStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandConsumerStats.Merge(dst, src)
}
func (m *CommandConsumerStats) XXX_Size() int {
	return xxx_messageInfo_CommandConsumerStats.Size(m)
}
func (m *CommandConsumerStats) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandConsumerStats.DiscardUnknown(m)
}

var xxx_messageInfo_CommandConsumerStats proto.InternalMessageInfo

func (m *CommandConsumerStats) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

func (m *CommandConsumerStats) GetConsumerId() uint64 {
	if m != nil && m.ConsumerId != nil {
		return *m.ConsumerId
	}
	return 0
}

type CommandConsumerStatsResponse 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"`
	// / Total rate of messages delivered to the consumer. msg/s
	MsgRateOut *float64 `protobuf:"fixed64,4,opt,name=msgRateOut" json:"msgRateOut,omitempty"`
	// / Total throughput delivered to the consumer. bytes/s
	MsgThroughputOut *float64 `protobuf:"fixed64,5,opt,name=msgThroughputOut" json:"msgThroughputOut,omitempty"`
	// / Total rate of messages redelivered by this consumer. msg/s
	MsgRateRedeliver *float64 `protobuf:"fixed64,6,opt,name=msgRateRedeliver" json:"msgRateRedeliver,omitempty"`
	// / Name of the consumer
	ConsumerName *string `protobuf:"bytes,7,opt,name=consumerName" json:"consumerName,omitempty"`
	// / Number of available message permits for the consumer
	AvailablePermits *uint64 `protobuf:"varint,8,opt,name=availablePermits" json:"availablePermits,omitempty"`
	// / Number of unacknowledged messages for the consumer
	UnackedMessages *uint64 `protobuf:"varint,9,opt,name=unackedMessages" json:"unackedMessages,omitempty"`
	// / Flag to verify if consumer is blocked due to reaching threshold of unacked messages
	BlockedConsumerOnUnackedMsgs *bool `protobuf:"varint,10,opt,name=blockedConsumerOnUnackedMsgs" json:"blockedConsumerOnUnackedMsgs,omitempty"`
	// / Address of this consumer
	Address *string `protobuf:"bytes,11,opt,name=address" json:"address,omitempty"`
	// / Timestamp of connection
	ConnectedSince *string `protobuf:"bytes,12,opt,name=connectedSince" json:"connectedSince,omitempty"`
	// / Whether this subscription is Exclusive or Shared or Failover
	Type *string `protobuf:"bytes,13,opt,name=type" json:"type,omitempty"`
	// / Total rate of messages expired on this subscription. msg/s
	MsgRateExpired *float64 `protobuf:"fixed64,14,opt,name=msgRateExpired" json:"msgRateExpired,omitempty"`
	// / Number of messages in the subscription backlog
	MsgBacklog           *uint64  `protobuf:"varint,15,opt,name=msgBacklog" json:"msgBacklog,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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_PulsarApi_976de857822f53b5, []int{37}
}
func (m *CommandConsumerStatsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandConsumerStatsResponse.Unmarshal(m, b)
}
func (m *CommandConsumerStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandConsumerStatsResponse.Marshal(b, m, deterministic)
}
func (dst *CommandConsumerStatsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandConsumerStatsResponse.Merge(dst, src)
}
func (m *CommandConsumerStatsResponse) XXX_Size() int {
	return xxx_messageInfo_CommandConsumerStatsResponse.Size(m)
}
func (m *CommandConsumerStatsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandConsumerStatsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CommandConsumerStatsResponse proto.InternalMessageInfo

func (m *CommandConsumerStatsResponse) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

func (m *CommandConsumerStatsResponse) GetErrorCode() ServerError {
	if m != nil && m.ErrorCode != nil {
		return *m.ErrorCode
	}
	return ServerError_UnknownError
}

func (m *CommandConsumerStatsResponse) GetErrorMessage() string {
	if m != nil && m.ErrorMessage != nil {
		return *m.ErrorMessage
	}
	return ""
}

func (m *CommandConsumerStatsResponse) GetMsgRateOut() float64 {
	if m != nil && m.MsgRateOut != nil {
		return *m.MsgRateOut
	}
	return 0
}

func (m *CommandConsumerStatsResponse) GetMsgThroughputOut() float64 {
	if m != nil && m.MsgThroughputOut != nil {
		return *m.MsgThroughputOut
	}
	return 0
}

func (m *CommandConsumerStatsResponse) GetMsgRateRedeliver() float64 {
	if m != nil && m.MsgRateRedeliver != nil {
		return *m.MsgRateRedeliver
	}
	return 0
}

func (m *CommandConsumerStatsResponse) GetConsumerName() string {
	if m != nil && m.ConsumerName != nil {
		return *m.ConsumerName
	}
	return ""
}

func (m *CommandConsumerStatsResponse) GetAvailablePermits() uint64 {
	if m != nil && m.AvailablePermits != nil {
		return *m.AvailablePermits
	}
	return 0
}

func (m *CommandConsumerStatsResponse) GetUnackedMessages() uint64 {
	if m != nil && m.UnackedMessages != nil {
		return *m.UnackedMessages
	}
	return 0
}

func (m *CommandConsumerStatsResponse) GetBlockedConsumerOnUnackedMsgs() bool {
	if m != nil && m.BlockedConsumerOnUnackedMsgs != nil {
		return *m.BlockedConsumerOnUnackedMsgs
	}
	return false
}

func (m *CommandConsumerStatsResponse) GetAddress() string {
	if m != nil && m.Address != nil {
		return *m.Address
	}
	return ""
}

func (m *CommandConsumerStatsResponse) GetConnectedSince() string {
	if m != nil && m.ConnectedSince != nil {
		return *m.ConnectedSince
	}
	return ""
}

func (m *CommandConsumerStatsResponse) GetType() string {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return ""
}

func (m *CommandConsumerStatsResponse) GetMsgRateExpired() float64 {
	if m != nil && m.MsgRateExpired != nil {
		return *m.MsgRateExpired
	}
	return 0
}

func (m *CommandConsumerStatsResponse) GetMsgBacklog() uint64 {
	if m != nil && m.MsgBacklog != nil {
		return *m.MsgBacklog
	}
	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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{38}
}
func (m *CommandGetLastMessageId) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandGetLastMessageId.Unmarshal(m, b)
}
func (m *CommandGetLastMessageId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandGetLastMessageId.Marshal(b, m, deterministic)
}
func (dst *CommandGetLastMessageId) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandGetLastMessageId.Merge(dst, src)
}
func (m *CommandGetLastMessageId) XXX_Size() int {
	return xxx_messageInfo_CommandGetLastMessageId.Size(m)
}
func (m *CommandGetLastMessageId) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandGetLastMessageId.DiscardUnknown(m)
}

var xxx_messageInfo_CommandGetLastMessageId proto.InternalMessageInfo

func (m *CommandGetLastMessageId) GetConsumerId() uint64 {
	if m != nil && m.ConsumerId != nil {
		return *m.ConsumerId
	}
	return 0
}

func (m *CommandGetLastMessageId) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

type CommandGetLastMessageIdResponse struct {
	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"`
	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_PulsarApi_976de857822f53b5, []int{39}
}
func (m *CommandGetLastMessageIdResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandGetLastMessageIdResponse.Unmarshal(m, b)
}
func (m *CommandGetLastMessageIdResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandGetLastMessageIdResponse.Marshal(b, m, deterministic)
}
func (dst *CommandGetLastMessageIdResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandGetLastMessageIdResponse.Merge(dst, src)
}
func (m *CommandGetLastMessageIdResponse) XXX_Size() int {
	return xxx_messageInfo_CommandGetLastMessageIdResponse.Size(m)
}
func (m *CommandGetLastMessageIdResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandGetLastMessageIdResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CommandGetLastMessageIdResponse proto.InternalMessageInfo

func (m *CommandGetLastMessageIdResponse) GetLastMessageId() *MessageIdData {
	if m != nil {
		return m.LastMessageId
	}
	return nil
}

func (m *CommandGetLastMessageIdResponse) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

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"`
	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_PulsarApi_976de857822f53b5, []int{40}
}
func (m *CommandGetTopicsOfNamespace) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandGetTopicsOfNamespace.Unmarshal(m, b)
}
func (m *CommandGetTopicsOfNamespace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandGetTopicsOfNamespace.Marshal(b, m, deterministic)
}
func (dst *CommandGetTopicsOfNamespace) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandGetTopicsOfNamespace.Merge(dst, src)
}
func (m *CommandGetTopicsOfNamespace) XXX_Size() int {
	return xxx_messageInfo_CommandGetTopicsOfNamespace.Size(m)
}
func (m *CommandGetTopicsOfNamespace) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandGetTopicsOfNamespace.DiscardUnknown(m)
}

var xxx_messageInfo_CommandGetTopicsOfNamespace proto.InternalMessageInfo

const Default_CommandGetTopicsOfNamespace_Mode CommandGetTopicsOfNamespace_Mode = CommandGetTopicsOfNamespace_PERSISTENT

func (m *CommandGetTopicsOfNamespace) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

func (m *CommandGetTopicsOfNamespace) GetNamespace() string {
	if m != nil && m.Namespace != nil {
		return *m.Namespace
	}
	return ""
}

func (m *CommandGetTopicsOfNamespace) GetMode() CommandGetTopicsOfNamespace_Mode {
	if m != nil && m.Mode != nil {
		return *m.Mode
	}
	return Default_CommandGetTopicsOfNamespace_Mode
}

type CommandGetTopicsOfNamespaceResponse struct {
	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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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_PulsarApi_976de857822f53b5, []int{41}
}
func (m *CommandGetTopicsOfNamespaceResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandGetTopicsOfNamespaceResponse.Unmarshal(m, b)
}
func (m *CommandGetTopicsOfNamespaceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandGetTopicsOfNamespaceResponse.Marshal(b, m, deterministic)
}
func (dst *CommandGetTopicsOfNamespaceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandGetTopicsOfNamespaceResponse.Merge(dst, src)
}
func (m *CommandGetTopicsOfNamespaceResponse) XXX_Size() int {
	return xxx_messageInfo_CommandGetTopicsOfNamespaceResponse.Size(m)
}
func (m *CommandGetTopicsOfNamespaceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandGetTopicsOfNamespaceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CommandGetTopicsOfNamespaceResponse proto.InternalMessageInfo

func (m *CommandGetTopicsOfNamespaceResponse) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

func (m *CommandGetTopicsOfNamespaceResponse) GetTopics() []string {
	if m != nil {
		return m.Topics
	}
	return nil
}

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:"-"`
}

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_PulsarApi_976de857822f53b5, []int{42}
}
func (m *CommandGetSchema) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandGetSchema.Unmarshal(m, b)
}
func (m *CommandGetSchema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandGetSchema.Marshal(b, m, deterministic)
}
func (dst *CommandGetSchema) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandGetSchema.Merge(dst, src)
}
func (m *CommandGetSchema) XXX_Size() int {
	return xxx_messageInfo_CommandGetSchema.Size(m)
}
func (m *CommandGetSchema) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandGetSchema.DiscardUnknown(m)
}

var xxx_messageInfo_CommandGetSchema proto.InternalMessageInfo

func (m *CommandGetSchema) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

func (m *CommandGetSchema) GetTopic() string {
	if m != nil && m.Topic != nil {
		return *m.Topic
	}
	return ""
}

func (m *CommandGetSchema) GetSchemaVersion() []byte {
	if m != nil {
		return m.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_PulsarApi_976de857822f53b5, []int{43}
}
func (m *CommandGetSchemaResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommandGetSchemaResponse.Unmarshal(m, b)
}
func (m *CommandGetSchemaResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommandGetSchemaResponse.Marshal(b, m, deterministic)
}
func (dst *CommandGetSchemaResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandGetSchemaResponse.Merge(dst, src)
}
func (m *CommandGetSchemaResponse) XXX_Size() int {
	return xxx_messageInfo_CommandGetSchemaResponse.Size(m)
}
func (m *CommandGetSchemaResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandGetSchemaResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CommandGetSchemaResponse proto.InternalMessageInfo

func (m *CommandGetSchemaResponse) GetRequestId() uint64 {
	if m != nil && m.RequestId != nil {
		return *m.RequestId
	}
	return 0
}

func (m *CommandGetSchemaResponse) GetErrorCode() ServerError {
	if m != nil && m.ErrorCode != nil {
		return *m.ErrorCode
	}
	return ServerError_UnknownError
}

func (m *CommandGetSchemaResponse) GetErrorMessage() string {
	if m != nil && m.ErrorMessage != nil {
		return *m.ErrorMessage
	}
	return ""
}

func (m *CommandGetSchemaResponse) GetSchema() *Schema {
	if m != nil {
		return m.Schema
	}
	return nil
}

func (m *CommandGetSchemaResponse) GetSchemaVersion() []byte {
	if m != nil {
		return m.SchemaVersion
	}
	return nil
}

type BaseCommand struct {
	Type                            *BaseCommand_Type                        `protobuf:"varint,1,req,name=type,enum=pulsar.proto.BaseCommand_Type" json:"type,omitempty"`
	Connect                         *CommandConnect                          `protobuf:"bytes,2,opt,name=connect" json:"connect,omitempty"`
	Connected                       *CommandConnected                        `protobuf:"bytes,3,opt,name=connected" json:"connected,omitempty"`
	Subscribe                       *CommandSubscribe                        `protobuf:"bytes,4,opt,name=subscribe" json:"subscribe,omitempty"`
	Producer                        *CommandProducer                         `protobuf:"bytes,5,opt,name=producer" json:"producer,omitempty"`
	Send                            *CommandSend                             `protobuf:"bytes,6,opt,name=send" json:"send,omitempty"`
	SendReceipt                     *CommandSendReceipt                      `protobuf:"bytes,7,opt,name=send_receipt,json=sendReceipt" json:"send_receipt,omitempty"`
	SendError                       *CommandSendError                        `protobuf:"bytes,8,opt,name=send_error,json=sendError" json:"send_error,omitempty"`
	Message                         *CommandMessage                          `protobuf:"bytes,9,opt,name=message" json:"message,omitempty"`
	Ack                             *CommandAck                              `protobuf:"bytes,10,opt,name=ack" json:"ack,omitempty"`
	Flow                            *CommandFlow                             `protobuf:"bytes,11,opt,name=flow" json:"flow,omitempty"`
	Unsubscribe                     *CommandUnsubscribe                      `protobuf:"bytes,12,opt,name=unsubscribe" json:"unsubscribe,omitempty"`
	Success                         *CommandSuccess                          `protobuf:"bytes,13,opt,name=success" json:"success,omitempty"`
	Error                           *CommandError                            `protobuf:"bytes,14,opt,name=error" json:"error,omitempty"`
	CloseProducer                   *CommandCloseProducer                    `protobuf:"bytes,15,opt,name=close_producer,json=closeProducer" json:"close_producer,omitempty"`
	CloseConsumer                   *CommandCloseConsumer                    `protobuf:"bytes,16,opt,name=close_consumer,json=closeConsumer" json:"close_consumer,omitempty"`
	ProducerSuccess                 *CommandProducerSuccess                  `protobuf:"bytes,17,opt,name=producer_success,json=producerSuccess" json:"producer_success,omitempty"`
	Ping                            *CommandPing                             `protobuf:"bytes,18,opt,name=ping" json:"ping,omitempty"`
	Pong                            *CommandPong                             `protobuf:"bytes,19,opt,name=pong" json:"pong,omitempty"`
	RedeliverUnacknowledgedMessages *CommandRedeliverUnacknowledgedMessages  `protobuf:"bytes,20,opt,name=redeliverUnacknowledgedMessages" json:"redeliverUnacknowledgedMessages,omitempty"`
	PartitionMetadata               *CommandPartitionedTopicMetadata         `protobuf:"bytes,21,opt,name=partitionMetadata" json:"partitionMetadata,omitempty"`
	PartitionMetadataResponse       *CommandPartitionedTopicMetadataResponse `protobuf:"bytes,22,opt,name=partitionMetadataResponse" json:"partitionMetadataResponse,omitempty"`
	LookupTopic                     *CommandLookupTopic                      `protobuf:"bytes,23,opt,name=lookupTopic" json:"lookupTopic,omitempty"`
	LookupTopicResponse             *CommandLookupTopicResponse              `protobuf:"bytes,24,opt,name=lookupTopicResponse" json:"lookupTopicResponse,omitempty"`
	ConsumerStats                   *CommandConsumerStats                    `protobuf:"bytes,25,opt,name=consumerStats" json:"consumerStats,omitempty"`
	ConsumerStatsResponse           *CommandConsumerStatsResponse            `protobuf:"bytes,26,opt,name=consumerStatsResponse" json:"consumerStatsResponse,omitempty"`
	ReachedEndOfTopic               *CommandReachedEndOfTopic                `protobuf:"bytes,27,opt,name=reachedEndOfTopic" json:"reachedEndOfTopic,omitempty"`
	Seek                            *CommandSeek                             `protobuf:"bytes,28,opt,name=seek" json:"seek,omitempty"`
	GetLastMessageId                *CommandGetLastMessageId                 `protobuf:"bytes,29,opt,name=getLastMessageId" json:"getLastMessageId,omitempty"`
	GetLastMessageIdResponse        *CommandGetLastMessageIdResponse         `protobuf:"bytes,30,opt,name=getLastMessageIdResponse" json:"getLastMessageIdResponse,omitempty"`
	ActiveConsumerChange            *CommandActiveConsumerChange             `protobuf:"bytes,31,opt,name=active_consumer_change,json=activeConsumerChange" json:"active_consumer_change,omitempty"`
	GetTopicsOfNamespace            *CommandGetTopicsOfNamespace             `protobuf:"bytes,32,opt,name=getTopicsOfNamespace" json:"getTopicsOfNamespace,omitempty"`
	GetTopicsOfNamespaceResponse    *CommandGetTopicsOfNamespaceResponse     `protobuf:"bytes,33,opt,name=getTopicsOfNamespaceResponse" json:"getTopicsOfNamespaceResponse,omitempty"`
	GetSchema                       *CommandGetSchema                        `protobuf:"bytes,34,opt,name=getSchema" json:"getSchema,omitempty"`
	GetSchemaResponse               *CommandGetSchemaResponse                `protobuf:"bytes,35,opt,name=getSchemaResponse" json:"getSchemaResponse,omitempty"`
	AuthChallenge                   *CommandAuthChallenge                    `protobuf:"bytes,36,opt,name=authChallenge" json:"authChallenge,omitempty"`
	AuthResponse                    *CommandAuthResponse                     `protobuf:"bytes,37,opt,name=authResponse" json:"authResponse,omitempty"`
	XXX_NoUnkeyedLiteral            struct{}                                 `json:"-"`
	XXX_unrecognized                []byte                                   `json:"-"`
	XXX_sizecache                   int32                                    `json:"-"`
}

func (m *BaseCommand) Reset()         { *m = BaseCommand{} }
func (m *BaseCommand) String() string { return proto.CompactTextString(m) }
func (*BaseCommand) ProtoMessage()    {}
func (*BaseCommand) Descriptor() ([]byte, []int) {
	return fileDescriptor_PulsarApi_976de857822f53b5, []int{44}
}
func (m *BaseCommand) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BaseCommand.Unmarshal(m, b)
}
func (m *BaseCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BaseCommand.Marshal(b, m, deterministic)
}
func (dst *BaseCommand) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BaseCommand.Merge(dst, src)
}
func (m *BaseCommand) XXX_Size() int {
	return xxx_messageInfo_BaseCommand.Size(m)
}
func (m *BaseCommand) XXX_DiscardUnknown() {
	xxx_messageInfo_BaseCommand.DiscardUnknown(m)
}

var xxx_messageInfo_BaseCommand proto.InternalMessageInfo

func (m *BaseCommand) GetType() BaseCommand_Type {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return BaseCommand_CONNECT
}

func (m *BaseCommand) GetConnect() *CommandConnect {
	if m != nil {
		return m.Connect
	}
	return nil
}

func (m *BaseCommand) GetConnected() *CommandConnected {
	if m != nil {
		return m.Connected
	}
	return nil
}

func (m *BaseCommand) GetSubscribe() *CommandSubscribe {
	if m != nil {
		return m.Subscribe
	}
	return nil
}

func (m *BaseCommand) GetProducer() *CommandProducer {
	if m != nil {
		return m.Producer
	}
	return nil
}

func (m *BaseCommand) GetSend() *CommandSend {
	if m != nil {
		return m.Send
	}
	return nil
}

func (m *BaseCommand) GetSendReceipt() *CommandSendReceipt {
	if m != nil {
		return m.SendReceipt
	}
	return nil
}

func (m *BaseCommand) GetSendError() *CommandSendError {
	if m != nil {
		return m.SendError
	}
	return nil
}

func (m *BaseCommand) GetMessage() *CommandMessage {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *BaseCommand) GetAck() *CommandAck {
	if m != nil {
		return m.Ack
	}
	return nil
}

func (m *BaseCommand) GetFlow() *CommandFlow {
	if m != nil {
		return m.Flow
	}
	return nil
}

func (m *BaseCommand) GetUnsubscribe() *CommandUnsubscribe {
	if m != nil {
		return m.Unsubscribe
	}
	return nil
}

func (m *BaseCommand) GetSuccess() *CommandSuccess {
	if m != nil {
		return m.Success
	}
	return nil
}

func (m *BaseCommand) GetError() *CommandError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *BaseCommand) GetCloseProducer() *CommandCloseProducer {
	if m != nil {
		return m.CloseProducer
	}
	return nil
}

func (m *BaseCommand) GetCloseConsumer() *CommandCloseConsumer {
	if m != nil {
		return m.CloseConsumer
	}
	return nil
}

func (m *BaseCommand) GetProducerSuccess() *CommandProducerSuccess {
	if m != nil {
		return m.ProducerSuccess
	}
	return nil
}

func (m *BaseCommand) GetPing() *CommandPing {
	if m != nil {
		return m.Ping
	}
	return nil
}

func (m *BaseCommand) GetPong() *CommandPong {
	if m != nil {
		return m.Pong
	}
	return nil
}

func (m *BaseCommand) GetRedeliverUnacknowledgedMessages() *CommandRedeliverUnacknowledgedMessages {
	if m != nil {
		return m.RedeliverUnacknowledgedMessages
	}
	return nil
}

func (m *BaseCommand) GetPartitionMetadata() *CommandPartitionedTopicMetadata {
	if m != nil {
		return m.PartitionMetadata
	}
	return nil
}

func (m *BaseCommand) GetPartitionMetadataResponse() *CommandPartitionedTopicMetadataResponse {
	if m != nil {
		return m.PartitionMetadataResponse
	}
	return nil
}

func (m *BaseCommand) GetLookupTopic() *CommandLookupTopic {
	if m != nil {
		return m.LookupTopic
	}
	return nil
}

func (m *BaseCommand) GetLookupTopicResponse() *CommandLookupTopicResponse {
	if m != nil {
		return m.LookupTopicResponse
	}
	return nil
}

func (m *BaseCommand) GetConsumerStats() *CommandConsumerStats {
	if m != nil {
		return m.ConsumerStats
	}
	return nil
}

func (m *BaseCommand) GetConsumerStatsResponse() *CommandConsumerStatsResponse {
	if m != nil {
		return m.ConsumerStatsResponse
	}
	return nil
}

func (m *BaseCommand) GetReachedEndOfTopic() *CommandReachedEndOfTopic {
	if m != nil {
		return m.ReachedEndOfTopic
	}
	return nil
}

func (m *BaseCommand) GetSeek() *CommandSeek {
	if m != nil {
		return m.Seek
	}
	return nil
}

func (m *BaseCommand) GetGetLastMessageId() *CommandGetLastMessageId {
	if m != nil {
		return m.GetLastMessageId
	}
	return nil
}

func (m *BaseCommand) GetGetLastMessageIdResponse() *CommandGetLastMessageIdResponse {
	if m != nil {
		return m.GetLastMessageIdResponse
	}
	return nil
}

func (m *BaseCommand) GetActiveConsumerChange() *CommandActiveConsumerChange {
	if m != nil {
		return m.ActiveConsumerChange
	}
	return nil
}

func (m *BaseCommand) GetGetTopicsOfNamespace() *CommandGetTopicsOfNamespace {
	if m != nil {
		return m.GetTopicsOfNamespace
	}
	return nil
}

func (m *BaseCommand) GetGetTopicsOfNamespaceResponse() *CommandGetTopicsOfNamespaceResponse {
	if m != nil {
		return m.GetTopicsOfNamespaceResponse
	}
	return nil
}

func (m *BaseCommand) GetGetSchema() *CommandGetSchema {
	if m != nil {
		return m.GetSchema
	}
	return nil
}

func (m *BaseCommand) GetGetSchemaResponse() *CommandGetSchemaResponse {
	if m != nil {
		return m.GetSchemaResponse
	}
	return nil
}

func (m *BaseCommand) GetAuthChallenge() *CommandAuthChallenge {
	if m != nil {
		return m.AuthChallenge
	}
	return nil
}

func (m *BaseCommand) GetAuthResponse() *CommandAuthResponse {
	if m != nil {
		return m.AuthResponse
	}
	return nil
}

func init() {
	proto.RegisterType((*Schema)(nil), "pulsar.proto.Schema")
	proto.RegisterType((*MessageIdData)(nil), "pulsar.proto.MessageIdData")
	proto.RegisterType((*KeyValue)(nil), "pulsar.proto.KeyValue")
	proto.RegisterType((*KeyLongValue)(nil), "pulsar.proto.KeyLongValue")
	proto.RegisterType((*EncryptionKeys)(nil), "pulsar.proto.EncryptionKeys")
	proto.RegisterType((*MessageMetadata)(nil), "pulsar.proto.MessageMetadata")
	proto.RegisterType((*SingleMessageMetadata)(nil), "pulsar.proto.SingleMessageMetadata")
	proto.RegisterType((*CommandConnect)(nil), "pulsar.proto.CommandConnect")
	proto.RegisterType((*CommandConnected)(nil), "pulsar.proto.CommandConnected")
	proto.RegisterType((*CommandAuthResponse)(nil), "pulsar.proto.CommandAuthResponse")
	proto.RegisterType((*CommandAuthChallenge)(nil), "pulsar.proto.CommandAuthChallenge")
	proto.RegisterType((*AuthData)(nil), "pulsar.proto.AuthData")
	proto.RegisterType((*CommandSubscribe)(nil), "pulsar.proto.CommandSubscribe")
	proto.RegisterType((*CommandPartitionedTopicMetadata)(nil), "pulsar.proto.CommandPartitionedTopicMetadata")
	proto.RegisterType((*CommandPartitionedTopicMetadataResponse)(nil), "pulsar.proto.CommandPartitionedTopicMetadataResponse")
	proto.RegisterType((*CommandLookupTopic)(nil), "pulsar.proto.CommandLookupTopic")
	proto.RegisterType((*CommandLookupTopicResponse)(nil), "pulsar.proto.CommandLookupTopicResponse")
	proto.RegisterType((*CommandProducer)(nil), "pulsar.proto.CommandProducer")
	proto.RegisterType((*CommandSend)(nil), "pulsar.proto.CommandSend")
	proto.RegisterType((*CommandSendReceipt)(nil), "pulsar.proto.CommandSendReceipt")
	proto.RegisterType((*CommandSendError)(nil), "pulsar.proto.CommandSendError")
	proto.RegisterType((*CommandMessage)(nil), "pulsar.proto.CommandMessage")
	proto.RegisterType((*CommandAck)(nil), "pulsar.proto.CommandAck")
	proto.RegisterType((*CommandActiveConsumerChange)(nil), "pulsar.proto.CommandActiveConsumerChange")
	proto.RegisterType((*CommandFlow)(nil), "pulsar.proto.CommandFlow")
	proto.RegisterType((*CommandUnsubscribe)(nil), "pulsar.proto.CommandUnsubscribe")
	proto.RegisterType((*CommandSeek)(nil), "pulsar.proto.CommandSeek")
	proto.RegisterType((*CommandReachedEndOfTopic)(nil), "pulsar.proto.CommandReachedEndOfTopic")
	proto.RegisterType((*CommandCloseProducer)(nil), "pulsar.proto.CommandCloseProducer")
	proto.RegisterType((*CommandCloseConsumer)(nil), "pulsar.proto.CommandCloseConsumer")
	proto.RegisterType((*CommandRedeliverUnacknowledgedMessages)(nil), "pulsar.proto.CommandRedeliverUnacknowledgedMessages")
	proto.RegisterType((*CommandSuccess)(nil), "pulsar.proto.CommandSuccess")
	proto.RegisterType((*CommandProducerSuccess)(nil), "pulsar.proto.CommandProducerSuccess")
	proto.RegisterType((*CommandError)(nil), "pulsar.proto.CommandError")
	proto.RegisterType((*CommandPing)(nil), "pulsar.proto.CommandPing")
	proto.RegisterType((*CommandPong)(nil), "pulsar.proto.CommandPong")
	proto.RegisterType((*CommandConsumerStats)(nil), "pulsar.proto.CommandConsumerStats")
	proto.RegisterType((*CommandConsumerStatsResponse)(nil), "pulsar.proto.CommandConsumerStatsResponse")
	proto.RegisterType((*CommandGetLastMessageId)(nil), "pulsar.proto.CommandGetLastMessageId")
	proto.RegisterType((*CommandGetLastMessageIdResponse)(nil), "pulsar.proto.CommandGetLastMessageIdResponse")
	proto.RegisterType((*CommandGetTopicsOfNamespace)(nil), "pulsar.proto.CommandGetTopicsOfNamespace")
	proto.RegisterType((*CommandGetTopicsOfNamespaceResponse)(nil), "pulsar.proto.CommandGetTopicsOfNamespaceResponse")
	proto.RegisterType((*CommandGetSchema)(nil), "pulsar.proto.CommandGetSchema")
	proto.RegisterType((*CommandGetSchemaResponse)(nil), "pulsar.proto.CommandGetSchemaResponse")
	proto.RegisterType((*BaseCommand)(nil), "pulsar.proto.BaseCommand")
	proto.RegisterEnum("pulsar.proto.CompressionType", CompressionType_name, CompressionType_value)
	proto.RegisterEnum("pulsar.proto.ServerError", ServerError_name, ServerError_value)
	proto.RegisterEnum("pulsar.proto.AuthMethod", AuthMethod_name, AuthMethod_value)
	proto.RegisterEnum("pulsar.proto.ProtocolVersion", ProtocolVersion_name, ProtocolVersion_value)
	proto.RegisterEnum("pulsar.proto.Schema_Type", Schema_Type_name, Schema_Type_value)
	proto.RegisterEnum("pulsar.proto.CommandSubscribe_SubType", CommandSubscribe_SubType_name, CommandSubscribe_SubType_value)
	proto.RegisterEnum("pulsar.proto.CommandSubscribe_InitialPosition", CommandSubscribe_InitialPosition_name, CommandSubscribe_InitialPosition_value)
	proto.RegisterEnum("pulsar.proto.CommandPartitionedTopicMetadataResponse_LookupType", CommandPartitionedTopicMetadataResponse_LookupType_name, CommandPartitionedTopicMetadataResponse_LookupType_value)
	proto.RegisterEnum("pulsar.proto.CommandLookupTopicResponse_LookupType", CommandLookupTopicResponse_LookupType_name, CommandLookupTopicResponse_LookupType_value)
	proto.RegisterEnum("pulsar.proto.CommandAck_AckType", CommandAck_AckType_name, CommandAck_AckType_value)
	proto.RegisterEnum("pulsar.proto.CommandAck_ValidationError", CommandAck_ValidationError_name, CommandAck_ValidationError_value)
	proto.RegisterEnum("pulsar.proto.CommandGetTopicsOfNamespace_Mode", CommandGetTopicsOfNamespace_Mode_name, CommandGetTopicsOfNamespace_Mode_value)
	proto.RegisterEnum("pulsar.proto.BaseCommand_Type", BaseCommand_Type_name, BaseCommand_Type_value)
}

func init() { proto.RegisterFile("PulsarApi.proto", fileDescriptor_PulsarApi_976de857822f53b5) }

var fileDescriptor_PulsarApi_976de857822f53b5 = []byte{
	// 4429 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5b, 0x4f, 0x8f, 0xdb, 0x48,
	0x76, 0x37, 0xf5, 0xa7, 0x5b, 0x7a, 0xfa, 0x57, 0xae, 0x6e, 0x7b, 0x34, 0xb6, 0xc7, 0x96, 0xe9,
	0x3f, 0xdb, 0xe3, 0x1d, 0x77, 0xec, 0xb6, 0xd7, 0x99, 0xf1, 0x6e, 0x80, 0x51, 0xab, 0x69, 0x5b,
	0x71, 0x5b, 0xd2, 0x94, 0xd4, 0x5e, 0xcc, 0x64, 0x17, 0x5c, 0x36, 0x59, 0x56, 0x13, 0x4d, 0x91,
	0x0a, 0x49, 0xf5, 0xb8, 0xe7, 0x90, 0xdb, 0x22, 0x97, 0x20, 0x41, 0x92, 0x63, 0x80, 0x2c, 0x72,
	0xc8, 0x07, 0xc8, 0x2d, 0xc0, 0x7e, 0x83, 0xfd, 0x06, 0x39, 0x05, 0x58, 0x20, 0xc7, 0x05, 0x02,
	0x24, 0x1f, 0x20, 0xa8, 0x62, 0xf1, 0x9f, 0x44, 0x49, 0xed, 0x99, 0x3d, 0xe4, 0x24, 0xf2, 0xd5,
	0xab, 0x57, 0xaf, 0x5e, 0xfd, 0xea, 0xbd, 0x57, 0xaf, 0x28, 0x68, 0x0c, 0x66, 0x96, 0xa7, 0xb9,
	0xed, 0xa9, 0xb9, 0x3b, 0x75, 0x1d, 0xdf, 0xc1, 0xd5, 0x29, 0x27, 0x04, 0x6f, 0xf2, 0xef, 0x73,
	0xb0, 0x31, 0xd4, 0x4f, 0xe8, 0x44, 0xc3, 0x18, 0x0a, 0xb6, 0x36, 0xa1, 0x4d, 0xa9, 0x95, 0xdb,
	0x29, 0x13, 0xfe, 0x8c, 0x6f, 0x41, 0xc5, 0xe3, 0xad, 0xaa, 0xa1, 0xf9, 0x5a, 0x33, 0xdf, 0xca,
	0xed, 0x54, 0x09, 0x04, 0xa4, 0x03, 0xcd, 0xd7, 0xf0, 0x43, 0x28, 0xf8, 0xe7, 0x53, 0xda, 0x2c,
	0xb4, 0x72, 0x3b, 0xf5, 0xbd, 0x8f, 0x77, 0x93, 0xc2, 0x77, 0x03, 0xc1, 0xbb, 0xa3, 0xf3, 0x29,
	0x25, 0x9c, 0x0d, 0x3f, 0x03, 0x98, 0xba, 0xce, 0x94, 0xba, 0xbe, 0x49, 0xbd, 0x66, 0xb1, 0x95,
	0xdf, 0xa9, 0xec, 0x5d, 0x4d, 0x77, 0x7a, 0x4d, 0xcf, 0xdf, 0x6a, 0xd6, 0x8c, 0x92, 0x04, 0xa7,
	0xfc, 0x5b, 0x09, 0x0a, 0x4c, 0x0c, 0x2e, 0x41, 0xa1, 0xe7, 0xd8, 0x14, 0x5d, 0xc2, 0x00, 0x1b,
	0x43, 0xdf, 0x35, 0xed, 0x31, 0x92, 0x18, 0xf5, 0xcf, 0x3d, 0xc7, 0x46, 0x39, 0x5c, 0x85, 0xd2,
	0x80, 0x89, 0x39, 0x9e, 0xbd, 0x43, 0x79, 0x46, 0x6f, 0x9f, 0xb9, 0x0e, 0x2a, 0xb0, 0xa7, 0x7d,
	0xc7, 0xb1, 0x50, 0x91, 0x3d, 0x75, 0x6d, 0xff, 0x73, 0xb4, 0x81, 0xcb, 0x50, 0xec, 0xda, 0xfe,
	0xe3, 0x67, 0x68, 0x53, 0x3c, 0x3e, 0xd9, 0x43, 0x25, 0xf1, 0xf8, 0xec, 0x29, 0x2a, 0xb3, 0xc7,
	0x17, 0x96, 0xa3, 0xf9, 0x08, 0xd8, 0x68, 0x07, 0xce, 0xec, 0xd8, 0xa2, 0xa8, 0xc2, 0x24, 0x1c,
	0x68, 0x3e, 0x45, 0x55, 0xf6, 0x34, 0x32, 0x27, 0x14, 0xd5, 0x70, 0x0d, 0xca, 0xec, 0xc9, 0xf3,
	0xb5, 0xc9, 0x14, 0xd5, 0x99, 0x1a, 0xe1, 0x3c, 0x50, 0x43, 0xfe, 0x1b, 0x09, 0x6a, 0x6f, 0xa8,
	0xe7, 0x69, 0x63, 0xda, 0x35, 0xb8, 0xd9, 0xae, 0x41, 0xc9, 0xa2, 0xc6, 0x98, 0xba, 0x5d, 0x83,
	0xdb, 0xbb, 0x40, 0xa2, 0x77, 0xdc, 0x84, 0x4d, 0x6a, 0xfb, 0xee, 0x79, 0xd7, 0x68, 0xe6, 0x78,
	0x53, 0xf8, 0x8a, 0x5b, 0x50, 0x9e, 0x6a, 0xae, 0x6f, 0xfa, 0xa6, 0x63, 0x37, 0xf3, 0x2d, 0x69,
	0xa7, 0xf8, 0x3c, 0xf7, 0xf0, 0x31, 0x89, 0x89, 0xf8, 0x0e, 0x54, 0x8e, 0x35, 0x5f, 0x3f, 0x51,
	0x4d, 0xdb, 0xa0, 0xef, 0x9b, 0x85, 0x88, 0x07, 0x38, 0xb9, 0xcb, 0xa8, 0xf2, 0x5e, 0xac, 0x1c,
	0x46, 0x90, 0x3f, 0xa5, 0xe7, 0x62, 0xcd, 0xd9, 0x23, 0xde, 0x86, 0xe2, 0x19, 0x6b, 0xe2, 0x83,
	0x97, 0x49, 0xf0, 0x22, 0x3f, 0x83, 0xea, 0x6b, 0x7a, 0x7e, 0xe8, 0xd8, 0xe3, 0x0b, 0xf5, 0x2b,
	0x84, 0xfd, 0x2c, 0xa8, 0x2b, 0xb6, 0xee, 0x9e, 0x4f, 0x99, 0x7a, 0xaf, 0xe9, 0xb9, 0xb7, 0xae,
	0x67, 0x55, 0xf4, 0xc4, 0x7b, 0x50, 0x9a, 0x50, 0x5f, 0x13, 0xb8, 0x5b, 0x05, 0x94, 0x88, 0x4f,
	0xfe, 0xfd, 0x06, 0x34, 0x84, 0xa1, 0xdf, 0x08, 0x1a, 0xbe, 0x03, 0xb5, 0xa9, 0xeb, 0x18, 0x33,
	0x9d, 0xba, 0x6a, 0x02, 0xdf, 0xd5, 0x90, 0xd8, 0x0b, 0x71, 0x4e, 0xff, 0x72, 0x46, 0x6d, 0x9d,
	0xaa, 0x66, 0x68, 0x77, 0x08, 0x49, 0x5d, 0x03, 0xdf, 0x86, 0xea, 0x74, 0x76, 0x6c, 0x99, 0xde,
	0x89, 0xea, 0x9b, 0x13, 0xca, 0x77, 0x42, 0x81, 0x54, 0x04, 0x8d, 0x2d, 0xfd, 0x1c, 0xb6, 0x0b,
	0x17, 0xc5, 0x36, 0xfe, 0x11, 0x34, 0x5c, 0x3a, 0xb5, 0x4c, 0x5d, 0xf3, 0xa9, 0xa1, 0xbe, 0x73,
	0x9d, 0x49, 0xb3, 0xd8, 0x92, 0x76, 0xca, 0xa4, 0x1e, 0x93, 0x5f, 0xb8, 0xce, 0x84, 0xcf, 0x24,
	0x5c, 0x69, 0x95, 0xd9, 0x70, 0x83, 0xb3, 0x55, 0x23, 0xe2, 0x6b, 0x7a, 0xce, 0x14, 0x8d, 0xba,
	0xa9, 0xbe, 0xd3, 0xdc, 0x6c, 0xe5, 0x77, 0xca, 0xa4, 0x12, 0xd1, 0x46, 0x0e, 0x56, 0xa0, 0xa2,
	0x3b, 0x93, 0xa9, 0x4b, 0x3d, 0x8f, 0x01, 0xa9, 0xd4, 0x92, 0x76, 0xea, 0x7b, 0x9f, 0xa4, 0x35,
	0xed, 0xc4, 0x0c, 0x6c, 0xdf, 0x3d, 0x2f, 0xf4, 0xfa, 0x3d, 0x85, 0x24, 0xfb, 0xe1, 0x5d, 0xb8,
	0x3c, 0xb3, 0x43, 0x02, 0x35, 0x54, 0xcf, 0xfc, 0x8e, 0x36, 0xcb, 0x2d, 0x69, 0xa7, 0xf6, 0x5c,
	0x7a, 0x44, 0x50, 0xb2, 0x6d, 0x68, 0x7e, 0x47, 0xf1, 0x53, 0xb8, 0x62, 0xcf, 0x26, 0xea, 0x24,
	0x58, 0x1f, 0x4f, 0x35, 0x6d, 0x95, 0x83, 0xb2, 0x59, 0xe1, 0x28, 0x95, 0x1e, 0x13, 0x6c, 0xcf,
	0x26, 0x62, 0xf9, 0xbc, 0xae, 0xbd, 0xcf, 0x1a, 0x71, 0x0b, 0x80, 0x9e, 0x51, 0xdb, 0x0f, 0xcc,
	0x5e, 0x6d, 0x49, 0x3b, 0x05, 0x26, 0xbe, 0xcc, 0x89, 0xdc, 0xee, 0x0a, 0x34, 0x68, 0x04, 0x31,
	0x66, 0x17, 0xaf, 0x59, 0xe3, 0xc6, 0xbf, 0x91, 0x9e, 0x52, 0x1a, 0x87, 0xa4, 0x4e, 0xd3, 0xb8,
	0xfc, 0x51, 0x4a, 0x8c, 0x66, 0x8d, 0x9d, 0x66, 0x3d, 0x58, 0x86, 0x98, 0xdc, 0xb6, 0xc6, 0x0e,
	0xfe, 0x14, 0x50, 0x82, 0x71, 0xaa, 0xb9, 0xda, 0xa4, 0xd9, 0x68, 0x49, 0x3b, 0x55, 0x92, 0x10,
	0x30, 0x60, 0x64, 0x7c, 0x0f, 0xea, 0xc2, 0x7d, 0x9e, 0x51, 0x97, 0x1b, 0x1b, 0x71, 0xc6, 0x5a,
	0x40, 0x7d, 0x1b, 0x10, 0xf1, 0x97, 0xf0, 0x71, 0x6a, 0x61, 0xd5, 0xe3, 0x67, 0x4f, 0x55, 0x6a,
	0xeb, 0x8e, 0x41, 0x8d, 0xe6, 0xe5, 0x96, 0xb4, 0x53, 0x7a, 0x5e, 0x7c, 0xa7, 0x59, 0x1e, 0x25,
	0x57, 0x93, 0x6b, 0xbd, 0xff, 0xec, 0xa9, 0x12, 0x30, 0xb1, 0x55, 0x77, 0x5c, 0x83, 0x32, 0x77,
	0xc8, 0x91, 0x81, 0xf9, 0x30, 0x95, 0x90, 0xc6, 0x80, 0x71, 0x1f, 0x1a, 0x06, 0xb5, 0xcc, 0x33,
	0xea, 0xaa, 0x9a, 0xb0, 0xe6, 0x56, 0x4b, 0xda, 0xc9, 0x93, 0x9a, 0x20, 0xb7, 0x03, 0x73, 0xde,
	0x82, 0xca, 0x44, 0x73, 0x4f, 0xa9, 0xab, 0x72, 0xc7, 0xbe, 0xcd, 0x16, 0x87, 0x40, 0x40, 0x62,
	0x50, 0x90, 0x7f, 0x97, 0x83, 0x2b, 0x43, 0xd3, 0x1e, 0x5b, 0x74, 0x7e, 0xab, 0xa5, 0x77, 0x80,
	0x74, 0xe1, 0x1d, 0xb0, 0x00, 0xec, 0x5c, 0x36, 0xb0, 0xa7, 0xda, 0xb9, 0xe5, 0x68, 0x02, 0x69,
	0x6c, 0x07, 0x16, 0x49, 0x45, 0xd0, 0x38, 0xc2, 0x1e, 0x40, 0x8d, 0x61, 0x4e, 0xd3, 0xd9, 0x46,
	0x72, 0x66, 0x3e, 0xf7, 0x7f, 0x91, 0xed, 0xaa, 0x51, 0x5b, 0x7f, 0xe6, 0xcf, 0xe1, 0xaa, 0x98,
	0x81, 0xab, 0x95, 0xab, 0xb2, 0xf1, 0x7d, 0x56, 0x65, 0x73, 0x61, 0x55, 0xe4, 0x7f, 0xcd, 0x43,
	0xbd, 0xe3, 0x4c, 0x26, 0x9a, 0x6d, 0x74, 0x1c, 0xdb, 0xa6, 0xba, 0xcf, 0x40, 0xa3, 0x5b, 0x26,
	0x53, 0x2d, 0x04, 0x4d, 0xe0, 0xb1, 0x6a, 0x01, 0x35, 0x04, 0xcd, 0x17, 0x50, 0xd1, 0x66, 0xfe,
	0x89, 0x3a, 0xa1, 0xfe, 0x89, 0x63, 0x70, 0x93, 0xd5, 0xf7, 0x9a, 0x69, 0x6b, 0xb7, 0x67, 0xfe,
	0xc9, 0x1b, 0xde, 0x4e, 0x40, 0x8b, 0x9e, 0xf1, 0x0e, 0xa0, 0x44, 0xd7, 0xc0, 0x2b, 0x0a, 0x97,
	0x13, 0x73, 0x71, 0xbf, 0x78, 0x1d, 0xca, 0x9c, 0x53, 0x78, 0x61, 0xa6, 0x7e, 0x89, 0x11, 0x78,
	0x10, 0xfb, 0x0c, 0x10, 0x1f, 0x46, 0x77, 0xac, 0x48, 0xd5, 0x20, 0xe2, 0x48, 0x8f, 0x48, 0x23,
	0x6c, 0x0a, 0xf5, 0x7d, 0x08, 0x5b, 0x53, 0xd7, 0x79, 0x7f, 0xae, 0xfa, 0x8e, 0x7a, 0xec, 0x3a,
	0x0c, 0x60, 0x33, 0xd7, 0x12, 0x3e, 0x0c, 0xf1, 0xa6, 0x91, 0xb3, 0xcf, 0x1b, 0x8e, 0x5c, 0x0b,
	0x3f, 0x04, 0xec, 0xb8, 0xe6, 0xd8, 0xb4, 0x35, 0x4b, 0x9d, 0xba, 0xa6, 0xad, 0x9b, 0x53, 0xcd,
	0xe2, 0x16, 0x2c, 0x93, 0xcb, 0x61, 0xcb, 0x20, 0x6c, 0xc0, 0x9f, 0x25, 0xd8, 0x63, 0x8d, 0x4b,
	0x81, 0xf0, 0xb0, 0xa5, 0x1d, 0x6a, 0xfe, 0x08, 0xb6, 0xd3, 0xdc, 0xc2, 0x88, 0x65, 0xce, 0x8f,
	0x93, 0xfc, 0x81, 0x31, 0xe4, 0xbf, 0x97, 0x00, 0xa5, 0xd7, 0x89, 0x1a, 0x7c, 0x7b, 0x53, 0x97,
	0xed, 0xa8, 0xb9, 0x95, 0x0a, 0xa8, 0xe1, 0xcc, 0xb3, 0xec, 0x94, 0x5b, 0x6a, 0xa7, 0x1d, 0x40,
	0x13, 0xed, 0x7d, 0xe8, 0x26, 0x43, 0xac, 0xb3, 0x4d, 0x58, 0x9f, 0x68, 0xef, 0xc5, 0x96, 0x63,
	0x70, 0x97, 0xff, 0x59, 0x82, 0x2d, 0xa1, 0x13, 0xd3, 0x94, 0x50, 0x6f, 0xea, 0xd8, 0x1e, 0xcd,
	0x04, 0x90, 0xb4, 0x08, 0xa0, 0x3d, 0x28, 0xb9, 0xa2, 0x0b, 0x57, 0x67, 0x61, 0xaf, 0x86, 0xe6,
	0x22, 0x11, 0x5f, 0xe6, 0x54, 0xf2, 0xcb, 0xa6, 0x22, 0xff, 0x8b, 0x04, 0xdb, 0x09, 0x05, 0x3b,
	0x27, 0x9a, 0x65, 0x51, 0x7b, 0x4c, 0x33, 0x0d, 0x27, 0x2d, 0x1a, 0xee, 0x29, 0x94, 0xf5, 0xb0,
	0xcf, 0x1a, 0x15, 0x63, 0xc6, 0x0f, 0xd4, 0xf1, 0x2b, 0x28, 0x45, 0xb0, 0xc8, 0xda, 0x17, 0xd2,
	0xfa, 0x7d, 0x91, 0x4b, 0xef, 0x0b, 0xf9, 0x37, 0x1b, 0x11, 0x56, 0x86, 0xb3, 0x63, 0x4f, 0x77,
	0xcd, 0x63, 0xca, 0x92, 0x1c, 0xdf, 0x99, 0x9a, 0xba, 0x80, 0x48, 0xf0, 0x82, 0x65, 0xa8, 0x7a,
	0x01, 0x0b, 0x8f, 0x1a, 0x22, 0xe7, 0x4a, 0xd1, 0xf0, 0x97, 0xb0, 0xe9, 0xcd, 0x8e, 0x99, 0xeb,
	0xe5, 0x3e, 0xaf, 0xbe, 0x77, 0x7f, 0x21, 0x54, 0xa7, 0x86, 0xda, 0x1d, 0x06, 0xdc, 0x24, 0xec,
	0xc6, 0x5c, 0xba, 0xee, 0xd8, 0xde, 0x6c, 0x42, 0x5d, 0x96, 0xdd, 0x14, 0x82, 0xec, 0x26, 0x24,
	0x75, 0x0d, 0xfc, 0x09, 0x80, 0xcb, 0x72, 0x1d, 0xcf, 0x67, 0xed, 0x45, 0xde, 0x5e, 0x16, 0x94,
	0xae, 0xc1, 0xfc, 0x73, 0xd4, 0x9f, 0x1b, 0x45, 0x24, 0x1e, 0x21, 0x91, 0x9b, 0xe4, 0x1e, 0xd4,
	0xa7, 0xae, 0xe9, 0xb8, 0xa6, 0x7f, 0xae, 0x5a, 0xf4, 0x8c, 0x06, 0x9b, 0xb5, 0x48, 0x6a, 0x21,
	0xf5, 0x90, 0x11, 0xf1, 0x4d, 0xd8, 0x34, 0x66, 0xae, 0x76, 0x6c, 0x51, 0xbe, 0x3b, 0x4b, 0xcf,
	0x0b, 0xbe, 0x3b, 0xa3, 0x24, 0x24, 0x62, 0x05, 0x90, 0xe7, 0x6b, 0xae, 0x1f, 0x6d, 0x00, 0x33,
	0xd8, 0x96, 0x95, 0xbd, 0xeb, 0xe9, 0x69, 0xa7, 0x12, 0x6a, 0x52, 0xe7, 0x9d, 0x22, 0x5a, 0x2a,
	0x7b, 0x84, 0x8b, 0x65, 0x8f, 0x6c, 0x06, 0x2e, 0xd5, 0x0c, 0x35, 0x8a, 0x13, 0x3c, 0x33, 0x29,
	0x91, 0x1a, 0xa3, 0x76, 0x42, 0x22, 0xfe, 0x0c, 0x36, 0x82, 0xf0, 0xcd, 0xb3, 0x91, 0xca, 0xde,
	0x76, 0xd6, 0xa1, 0x87, 0x08, 0x1e, 0xfc, 0x2b, 0x68, 0x98, 0xb6, 0xe9, 0x9b, 0x9a, 0x35, 0x70,
	0xbc, 0x20, 0x73, 0xaf, 0x71, 0x57, 0xbd, 0xbb, 0x66, 0x15, 0xbb, 0xe9, 0x5e, 0xcf, 0x37, 0x0e,
	0x35, 0x9f, 0x7a, 0x3e, 0x99, 0x17, 0x87, 0xbf, 0x84, 0x1b, 0x71, 0xc6, 0x97, 0x44, 0x8e, 0xea,
	0xf9, 0x9a, 0x4f, 0x79, 0x16, 0x53, 0x22, 0xd7, 0x22, 0x9e, 0x61, 0x82, 0x65, 0xc8, 0x38, 0xe4,
	0x7d, 0xd8, 0x14, 0x98, 0x61, 0xe7, 0x18, 0xe5, 0xbd, 0x6e, 0xcd, 0x3c, 0xf3, 0x2c, 0x3c, 0x64,
	0x9d, 0x68, 0x2e, 0x35, 0x90, 0xc4, 0xce, 0x34, 0x2f, 0x34, 0xd3, 0x72, 0xce, 0xa8, 0x8b, 0x72,
	0xb8, 0x0e, 0xf0, 0x9a, 0x9e, 0xab, 0xa2, 0x35, 0x2f, 0xff, 0x18, 0x1a, 0x73, 0x1a, 0xb3, 0xce,
	0x81, 0xce, 0xe8, 0x12, 0xeb, 0xac, 0x68, 0xae, 0x65, 0xb2, 0x37, 0x49, 0xfe, 0x2f, 0x09, 0x6e,
	0x89, 0x09, 0x0f, 0xc2, 0xd0, 0x49, 0x8d, 0x11, 0xdb, 0x12, 0x51, 0x32, 0x91, 0xbd, 0x61, 0xd2,
	0x48, 0xcd, 0xcd, 0x23, 0x35, 0x3b, 0x6a, 0xe4, 0x3f, 0x2c, 0x6a, 0x14, 0x3e, 0x30, 0x6a, 0x14,
	0x97, 0x46, 0x8d, 0x7f, 0xcf, 0xc1, 0x8f, 0xd6, 0xcc, 0x33, 0xf2, 0xda, 0x37, 0x01, 0xa2, 0x34,
	0xc2, 0xe3, 0x6e, 0xa7, 0x46, 0x12, 0x94, 0x75, 0x33, 0xff, 0x45, 0xc2, 0x9b, 0xe7, 0x39, 0xc0,
	0xbe, 0xcc, 0x04, 0xd8, 0x3a, 0x3d, 0x76, 0x0f, 0x1d, 0xe7, 0x74, 0x36, 0xe5, 0x0e, 0x24, 0xf6,
	0xfb, 0x7f, 0x02, 0x45, 0xea, 0xba, 0x8e, 0xcb, 0x6d, 0xb3, 0x78, 0xce, 0xe7, 0x5e, 0x5b, 0x61,
	0x0c, 0x24, 0xe0, 0x63, 0x87, 0x58, 0xb1, 0x81, 0x85, 0x79, 0xc2, 0x57, 0xf9, 0x1e, 0x40, 0x3c,
	0x04, 0xae, 0x30, 0xe8, 0xe9, 0x3a, 0xf5, 0xbc, 0x00, 0x6d, 0x0c, 0x61, 0x0c, 0x6d, 0xf2, 0xaf,
	0x73, 0x80, 0x85, 0xca, 0x82, 0x9d, 0xaf, 0xff, 0xf7, 0x42, 0xc5, 0x8f, 0xa1, 0xc6, 0xd6, 0x8b,
	0x79, 0x21, 0xcd, 0x37, 0xcf, 0x02, 0x03, 0x45, 0xd9, 0x5b, 0xba, 0x6d, 0x09, 0x84, 0x0a, 0x1f,
	0x06, 0xa1, 0xe2, 0x07, 0x42, 0x68, 0x63, 0x29, 0x84, 0xfe, 0x23, 0x0f, 0xd7, 0x16, 0xed, 0x10,
	0xa1, 0xe6, 0x01, 0xa0, 0x20, 0x99, 0x62, 0x6b, 0x60, 0xea, 0xf4, 0xc8, 0xb5, 0x44, 0xc8, 0x5a,
	0xa0, 0xe3, 0x47, 0xb0, 0x35, 0x4f, 0x1b, 0x59, 0x9e, 0x48, 0xb6, 0xb3, 0x9a, 0x70, 0x7f, 0x01,
	0x54, 0x4f, 0x32, 0x41, 0x95, 0xa1, 0x59, 0x36, 0x8e, 0xd2, 0x0b, 0x55, 0x58, 0xbb, 0x50, 0xc5,
	0x15, 0x0b, 0x15, 0x61, 0x72, 0xe3, 0xc3, 0x31, 0xb9, 0x99, 0xc2, 0x24, 0x4f, 0xf5, 0x83, 0xdc,
	0xf4, 0xc4, 0x75, 0x66, 0xe3, 0x13, 0xd5, 0x0b, 0xcc, 0xc0, 0x33, 0xd4, 0x52, 0x3a, 0xd5, 0xe7,
	0x89, 0x6a, 0xc0, 0x16, 0x1b, 0x4b, 0x7e, 0x92, 0x42, 0x75, 0x15, 0x4a, 0x84, 0x1a, 0xa6, 0x4b,
	0x75, 0xe6, 0xfb, 0x2a, 0xb0, 0x29, 0x72, 0x46, 0x24, 0x25, 0x30, 0x9e, 0x93, 0xff, 0x31, 0x07,
	0x8d, 0x70, 0x5b, 0x8a, 0x6a, 0xc4, 0x12, 0x80, 0xdf, 0x82, 0x4a, 0x54, 0xc4, 0x88, 0xeb, 0x13,
	0x21, 0x69, 0x21, 0x82, 0xe7, 0x33, 0x22, 0x78, 0xba, 0x08, 0x52, 0x10, 0x27, 0xac, 0x64, 0x11,
	0xe4, 0x0e, 0x94, 0xc5, 0x01, 0x96, 0x1a, 0x69, 0xcb, 0xc7, 0xf4, 0x54, 0x60, 0xdd, 0xb8, 0x60,
	0x60, 0x8d, 0x23, 0xe6, 0xe6, 0xfa, 0x88, 0x29, 0xcf, 0xa0, 0x12, 0x06, 0x43, 0x6a, 0x1b, 0xf3,
	0x53, 0x97, 0x16, 0xa6, 0xbe, 0xb6, 0x76, 0x73, 0x17, 0xaa, 0xc9, 0xc2, 0x43, 0x98, 0x0c, 0x3e,
	0x26, 0x95, 0x44, 0xbd, 0x41, 0xfe, 0x07, 0x29, 0x72, 0x38, 0x6c, 0x5c, 0x42, 0x75, 0x6a, 0x4e,
	0xfd, 0x3f, 0xc2, 0xf0, 0xcf, 0x01, 0x12, 0xb9, 0x4c, 0x7e, 0x7d, 0x2e, 0x53, 0x9e, 0x84, 0xaf,
	0xf2, 0x6f, 0xe2, 0x63, 0x07, 0x53, 0x8a, 0xc3, 0xf9, 0x8f, 0xa0, 0x52, 0xb4, 0x75, 0xf2, 0x99,
	0x65, 0xdb, 0x95, 0x5b, 0xa7, 0xc0, 0x71, 0x19, 0xb9, 0xf3, 0x7f, 0x92, 0xa2, 0x03, 0xac, 0x98,
	0xc5, 0x7c, 0xba, 0x29, 0x2d, 0xa4, 0x9b, 0x69, 0x8b, 0x30, 0xf5, 0x2e, 0x6c, 0x11, 0x96, 0xdd,
	0xbb, 0x54, 0x54, 0x2c, 0xce, 0x55, 0xdd, 0x99, 0xd9, 0x3e, 0xb7, 0x29, 0x2f, 0x3a, 0x35, 0xe2,
	0xa6, 0x0e, 0x6b, 0x91, 0xff, 0x37, 0x0f, 0x10, 0x9e, 0x40, 0xf4, 0xd3, 0xf5, 0x9a, 0xfd, 0x14,
	0x4a, 0x9a, 0x7e, 0x1a, 0x54, 0x3e, 0x72, 0xdc, 0x36, 0xad, 0x4c, 0x87, 0xd7, 0xd6, 0x4f, 0x77,
	0xdb, 0xfa, 0x69, 0x90, 0x66, 0x6b, 0xc1, 0xc3, 0xc2, 0x42, 0xe7, 0x3f, 0x60, 0x5a, 0x43, 0x40,
	0x67, 0x9a, 0x65, 0x1a, 0x1a, 0x4f, 0xdc, 0x92, 0xb1, 0x76, 0x67, 0xa9, 0x02, 0x6f, 0xa3, 0x0e,
	0xc1, 0x5a, 0x35, 0xce, 0xd2, 0x04, 0xa6, 0xd0, 0x42, 0xb5, 0xfd, 0xda, 0xc2, 0x6e, 0x8d, 0x8a,
	0xba, 0xa9, 0x8a, 0xfb, 0xa7, 0xb0, 0x29, 0x26, 0xc8, 0x52, 0xbd, 0xae, 0x6d, 0x98, 0x67, 0xa6,
	0x31, 0xd3, 0x2c, 0x74, 0x89, 0xbd, 0x77, 0x66, 0x93, 0x99, 0xc5, 0xdd, 0x30, 0x92, 0xe4, 0xbf,
	0x93, 0xa0, 0x31, 0xa7, 0x0b, 0xbe, 0x09, 0xd7, 0x8e, 0xe6, 0x0a, 0x80, 0x1d, 0xc7, 0x75, 0x67,
	0x3c, 0xeb, 0x44, 0x97, 0xf0, 0x55, 0xc0, 0x07, 0x34, 0x51, 0x4d, 0xe4, 0xbd, 0x90, 0x84, 0xb7,
	0x01, 0x75, 0x4e, 0xa8, 0x7e, 0xea, 0xcd, 0x26, 0x6f, 0x4c, 0x6f, 0xa2, 0xf9, 0xfa, 0x09, 0xca,
	0xe1, 0x8f, 0xe1, 0x0a, 0xaf, 0x06, 0x1e, 0xd0, 0x21, 0x75, 0x4d, 0xcd, 0x32, 0xbf, 0xa3, 0x41,
	0x87, 0x3c, 0xde, 0x82, 0xc6, 0x01, 0x0d, 0xab, 0x6e, 0x01, 0xb1, 0x20, 0x1f, 0xc3, 0xf5, 0xc8,
	0x4e, 0x4c, 0xc9, 0x8e, 0x58, 0xe1, 0xce, 0x89, 0x66, 0x5f, 0x04, 0xa0, 0x32, 0x94, 0x4d, 0x4f,
	0xd5, 0x78, 0x5f, 0x1e, 0x1f, 0x23, 0x4f, 0x58, 0x32, 0xbd, 0x40, 0xa4, 0xfc, 0x36, 0x72, 0x53,
	0x2f, 0x2c, 0xe7, 0xdb, 0xf5, 0x32, 0xef, 0x43, 0x5d, 0x2c, 0xf7, 0x80, 0xba, 0x13, 0xd3, 0xf7,
	0x38, 0xc0, 0x6a, 0x64, 0x8e, 0x2a, 0x8f, 0x22, 0x37, 0x74, 0x64, 0x7b, 0xd1, 0xf1, 0x71, 0xad,
	0xf8, 0xd5, 0x29, 0x90, 0xfc, 0x5b, 0x29, 0xe1, 0x55, 0xe9, 0xe9, 0x0f, 0x95, 0xf7, 0x43, 0x9c,
	0x1a, 0x4b, 0x82, 0xc2, 0xbe, 0xa9, 0x9a, 0x3a, 0xc3, 0x7b, 0x81, 0xe0, 0xd0, 0x1e, 0x71, 0x69,
	0x5d, 0xfe, 0x29, 0x34, 0x85, 0xf2, 0x84, 0x6a, 0xfa, 0x09, 0x35, 0x14, 0xdb, 0xe8, 0xbf, 0x1b,
	0x85, 0xa1, 0x71, 0xe5, 0x4c, 0xe4, 0xb7, 0x51, 0x11, 0xa2, 0x63, 0x39, 0x1e, 0x8d, 0x22, 0xed,
	0x5a, 0x37, 0xba, 0xc6, 0xa4, 0x73, 0x72, 0x43, 0x8c, 0xfd, 0xe0, 0xa5, 0xfa, 0x6b, 0x09, 0xee,
	0x47, 0xb3, 0x15, 0xee, 0xec, 0xc8, 0xd6, 0xf4, 0x53, 0xdb, 0xf9, 0x96, 0x5f, 0x12, 0x85, 0x8e,
	0xd6, 0x5b, 0x3f, 0xd4, 0xcf, 0xa0, 0x12, 0x2f, 0x13, 0x43, 0xdc, 0x5a, 0x9f, 0x04, 0xd1, 0x3a,
	0x79, 0xf2, 0x2f, 0x23, 0xd7, 0x2e, 0x72, 0xf4, 0x39, 0xd5, 0xa5, 0x79, 0x54, 0xc4, 0x81, 0x3e,
	0x77, 0x81, 0x40, 0xff, 0x6f, 0x12, 0x5c, 0x9d, 0x4b, 0x7f, 0x2e, 0x38, 0xce, 0x42, 0x3a, 0x93,
	0xcb, 0xb8, 0xd3, 0xf9, 0x0c, 0x90, 0xa5, 0x79, 0xbe, 0x9a, 0x0c, 0x85, 0x0c, 0xa8, 0x79, 0x7e,
	0x21, 0x56, 0x67, 0x6d, 0xc3, 0x38, 0x24, 0x2e, 0x96, 0xea, 0x0b, 0x19, 0xa5, 0x7a, 0xf9, 0x3d,
	0x54, 0x85, 0xca, 0x81, 0x9f, 0x5b, 0xa3, 0x68, 0x14, 0x68, 0x73, 0x1f, 0x1e, 0x68, 0xf3, 0xe9,
	0x40, 0x5b, 0x8b, 0x36, 0xf0, 0xc0, 0xb4, 0xc7, 0xc9, 0x57, 0xc7, 0x1e, 0x27, 0xc1, 0x28, 0x56,
	0x9f, 0x1d, 0xed, 0xd7, 0x1a, 0x72, 0x5d, 0x65, 0x48, 0xfe, 0xef, 0x02, 0xdc, 0xc8, 0x12, 0x4c,
	0xb2, 0x33, 0xfa, 0x85, 0x01, 0x3e, 0x07, 0xe0, 0x13, 0x53, 0x75, 0xc7, 0xa0, 0xa2, 0x48, 0xbd,
	0xc2, 0x0a, 0x65, 0xce, 0xdc, 0x71, 0x0c, 0x96, 0x8d, 0xd6, 0x82, 0x9e, 0xb1, 0x3d, 0x78, 0xca,
	0xca, 0x89, 0x61, 0xaa, 0x71, 0x13, 0x60, 0xe2, 0x8d, 0x89, 0xe6, 0xd3, 0xbe, 0x28, 0xf7, 0x4b,
	0x24, 0x41, 0x61, 0xc7, 0xa3, 0x89, 0x37, 0x16, 0xe9, 0xfa, 0x74, 0xe6, 0x33, 0xae, 0x22, 0xe7,
	0x5a, 0xa0, 0x0b, 0x5e, 0xd6, 0x33, 0xda, 0x76, 0xfc, 0x68, 0x11, 0xf0, 0xa6, 0xe8, 0x58, 0x86,
	0x54, 0xf1, 0x4b, 0x9c, 0x27, 0xd2, 0x05, 0xb1, 0x07, 0x80, 0xb4, 0x33, 0xcd, 0xb4, 0xb4, 0x63,
	0x2b, 0x72, 0xf9, 0x25, 0xee, 0xe2, 0x16, 0xe8, 0x78, 0x07, 0x1a, 0x33, 0xb6, 0xc5, 0xe3, 0xbd,
	0xcd, 0x8b, 0x5e, 0x05, 0x32, 0x4f, 0xc6, 0xfb, 0x70, 0xe3, 0xd8, 0x72, 0x18, 0x29, 0x5c, 0x8f,
	0xbe, 0x7d, 0x24, 0x78, 0xbc, 0xb1, 0xd7, 0x04, 0x5e, 0xed, 0x59, 0xc9, 0xc3, 0x40, 0xa6, 0x19,
	0x06, 0x8b, 0xbc, 0xbc, 0xc2, 0x55, 0x26, 0xe1, 0x2b, 0x0b, 0x52, 0x7a, 0x58, 0xde, 0x1e, 0x9a,
	0xb6, 0x1e, 0xdc, 0xb8, 0x95, 0xc9, 0x1c, 0x15, 0x63, 0x71, 0xed, 0x5f, 0xe3, 0xad, 0xc1, 0xdd,
	0x3e, 0x0b, 0x70, 0x81, 0x9d, 0x94, 0xf7, 0x53, 0xd3, 0xa5, 0x06, 0xaf, 0x3c, 0x49, 0x64, 0x8e,
	0x2a, 0xd6, 0x6c, 0x5f, 0xd3, 0x4f, 0x2d, 0x67, 0xcc, 0x6f, 0xce, 0x0a, 0x24, 0x41, 0x91, 0xbf,
	0x86, 0x8f, 0x04, 0xe2, 0x5e, 0x52, 0xff, 0x50, 0xf3, 0x12, 0x55, 0xbd, 0x1f, 0xea, 0x5a, 0x7f,
	0x1d, 0xd7, 0x9d, 0xe6, 0x65, 0x47, 0x80, 0xee, 0x40, 0x83, 0xbb, 0x8d, 0x44, 0x78, 0x93, 0xd6,
	0x67, 0xa8, 0x35, 0x2b, 0xa5, 0xe8, 0x1a, 0x3d, 0xfe, 0x53, 0x8a, 0x12, 0x94, 0x97, 0xd4, 0xe7,
	0x71, 0xcc, 0xeb, 0xbf, 0x63, 0xa8, 0xf1, 0xa6, 0x9a, 0xbe, 0x76, 0x53, 0xdd, 0x80, 0xb2, 0x1d,
	0xf2, 0x0a, 0xd7, 0x17, 0x13, 0x70, 0x0f, 0x0a, 0x13, 0xb6, 0xd9, 0xf2, 0x2b, 0xca, 0x8c, 0x59,
	0xa3, 0xee, 0xbe, 0x71, 0x0c, 0xfa, 0x1c, 0x06, 0x0a, 0x19, 0x76, 0x87, 0x23, 0xa5, 0x37, 0x22,
	0x5c, 0x8e, 0xfc, 0x04, 0x0a, 0xac, 0x85, 0xa5, 0x7d, 0x71, 0x1b, 0xba, 0x84, 0x31, 0xd4, 0x7b,
	0xfd, 0x9e, 0x9a, 0xa0, 0x49, 0x78, 0x13, 0xf2, 0xed, 0xc3, 0x43, 0x94, 0x93, 0x7f, 0x01, 0x77,
	0x56, 0x0c, 0x75, 0x51, 0xef, 0x71, 0x15, 0x36, 0xf8, 0xf9, 0x37, 0x88, 0x5c, 0x65, 0x22, 0xde,
	0x64, 0x3b, 0x3a, 0x15, 0xbd, 0xa4, 0xbe, 0xf8, 0x7c, 0x65, 0x8d, 0xa8, 0xe8, 0x5c, 0x9d, 0x4b,
	0x9e, 0xab, 0x17, 0xbd, 0x7e, 0x3e, 0xcb, 0xeb, 0xff, 0x41, 0x8a, 0x12, 0x90, 0x68, 0xc0, 0xff,
	0x27, 0x1e, 0x30, 0x0e, 0xb9, 0x85, 0x0b, 0x54, 0xa3, 0x17, 0xe7, 0x5b, 0xcc, 0x9a, 0xef, 0xff,
	0x5c, 0x83, 0xca, 0xbe, 0xc6, 0x72, 0x1a, 0x3e, 0x67, 0xbc, 0x27, 0xb6, 0xbb, 0xc4, 0xa3, 0xd8,
	0xcd, 0xf4, 0x10, 0x09, 0xc6, 0xf4, 0xa7, 0x3e, 0x9b, 0xc2, 0x69, 0x88, 0x64, 0xe0, 0x46, 0x26,
	0x12, 0x45, 0x65, 0x84, 0x84, 0xcc, 0xf8, 0x67, 0x50, 0x8e, 0x9c, 0x8d, 0x48, 0x2c, 0x6f, 0xae,
	0xea, 0x49, 0x0d, 0x12, 0x77, 0x60, 0xbd, 0xa3, 0xa4, 0x59, 0x58, 0xe4, 0xe6, 0xea, 0x42, 0x3b,
	0x89, 0x3b, 0xe0, 0x2f, 0xa0, 0x14, 0xa6, 0x10, 0xdc, 0x30, 0x95, 0x8c, 0xcf, 0x22, 0x92, 0xe9,
	0x0a, 0x89, 0xd8, 0xf1, 0x43, 0x28, 0x78, 0xd4, 0x0e, 0x2a, 0x79, 0x95, 0xf9, 0x05, 0x4e, 0xd6,
	0x15, 0x38, 0x1b, 0xee, 0x40, 0x95, 0xfd, 0xaa, 0x6e, 0x50, 0x66, 0x10, 0x85, 0x91, 0xd6, 0xf2,
	0x6e, 0x01, 0x1f, 0xa9, 0x78, 0x89, 0xda, 0xc4, 0x9f, 0x01, 0x70, 0x21, 0x41, 0x8a, 0x51, 0x5a,
	0x35, 0xdb, 0xb0, 0x78, 0x40, 0xca, 0x5e, 0x54, 0x47, 0x78, 0x16, 0xe7, 0x1a, 0xe5, 0x15, 0x2b,
	0x24, 0x90, 0x16, 0x57, 0xcb, 0x1e, 0x40, 0x5e, 0xd3, 0x4f, 0x79, 0xa4, 0xa9, 0xcc, 0xdf, 0x38,
	0xc7, 0xc7, 0x53, 0xc2, 0x98, 0x98, 0x59, 0xde, 0x59, 0xce, 0xb7, 0x3c, 0xce, 0x2c, 0x33, 0x0b,
	0x3b, 0x3f, 0x11, 0xce, 0x86, 0xf7, 0xa1, 0x32, 0x8b, 0x4f, 0x3d, 0xe2, 0x82, 0x25, 0xdb, 0x2a,
	0x89, 0xd3, 0x11, 0x49, 0x76, 0x62, 0xd3, 0xf2, 0x82, 0x34, 0x92, 0x87, 0xa7, 0x65, 0xd3, 0x12,
	0xa9, 0x26, 0x09, 0x99, 0xf1, 0xa3, 0x30, 0x57, 0xab, 0xf3, 0x5e, 0xd7, 0x32, 0x7b, 0xa5, 0x92,
	0xb5, 0x2e, 0xd4, 0x75, 0x96, 0xfa, 0xab, 0x11, 0x68, 0x1a, 0xbc, 0xab, 0x9c, 0x8d, 0xd7, 0xe4,
	0xe9, 0x83, 0xd4, 0xf4, 0xd4, 0x61, 0x24, 0x12, 0x15, 0x06, 0x33, 0xfe, 0xa5, 0xc8, 0x4a, 0x51,
	0x61, 0x6c, 0x17, 0xa2, 0xa2, 0xf3, 0x47, 0x9f, 0xdf, 0x7f, 0x06, 0xc9, 0x71, 0x68, 0x88, 0xcb,
	0x5c, 0xd8, 0xdd, 0x95, 0x60, 0x0e, 0x0d, 0xd2, 0x98, 0xce, 0x25, 0xe3, 0x0f, 0xa1, 0x30, 0x35,
	0xed, 0x31, 0xff, 0xa8, 0x64, 0xd9, 0x1a, 0xb2, 0x9c, 0x94, 0x70, 0x36, 0xce, 0xee, 0xd8, 0x63,
	0xfe, 0x75, 0xc9, 0x52, 0x76, 0x87, 0xb3, 0x3b, 0xf6, 0x18, 0xff, 0x15, 0xdc, 0x72, 0x57, 0x1f,
	0x73, 0xf8, 0x37, 0x28, 0x95, 0xbd, 0xa7, 0x99, 0x92, 0xd6, 0x1c, 0x91, 0xc8, 0x3a, 0xe1, 0xf8,
	0x2f, 0xe0, 0x72, 0x74, 0xcb, 0x12, 0x5e, 0x86, 0x34, 0xaf, 0xf0, 0x11, 0x1f, 0x7e, 0xd8, 0x0d,
	0xca, 0xa2, 0x1c, 0xec, 0x25, 0xbe, 0x21, 0x99, 0xbf, 0x69, 0x69, 0x5e, 0xe5, 0x83, 0xfc, 0xe4,
	0x7b, 0x5d, 0xd3, 0x90, 0xe5, 0x72, 0xd9, 0x26, 0xb2, 0xe2, 0x82, 0x7c, 0xf3, 0xa3, 0x15, 0x9b,
	0x28, 0x59, 0xb8, 0x4f, 0x76, 0xc2, 0xdf, 0xc0, 0x96, 0xb5, 0x58, 0xd4, 0x6f, 0x36, 0xb9, 0xac,
	0x9d, 0x8b, 0x5e, 0x02, 0x90, 0x2c, 0x21, 0xf8, 0x55, 0x7c, 0x9d, 0xcc, 0xcf, 0x12, 0xcd, 0x8f,
	0x57, 0x41, 0x3d, 0x75, 0xea, 0x48, 0x77, 0xc4, 0xbf, 0x82, 0x2b, 0x7a, 0xd6, 0xa9, 0xa4, 0x79,
	0x8d, 0x4b, 0x7c, 0x70, 0x01, 0x89, 0xa1, 0xa6, 0xd9, 0x82, 0xf0, 0x08, 0x2e, 0xbb, 0xf3, 0x25,
	0x87, 0xe6, 0x75, 0x2e, 0xfd, 0xfe, 0x12, 0x3c, 0xce, 0x71, 0x93, 0x45, 0x01, 0x41, 0xb0, 0xa0,
	0xa7, 0xcd, 0x1b, 0x2b, 0x83, 0x05, 0x3d, 0x25, 0x9c, 0x0d, 0x7f, 0x05, 0x68, 0x3c, 0x97, 0xae,
	0x36, 0x3f, 0xe1, 0x5d, 0xef, 0x2d, 0xcb, 0xee, 0xd2, 0xb9, 0xed, 0x42, 0x77, 0x6c, 0x42, 0x73,
	0xbc, 0x24, 0x03, 0x6e, 0xde, 0x5c, 0x01, 0xfe, 0x65, 0x69, 0x33, 0x59, 0x2a, 0x0e, 0xab, 0x70,
	0x35, 0xa8, 0xa4, 0x45, 0xbe, 0x4d, 0xd5, 0x79, 0x1d, 0xae, 0x79, 0x8b, 0x0f, 0xf4, 0xe9, 0x92,
	0x08, 0xb2, 0x58, 0xb8, 0x23, 0xdb, 0x5a, 0x56, 0x39, 0xef, 0x97, 0xb0, 0x3d, 0xce, 0x48, 0x32,
	0x9b, 0xad, 0x15, 0xe2, 0x33, 0xb3, 0xd2, 0x4c, 0x31, 0x78, 0x06, 0x37, 0xc6, 0x2b, 0x72, 0xd8,
	0xe6, 0x6d, 0x3e, 0xcc, 0xe3, 0x8b, 0x0f, 0x13, 0x9a, 0x6c, 0xa5, 0x58, 0x96, 0xc9, 0x8c, 0xc3,
	0x5c, 0xb3, 0x29, 0xaf, 0x88, 0xed, 0x71, 0x46, 0x1a, 0x77, 0x60, 0xb8, 0x1d, 0xcf, 0x67, 0xaa,
	0xcd, 0x3b, 0x2b, 0x70, 0xbb, 0x90, 0xd7, 0x92, 0x45, 0x01, 0x6c, 0xe7, 0x6a, 0xc9, 0x0f, 0x79,
	0x9a, 0x77, 0x57, 0xec, 0xdc, 0xd4, 0x27, 0x3f, 0x24, 0xdd, 0x11, 0x2b, 0x50, 0xd5, 0x12, 0xdf,
	0x2c, 0x35, 0xef, 0x71, 0x41, 0xb7, 0x97, 0x0a, 0x8a, 0xb4, 0x4a, 0x75, 0x93, 0x7f, 0x57, 0x14,
	0xdf, 0x85, 0x57, 0x60, 0xb3, 0xd3, 0xef, 0xf5, 0x94, 0xce, 0x08, 0xe5, 0x70, 0x0d, 0xca, 0xe2,
	0x45, 0x39, 0x40, 0x79, 0xf6, 0x3a, 0x3c, 0xda, 0x1f, 0x76, 0x48, 0x77, 0x5f, 0x41, 0x05, 0xfe,
	0x89, 0x38, 0xe9, 0x1f, 0x1c, 0x75, 0x14, 0x12, 0x7c, 0x0e, 0x3e, 0x54, 0x7a, 0x07, 0x68, 0x03,
	0x23, 0xa8, 0xb2, 0x27, 0x95, 0x28, 0x1d, 0xa5, 0x3b, 0x18, 0xa1, 0x4d, 0x76, 0xe2, 0xe1, 0x14,
	0x85, 0x90, 0x3e, 0x41, 0x25, 0x36, 0xc8, 0x1b, 0x65, 0x38, 0x6c, 0xbf, 0x54, 0x50, 0x99, 0x1f,
	0x75, 0x3a, 0xaf, 0x11, 0x30, 0x09, 0x2f, 0x0e, 0xfb, 0x3f, 0x47, 0x15, 0xdc, 0x80, 0xca, 0x51,
	0x2f, 0x1e, 0xaa, 0xca, 0x6f, 0xb7, 0x8f, 0x3a, 0x1d, 0x65, 0x38, 0x44, 0x35, 0x5c, 0x86, 0x62,
	0x20, 0xa8, 0xce, 0x8e, 0x4e, 0x9d, 0xc3, 0xfe, 0x50, 0x51, 0x23, 0x45, 0x1a, 0x31, 0xad, 0xd3,
	0xef, 0x0d, 0x8f, 0xde, 0x28, 0x04, 0x21, 0xbc, 0x0d, 0x28, 0xe4, 0x50, 0x43, 0x41, 0x97, 0xd9,
	0x80, 0x83, 0x6e, 0xef, 0x25, 0xc2, 0xfc, 0xa9, 0xdf, 0x7b, 0x89, 0xb6, 0xf0, 0x3d, 0xb8, 0x4d,
	0x94, 0x03, 0xe5, 0xb0, 0xfb, 0x56, 0x21, 0xea, 0x51, 0xaf, 0xdd, 0x79, 0xdd, 0xeb, 0xff, 0xfc,
	0x50, 0x39, 0x78, 0xa9, 0x1c, 0xa8, 0x42, 0xe7, 0x21, 0xda, 0xc6, 0x4d, 0xd8, 0x1e, 0xb4, 0xc9,
	0xa8, 0x3b, 0xea, 0xf6, 0x7b, 0xbc, 0x65, 0xd4, 0x3e, 0x68, 0x8f, 0xda, 0xe8, 0x0a, 0xbe, 0x0d,
	0x9f, 0x64, 0xb5, 0xa8, 0x44, 0x19, 0x0e, 0xfa, 0xbd, 0xa1, 0x82, 0xae, 0xf2, 0xef, 0x39, 0xfa,
	0xfd, 0xd7, 0x47, 0x03, 0xf4, 0x11, 0xde, 0x82, 0x46, 0xf0, 0x1c, 0x33, 0x34, 0xf9, 0x14, 0x84,
	0xf2, 0xea, 0x70, 0xd4, 0x1e, 0x0d, 0xd1, 0xc7, 0xf8, 0x3a, 0x7c, 0x94, 0xa6, 0xc5, 0x1d, 0xae,
	0x31, 0x75, 0x88, 0xd2, 0xee, 0xbc, 0x52, 0x0e, 0x54, 0x66, 0xe7, 0xfe, 0x0b, 0x75, 0xd4, 0x1f,
	0x74, 0x3b, 0xe8, 0x7a, 0xb0, 0x2c, 0xca, 0x6b, 0x74, 0x03, 0x7f, 0x04, 0x5b, 0x2f, 0x95, 0x91,
	0x7a, 0xd8, 0x1e, 0x8e, 0xc2, 0x99, 0xa8, 0xdd, 0x03, 0xf4, 0x09, 0x6e, 0xc1, 0x8d, 0x8c, 0x86,
	0x58, 0xfc, 0x4d, 0x7c, 0x0d, 0xae, 0xb6, 0x3b, 0xa3, 0xee, 0xdb, 0xd8, 0xa6, 0x6a, 0xe7, 0x55,
	0xbb, 0xf7, 0x52, 0x41, 0xb7, 0x98, 0x5e, 0xac, 0x37, 0x1f, 0x6f, 0xc8, 0x46, 0xee, 0xb5, 0xdf,
	0x28, 0xc3, 0x41, 0xbb, 0xa3, 0xa0, 0x16, 0xbe, 0x0b, 0xad, 0x25, 0x8d, 0xb1, 0xf8, 0xdb, 0x0c,
	0x1e, 0x8c, 0x6b, 0xd8, 0x79, 0xa5, 0xbc, 0x69, 0x23, 0x39, 0xd4, 0x34, 0x78, 0x8f, 0x19, 0xef,
	0x30, 0xbb, 0xb4, 0x8f, 0x46, 0xaf, 0xd8, 0xe0, 0x87, 0x87, 0x0a, 0x1b, 0xff, 0x2e, 0xbe, 0x0c,
	0x35, 0x4e, 0x8b, 0xd8, 0xee, 0x3d, 0x38, 0xe0, 0xb7, 0xc1, 0xc9, 0xcf, 0xae, 0xf9, 0xdf, 0x1d,
	0xfa, 0x3d, 0x05, 0x5d, 0x62, 0x70, 0x3b, 0xfc, 0xe6, 0x69, 0xf0, 0x5f, 0x87, 0x6f, 0x0e, 0xbb,
	0xfb, 0x28, 0xc7, 0x9f, 0x86, 0x23, 0x86, 0x70, 0x80, 0x8d, 0x61, 0xaf, 0x3d, 0x18, 0x7c, 0x8d,
	0x0a, 0x0f, 0xfe, 0x90, 0x87, 0x4a, 0xe2, 0x40, 0xc9, 0x60, 0x7d, 0x64, 0xb3, 0xbc, 0x47, 0xdc,
	0x8e, 0x5c, 0x62, 0x43, 0x87, 0x39, 0x43, 0xe2, 0xda, 0x65, 0xc0, 0xce, 0x7e, 0x9e, 0x4f, 0x6d,
	0x5d, 0xdc, 0xad, 0xe4, 0xd8, 0x84, 0xd8, 0xde, 0xa3, 0xb6, 0x6f, 0xea, 0xf1, 0xdd, 0x0e, 0xca,
	0xe3, 0xab, 0x80, 0xdb, 0xc1, 0x5d, 0xfc, 0x77, 0x09, 0x7a, 0x81, 0x8d, 0x15, 0xfa, 0xe6, 0xfd,
	0x99, 0x77, 0x8e, 0x8a, 0x0c, 0x27, 0xe2, 0x96, 0xbc, 0xe7, 0xf8, 0x84, 0x6a, 0xc6, 0x39, 0xda,
	0x60, 0x60, 0x0d, 0x93, 0xce, 0xfd, 0xa0, 0x4e, 0xf5, 0xd5, 0xcc, 0xf1, 0x35, 0xe5, 0xbd, 0x4e,
	0xa9, 0x41, 0x83, 0x1c, 0x1b, 0x6d, 0xe2, 0x4f, 0xe1, 0xde, 0x4a, 0xb6, 0xf7, 0x3a, 0x0d, 0xae,
	0x93, 0x4a, 0x6c, 0x4a, 0xe1, 0xb5, 0x51, 0xd0, 0xbb, 0xcc, 0x16, 0x98, 0x1d, 0x11, 0xa6, 0x53,
	0xc7, 0xf5, 0xa9, 0x21, 0x4e, 0xb6, 0x41, 0x23, 0x30, 0x7e, 0xee, 0x79, 0x7b, 0x8e, 0xff, 0xc2,
	0x99, 0xd9, 0x06, 0xaa, 0x30, 0x2c, 0x26, 0xbf, 0x8c, 0x8a, 0x5a, 0xaa, 0xfc, 0x4e, 0x2a, 0x2c,
	0xec, 0x85, 0xd4, 0x1a, 0x9b, 0xd9, 0xc8, 0x71, 0xde, 0x68, 0xf6, 0x39, 0x09, 0xce, 0xfa, 0x1e,
	0xaa, 0x33, 0x21, 0x5c, 0xee, 0x88, 0xba, 0x13, 0xd3, 0xd6, 0xfc, 0x70, 0x32, 0x0d, 0x66, 0x9a,
	0x68, 0x32, 0xcc, 0x34, 0x7c, 0x73, 0x77, 0x6d, 0x7e, 0x65, 0x17, 0xa8, 0xa2, 0x4d, 0x28, 0xba,
	0xcc, 0x4c, 0xdb, 0xe5, 0x17, 0x67, 0x9a, 0x6f, 0x1e, 0x5b, 0x34, 0x70, 0xc0, 0x08, 0xb3, 0xb5,
	0x08, 0x95, 0x68, 0x7b, 0x9e, 0x39, 0x16, 0x53, 0xd9, 0x7a, 0xf0, 0x1a, 0x20, 0xfe, 0x5c, 0x84,
	0x43, 0x2d, 0xfe, 0x54, 0x31, 0xf8, 0xa7, 0xcc, 0x16, 0x34, 0x62, 0xda, 0xd7, 0xba, 0xf6, 0xf6,
	0x71, 0xb0, 0xe2, 0x31, 0xb1, 0xcd, 0x16, 0xd9, 0x43, 0xb9, 0x07, 0x7f, 0x2b, 0x41, 0x63, 0x30,
	0xf7, 0x41, 0xea, 0x06, 0xe4, 0xce, 0x1e, 0xa1, 0x4b, 0xfc, 0x97, 0xf5, 0x64, 0xbf, 0x7b, 0x28,
	0xc7, 0x7f, 0x9f, 0xa0, 0x3c, 0xff, 0x7d, 0x8a, 0x0a, 0xfc, 0xf7, 0x27, 0xa8, 0xc8, 0x7f, 0x9f,
	0xa1, 0x0d, 0xfe, 0xfb, 0xa7, 0x68, 0x93, 0xff, 0x7e, 0x8e, 0x4a, 0xfc, 0xf7, 0x8b, 0xc0, 0x71,
	0x9e, 0x3d, 0x7e, 0x84, 0x20, 0x78, 0x78, 0x8c, 0x2a, 0xc1, 0xc3, 0x1e, 0xaa, 0x06, 0x0f, 0x4f,
	0x50, 0x2d, 0x78, 0x78, 0x8a, 0xea, 0xfb, 0xf7, 0x41, 0x76, 0xdc, 0xf1, 0xae, 0x36, 0x65, 0x29,
	0x54, 0x18, 0x1d, 0x74, 0x67, 0x32, 0x71, 0xec, 0x5d, 0x2d, 0xfc, 0x4f, 0xd3, 0xab, 0xfc, 0xff,
	0x05, 0x00, 0x00, 0xff, 0xff, 0x47, 0xe6, 0x3b, 0xba, 0xe7, 0x34, 0x00, 0x00,
}