applicationserver_pubsub.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: lorawan-stack/api/applicationserver_pubsub.proto

package ttnpb

import (
	bytes "bytes"
	context "context"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
	time "time"

	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	types "github.com/gogo/protobuf/types"
	golang_proto "github.com/golang/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = golang_proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
var _ = time.Kitchen

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type ApplicationPubSub_MQTTProvider_QoS int32

const (
	ApplicationPubSub_MQTTProvider_AT_MOST_ONCE  ApplicationPubSub_MQTTProvider_QoS = 0
	ApplicationPubSub_MQTTProvider_AT_LEAST_ONCE ApplicationPubSub_MQTTProvider_QoS = 1
	ApplicationPubSub_MQTTProvider_EXACTLY_ONCE  ApplicationPubSub_MQTTProvider_QoS = 2
)

var ApplicationPubSub_MQTTProvider_QoS_name = map[int32]string{
	0: "AT_MOST_ONCE",
	1: "AT_LEAST_ONCE",
	2: "EXACTLY_ONCE",
}

var ApplicationPubSub_MQTTProvider_QoS_value = map[string]int32{
	"AT_MOST_ONCE":  0,
	"AT_LEAST_ONCE": 1,
	"EXACTLY_ONCE":  2,
}

func (ApplicationPubSub_MQTTProvider_QoS) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1dce56ec18597200, []int{1, 1, 0}
}

type ApplicationPubSubIdentifiers struct {
	ApplicationIdentifiers `protobuf:"bytes,1,opt,name=application_ids,json=applicationIds,proto3,embedded=application_ids" json:"application_ids"`
	PubSubID               string   `protobuf:"bytes,2,opt,name=pub_sub_id,json=pubSubId,proto3" json:"pub_sub_id,omitempty"`
	XXX_NoUnkeyedLiteral   struct{} `json:"-"`
	XXX_sizecache          int32    `json:"-"`
}

func (m *ApplicationPubSubIdentifiers) Reset()      { *m = ApplicationPubSubIdentifiers{} }
func (*ApplicationPubSubIdentifiers) ProtoMessage() {}
func (*ApplicationPubSubIdentifiers) Descriptor() ([]byte, []int) {
	return fileDescriptor_1dce56ec18597200, []int{0}
}
func (m *ApplicationPubSubIdentifiers) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ApplicationPubSubIdentifiers) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ApplicationPubSubIdentifiers.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ApplicationPubSubIdentifiers) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ApplicationPubSubIdentifiers.Merge(m, src)
}
func (m *ApplicationPubSubIdentifiers) XXX_Size() int {
	return m.Size()
}
func (m *ApplicationPubSubIdentifiers) XXX_DiscardUnknown() {
	xxx_messageInfo_ApplicationPubSubIdentifiers.DiscardUnknown(m)
}

var xxx_messageInfo_ApplicationPubSubIdentifiers proto.InternalMessageInfo

func (m *ApplicationPubSubIdentifiers) GetPubSubID() string {
	if m != nil {
		return m.PubSubID
	}
	return ""
}

type ApplicationPubSub struct {
	ApplicationPubSubIdentifiers `protobuf:"bytes,1,opt,name=ids,proto3,embedded=ids" json:"ids"`
	CreatedAt                    time.Time `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3,stdtime" json:"created_at"`
	UpdatedAt                    time.Time `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,proto3,stdtime" json:"updated_at"`
	// The format to use for the body.
	// Supported values depend on the Application Server configuration.
	Format string `protobuf:"bytes,4,opt,name=format,proto3" json:"format,omitempty"`
	// The provider for the PubSub.
	//
	// Types that are valid to be assigned to Provider:
	//	*ApplicationPubSub_NATS
	//	*ApplicationPubSub_MQTT
	Provider isApplicationPubSub_Provider `protobuf_oneof:"provider"`
	// Base topic name to which the messages topic is appended.
	BaseTopic string `protobuf:"bytes,6,opt,name=base_topic,json=baseTopic,proto3" json:"base_topic,omitempty"`
	// The topic to which the Application Server subscribes for downlink queue push operations.
	DownlinkPush *ApplicationPubSub_Message `protobuf:"bytes,7,opt,name=downlink_push,json=downlinkPush,proto3" json:"downlink_push,omitempty"`
	// The topic to which the Application Server subscribes for downlink queue replace operations.
	DownlinkReplace      *ApplicationPubSub_Message `protobuf:"bytes,8,opt,name=downlink_replace,json=downlinkReplace,proto3" json:"downlink_replace,omitempty"`
	UplinkMessage        *ApplicationPubSub_Message `protobuf:"bytes,9,opt,name=uplink_message,json=uplinkMessage,proto3" json:"uplink_message,omitempty"`
	JoinAccept           *ApplicationPubSub_Message `protobuf:"bytes,10,opt,name=join_accept,json=joinAccept,proto3" json:"join_accept,omitempty"`
	DownlinkAck          *ApplicationPubSub_Message `protobuf:"bytes,11,opt,name=downlink_ack,json=downlinkAck,proto3" json:"downlink_ack,omitempty"`
	DownlinkNack         *ApplicationPubSub_Message `protobuf:"bytes,12,opt,name=downlink_nack,json=downlinkNack,proto3" json:"downlink_nack,omitempty"`
	DownlinkSent         *ApplicationPubSub_Message `protobuf:"bytes,13,opt,name=downlink_sent,json=downlinkSent,proto3" json:"downlink_sent,omitempty"`
	DownlinkFailed       *ApplicationPubSub_Message `protobuf:"bytes,14,opt,name=downlink_failed,json=downlinkFailed,proto3" json:"downlink_failed,omitempty"`
	DownlinkQueued       *ApplicationPubSub_Message `protobuf:"bytes,15,opt,name=downlink_queued,json=downlinkQueued,proto3" json:"downlink_queued,omitempty"`
	LocationSolved       *ApplicationPubSub_Message `protobuf:"bytes,16,opt,name=location_solved,json=locationSolved,proto3" json:"location_solved,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *ApplicationPubSub) Reset()      { *m = ApplicationPubSub{} }
func (*ApplicationPubSub) ProtoMessage() {}
func (*ApplicationPubSub) Descriptor() ([]byte, []int) {
	return fileDescriptor_1dce56ec18597200, []int{1}
}
func (m *ApplicationPubSub) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ApplicationPubSub) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ApplicationPubSub.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ApplicationPubSub) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ApplicationPubSub.Merge(m, src)
}
func (m *ApplicationPubSub) XXX_Size() int {
	return m.Size()
}
func (m *ApplicationPubSub) XXX_DiscardUnknown() {
	xxx_messageInfo_ApplicationPubSub.DiscardUnknown(m)
}

var xxx_messageInfo_ApplicationPubSub proto.InternalMessageInfo

type isApplicationPubSub_Provider interface {
	isApplicationPubSub_Provider()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type ApplicationPubSub_NATS struct {
	NATS *ApplicationPubSub_NATSProvider `protobuf:"bytes,17,opt,name=nats,proto3,oneof" json:"nats,omitempty"`
}
type ApplicationPubSub_MQTT struct {
	MQTT *ApplicationPubSub_MQTTProvider `protobuf:"bytes,25,opt,name=mqtt,proto3,oneof" json:"mqtt,omitempty"`
}

func (*ApplicationPubSub_NATS) isApplicationPubSub_Provider() {}
func (*ApplicationPubSub_MQTT) isApplicationPubSub_Provider() {}

func (m *ApplicationPubSub) GetProvider() isApplicationPubSub_Provider {
	if m != nil {
		return m.Provider
	}
	return nil
}

func (m *ApplicationPubSub) GetCreatedAt() time.Time {
	if m != nil {
		return m.CreatedAt
	}
	return time.Time{}
}

func (m *ApplicationPubSub) GetUpdatedAt() time.Time {
	if m != nil {
		return m.UpdatedAt
	}
	return time.Time{}
}

func (m *ApplicationPubSub) GetFormat() string {
	if m != nil {
		return m.Format
	}
	return ""
}

func (m *ApplicationPubSub) GetNATS() *ApplicationPubSub_NATSProvider {
	if x, ok := m.GetProvider().(*ApplicationPubSub_NATS); ok {
		return x.NATS
	}
	return nil
}

func (m *ApplicationPubSub) GetMQTT() *ApplicationPubSub_MQTTProvider {
	if x, ok := m.GetProvider().(*ApplicationPubSub_MQTT); ok {
		return x.MQTT
	}
	return nil
}

func (m *ApplicationPubSub) GetBaseTopic() string {
	if m != nil {
		return m.BaseTopic
	}
	return ""
}

func (m *ApplicationPubSub) GetDownlinkPush() *ApplicationPubSub_Message {
	if m != nil {
		return m.DownlinkPush
	}
	return nil
}

func (m *ApplicationPubSub) GetDownlinkReplace() *ApplicationPubSub_Message {
	if m != nil {
		return m.DownlinkReplace
	}
	return nil
}

func (m *ApplicationPubSub) GetUplinkMessage() *ApplicationPubSub_Message {
	if m != nil {
		return m.UplinkMessage
	}
	return nil
}

func (m *ApplicationPubSub) GetJoinAccept() *ApplicationPubSub_Message {
	if m != nil {
		return m.JoinAccept
	}
	return nil
}

func (m *ApplicationPubSub) GetDownlinkAck() *ApplicationPubSub_Message {
	if m != nil {
		return m.DownlinkAck
	}
	return nil
}

func (m *ApplicationPubSub) GetDownlinkNack() *ApplicationPubSub_Message {
	if m != nil {
		return m.DownlinkNack
	}
	return nil
}

func (m *ApplicationPubSub) GetDownlinkSent() *ApplicationPubSub_Message {
	if m != nil {
		return m.DownlinkSent
	}
	return nil
}

func (m *ApplicationPubSub) GetDownlinkFailed() *ApplicationPubSub_Message {
	if m != nil {
		return m.DownlinkFailed
	}
	return nil
}

func (m *ApplicationPubSub) GetDownlinkQueued() *ApplicationPubSub_Message {
	if m != nil {
		return m.DownlinkQueued
	}
	return nil
}

func (m *ApplicationPubSub) GetLocationSolved() *ApplicationPubSub_Message {
	if m != nil {
		return m.LocationSolved
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ApplicationPubSub) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ApplicationPubSub_NATS)(nil),
		(*ApplicationPubSub_MQTT)(nil),
	}
}

// The NATS provider settings.
type ApplicationPubSub_NATSProvider struct {
	// The server connection URL.
	ServerURL            string   `protobuf:"bytes,1,opt,name=server_url,json=serverUrl,proto3" json:"server_url,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ApplicationPubSub_NATSProvider) Reset()      { *m = ApplicationPubSub_NATSProvider{} }
func (*ApplicationPubSub_NATSProvider) ProtoMessage() {}
func (*ApplicationPubSub_NATSProvider) Descriptor() ([]byte, []int) {
	return fileDescriptor_1dce56ec18597200, []int{1, 0}
}
func (m *ApplicationPubSub_NATSProvider) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ApplicationPubSub_NATSProvider) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ApplicationPubSub_NATSProvider.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ApplicationPubSub_NATSProvider) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ApplicationPubSub_NATSProvider.Merge(m, src)
}
func (m *ApplicationPubSub_NATSProvider) XXX_Size() int {
	return m.Size()
}
func (m *ApplicationPubSub_NATSProvider) XXX_DiscardUnknown() {
	xxx_messageInfo_ApplicationPubSub_NATSProvider.DiscardUnknown(m)
}

var xxx_messageInfo_ApplicationPubSub_NATSProvider proto.InternalMessageInfo

func (m *ApplicationPubSub_NATSProvider) GetServerURL() string {
	if m != nil {
		return m.ServerURL
	}
	return ""
}

// The MQTT provider settings.
type ApplicationPubSub_MQTTProvider struct {
	ServerURL    string                             `protobuf:"bytes,1,opt,name=server_url,json=serverUrl,proto3" json:"server_url,omitempty"`
	ClientID     string                             `protobuf:"bytes,2,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	Username     string                             `protobuf:"bytes,3,opt,name=username,proto3" json:"username,omitempty"`
	Password     string                             `protobuf:"bytes,4,opt,name=password,proto3" json:"password,omitempty"`
	SubscribeQoS ApplicationPubSub_MQTTProvider_QoS `protobuf:"varint,5,opt,name=subscribe_qos,json=subscribeQos,proto3,enum=ttn.lorawan.v3.ApplicationPubSub_MQTTProvider_QoS" json:"subscribe_qos,omitempty"`
	PublishQoS   ApplicationPubSub_MQTTProvider_QoS `protobuf:"varint,6,opt,name=publish_qos,json=publishQos,proto3,enum=ttn.lorawan.v3.ApplicationPubSub_MQTTProvider_QoS" json:"publish_qos,omitempty"`
	UseTLS       bool                               `protobuf:"varint,7,opt,name=use_tls,json=useTls,proto3" json:"use_tls,omitempty"`
	// The server Root CA certificate. PEM formatted.
	TLSCA []byte `protobuf:"bytes,8,opt,name=tls_ca,json=tlsCa,proto3" json:"tls_ca,omitempty"`
	// The client certificate. PEM formatted.
	TLSClientCert []byte `protobuf:"bytes,9,opt,name=tls_client_cert,json=tlsClientCert,proto3" json:"tls_client_cert,omitempty"`
	// The client private key. PEM formatted.
	TLSClientKey         []byte   `protobuf:"bytes,10,opt,name=tls_client_key,json=tlsClientKey,proto3" json:"tls_client_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ApplicationPubSub_MQTTProvider) Reset()      { *m = ApplicationPubSub_MQTTProvider{} }
func (*ApplicationPubSub_MQTTProvider) ProtoMessage() {}
func (*ApplicationPubSub_MQTTProvider) Descriptor() ([]byte, []int) {
	return fileDescriptor_1dce56ec18597200, []int{1, 1}
}
func (m *ApplicationPubSub_MQTTProvider) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ApplicationPubSub_MQTTProvider) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ApplicationPubSub_MQTTProvider.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ApplicationPubSub_MQTTProvider) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ApplicationPubSub_MQTTProvider.Merge(m, src)
}
func (m *ApplicationPubSub_MQTTProvider) XXX_Size() int {
	return m.Size()
}
func (m *ApplicationPubSub_MQTTProvider) XXX_DiscardUnknown() {
	xxx_messageInfo_ApplicationPubSub_MQTTProvider.DiscardUnknown(m)
}

var xxx_messageInfo_ApplicationPubSub_MQTTProvider proto.InternalMessageInfo

func (m *ApplicationPubSub_MQTTProvider) GetServerURL() string {
	if m != nil {
		return m.ServerURL
	}
	return ""
}

func (m *ApplicationPubSub_MQTTProvider) GetClientID() string {
	if m != nil {
		return m.ClientID
	}
	return ""
}

func (m *ApplicationPubSub_MQTTProvider) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

func (m *ApplicationPubSub_MQTTProvider) GetPassword() string {
	if m != nil {
		return m.Password
	}
	return ""
}

func (m *ApplicationPubSub_MQTTProvider) GetSubscribeQoS() ApplicationPubSub_MQTTProvider_QoS {
	if m != nil {
		return m.SubscribeQoS
	}
	return ApplicationPubSub_MQTTProvider_AT_MOST_ONCE
}

func (m *ApplicationPubSub_MQTTProvider) GetPublishQoS() ApplicationPubSub_MQTTProvider_QoS {
	if m != nil {
		return m.PublishQoS
	}
	return ApplicationPubSub_MQTTProvider_AT_MOST_ONCE
}

func (m *ApplicationPubSub_MQTTProvider) GetUseTLS() bool {
	if m != nil {
		return m.UseTLS
	}
	return false
}

func (m *ApplicationPubSub_MQTTProvider) GetTLSCA() []byte {
	if m != nil {
		return m.TLSCA
	}
	return nil
}

func (m *ApplicationPubSub_MQTTProvider) GetTLSClientCert() []byte {
	if m != nil {
		return m.TLSClientCert
	}
	return nil
}

func (m *ApplicationPubSub_MQTTProvider) GetTLSClientKey() []byte {
	if m != nil {
		return m.TLSClientKey
	}
	return nil
}

type ApplicationPubSub_Message struct {
	// The topic on which the Application Server publishes or receives the messages.
	Topic                string   `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ApplicationPubSub_Message) Reset()      { *m = ApplicationPubSub_Message{} }
func (*ApplicationPubSub_Message) ProtoMessage() {}
func (*ApplicationPubSub_Message) Descriptor() ([]byte, []int) {
	return fileDescriptor_1dce56ec18597200, []int{1, 2}
}
func (m *ApplicationPubSub_Message) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ApplicationPubSub_Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ApplicationPubSub_Message.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ApplicationPubSub_Message) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ApplicationPubSub_Message.Merge(m, src)
}
func (m *ApplicationPubSub_Message) XXX_Size() int {
	return m.Size()
}
func (m *ApplicationPubSub_Message) XXX_DiscardUnknown() {
	xxx_messageInfo_ApplicationPubSub_Message.DiscardUnknown(m)
}

var xxx_messageInfo_ApplicationPubSub_Message proto.InternalMessageInfo

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

type ApplicationPubSubs struct {
	Pubsubs              []*ApplicationPubSub `protobuf:"bytes,1,rep,name=pubsubs,proto3" json:"pubsubs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ApplicationPubSubs) Reset()      { *m = ApplicationPubSubs{} }
func (*ApplicationPubSubs) ProtoMessage() {}
func (*ApplicationPubSubs) Descriptor() ([]byte, []int) {
	return fileDescriptor_1dce56ec18597200, []int{2}
}
func (m *ApplicationPubSubs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ApplicationPubSubs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ApplicationPubSubs.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ApplicationPubSubs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ApplicationPubSubs.Merge(m, src)
}
func (m *ApplicationPubSubs) XXX_Size() int {
	return m.Size()
}
func (m *ApplicationPubSubs) XXX_DiscardUnknown() {
	xxx_messageInfo_ApplicationPubSubs.DiscardUnknown(m)
}

var xxx_messageInfo_ApplicationPubSubs proto.InternalMessageInfo

func (m *ApplicationPubSubs) GetPubsubs() []*ApplicationPubSub {
	if m != nil {
		return m.Pubsubs
	}
	return nil
}

type ApplicationPubSubFormats struct {
	// Format and description.
	Formats              map[string]string `protobuf:"bytes,1,rep,name=formats,proto3" json:"formats,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *ApplicationPubSubFormats) Reset()      { *m = ApplicationPubSubFormats{} }
func (*ApplicationPubSubFormats) ProtoMessage() {}
func (*ApplicationPubSubFormats) Descriptor() ([]byte, []int) {
	return fileDescriptor_1dce56ec18597200, []int{3}
}
func (m *ApplicationPubSubFormats) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ApplicationPubSubFormats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ApplicationPubSubFormats.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ApplicationPubSubFormats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ApplicationPubSubFormats.Merge(m, src)
}
func (m *ApplicationPubSubFormats) XXX_Size() int {
	return m.Size()
}
func (m *ApplicationPubSubFormats) XXX_DiscardUnknown() {
	xxx_messageInfo_ApplicationPubSubFormats.DiscardUnknown(m)
}

var xxx_messageInfo_ApplicationPubSubFormats proto.InternalMessageInfo

func (m *ApplicationPubSubFormats) GetFormats() map[string]string {
	if m != nil {
		return m.Formats
	}
	return nil
}

type GetApplicationPubSubRequest struct {
	ApplicationPubSubIdentifiers `protobuf:"bytes,1,opt,name=ids,proto3,embedded=ids" json:"ids"`
	FieldMask                    types.FieldMask `protobuf:"bytes,2,opt,name=field_mask,json=fieldMask,proto3" json:"field_mask"`
	XXX_NoUnkeyedLiteral         struct{}        `json:"-"`
	XXX_sizecache                int32           `json:"-"`
}

func (m *GetApplicationPubSubRequest) Reset()      { *m = GetApplicationPubSubRequest{} }
func (*GetApplicationPubSubRequest) ProtoMessage() {}
func (*GetApplicationPubSubRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1dce56ec18597200, []int{4}
}
func (m *GetApplicationPubSubRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetApplicationPubSubRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetApplicationPubSubRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetApplicationPubSubRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetApplicationPubSubRequest.Merge(m, src)
}
func (m *GetApplicationPubSubRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetApplicationPubSubRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetApplicationPubSubRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetApplicationPubSubRequest proto.InternalMessageInfo

func (m *GetApplicationPubSubRequest) GetFieldMask() types.FieldMask {
	if m != nil {
		return m.FieldMask
	}
	return types.FieldMask{}
}

type ListApplicationPubSubsRequest struct {
	ApplicationIdentifiers `protobuf:"bytes,1,opt,name=application_ids,json=applicationIds,proto3,embedded=application_ids" json:"application_ids"`
	FieldMask              types.FieldMask `protobuf:"bytes,2,opt,name=field_mask,json=fieldMask,proto3" json:"field_mask"`
	XXX_NoUnkeyedLiteral   struct{}        `json:"-"`
	XXX_sizecache          int32           `json:"-"`
}

func (m *ListApplicationPubSubsRequest) Reset()      { *m = ListApplicationPubSubsRequest{} }
func (*ListApplicationPubSubsRequest) ProtoMessage() {}
func (*ListApplicationPubSubsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1dce56ec18597200, []int{5}
}
func (m *ListApplicationPubSubsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ListApplicationPubSubsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ListApplicationPubSubsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ListApplicationPubSubsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListApplicationPubSubsRequest.Merge(m, src)
}
func (m *ListApplicationPubSubsRequest) XXX_Size() int {
	return m.Size()
}
func (m *ListApplicationPubSubsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListApplicationPubSubsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListApplicationPubSubsRequest proto.InternalMessageInfo

func (m *ListApplicationPubSubsRequest) GetFieldMask() types.FieldMask {
	if m != nil {
		return m.FieldMask
	}
	return types.FieldMask{}
}

type SetApplicationPubSubRequest struct {
	ApplicationPubSub    `protobuf:"bytes,1,opt,name=pubsub,proto3,embedded=pubsub" json:"pubsub"`
	FieldMask            types.FieldMask `protobuf:"bytes,2,opt,name=field_mask,json=fieldMask,proto3" json:"field_mask"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *SetApplicationPubSubRequest) Reset()      { *m = SetApplicationPubSubRequest{} }
func (*SetApplicationPubSubRequest) ProtoMessage() {}
func (*SetApplicationPubSubRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1dce56ec18597200, []int{6}
}
func (m *SetApplicationPubSubRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SetApplicationPubSubRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SetApplicationPubSubRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SetApplicationPubSubRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetApplicationPubSubRequest.Merge(m, src)
}
func (m *SetApplicationPubSubRequest) XXX_Size() int {
	return m.Size()
}
func (m *SetApplicationPubSubRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SetApplicationPubSubRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SetApplicationPubSubRequest proto.InternalMessageInfo

func (m *SetApplicationPubSubRequest) GetFieldMask() types.FieldMask {
	if m != nil {
		return m.FieldMask
	}
	return types.FieldMask{}
}

func init() {
	proto.RegisterEnum("ttn.lorawan.v3.ApplicationPubSub_MQTTProvider_QoS", ApplicationPubSub_MQTTProvider_QoS_name, ApplicationPubSub_MQTTProvider_QoS_value)
	golang_proto.RegisterEnum("ttn.lorawan.v3.ApplicationPubSub_MQTTProvider_QoS", ApplicationPubSub_MQTTProvider_QoS_name, ApplicationPubSub_MQTTProvider_QoS_value)
	proto.RegisterType((*ApplicationPubSubIdentifiers)(nil), "ttn.lorawan.v3.ApplicationPubSubIdentifiers")
	golang_proto.RegisterType((*ApplicationPubSubIdentifiers)(nil), "ttn.lorawan.v3.ApplicationPubSubIdentifiers")
	proto.RegisterType((*ApplicationPubSub)(nil), "ttn.lorawan.v3.ApplicationPubSub")
	golang_proto.RegisterType((*ApplicationPubSub)(nil), "ttn.lorawan.v3.ApplicationPubSub")
	proto.RegisterType((*ApplicationPubSub_NATSProvider)(nil), "ttn.lorawan.v3.ApplicationPubSub.NATSProvider")
	golang_proto.RegisterType((*ApplicationPubSub_NATSProvider)(nil), "ttn.lorawan.v3.ApplicationPubSub.NATSProvider")
	proto.RegisterType((*ApplicationPubSub_MQTTProvider)(nil), "ttn.lorawan.v3.ApplicationPubSub.MQTTProvider")
	golang_proto.RegisterType((*ApplicationPubSub_MQTTProvider)(nil), "ttn.lorawan.v3.ApplicationPubSub.MQTTProvider")
	proto.RegisterType((*ApplicationPubSub_Message)(nil), "ttn.lorawan.v3.ApplicationPubSub.Message")
	golang_proto.RegisterType((*ApplicationPubSub_Message)(nil), "ttn.lorawan.v3.ApplicationPubSub.Message")
	proto.RegisterType((*ApplicationPubSubs)(nil), "ttn.lorawan.v3.ApplicationPubSubs")
	golang_proto.RegisterType((*ApplicationPubSubs)(nil), "ttn.lorawan.v3.ApplicationPubSubs")
	proto.RegisterType((*ApplicationPubSubFormats)(nil), "ttn.lorawan.v3.ApplicationPubSubFormats")
	golang_proto.RegisterType((*ApplicationPubSubFormats)(nil), "ttn.lorawan.v3.ApplicationPubSubFormats")
	proto.RegisterMapType((map[string]string)(nil), "ttn.lorawan.v3.ApplicationPubSubFormats.FormatsEntry")
	golang_proto.RegisterMapType((map[string]string)(nil), "ttn.lorawan.v3.ApplicationPubSubFormats.FormatsEntry")
	proto.RegisterType((*GetApplicationPubSubRequest)(nil), "ttn.lorawan.v3.GetApplicationPubSubRequest")
	golang_proto.RegisterType((*GetApplicationPubSubRequest)(nil), "ttn.lorawan.v3.GetApplicationPubSubRequest")
	proto.RegisterType((*ListApplicationPubSubsRequest)(nil), "ttn.lorawan.v3.ListApplicationPubSubsRequest")
	golang_proto.RegisterType((*ListApplicationPubSubsRequest)(nil), "ttn.lorawan.v3.ListApplicationPubSubsRequest")
	proto.RegisterType((*SetApplicationPubSubRequest)(nil), "ttn.lorawan.v3.SetApplicationPubSubRequest")
	golang_proto.RegisterType((*SetApplicationPubSubRequest)(nil), "ttn.lorawan.v3.SetApplicationPubSubRequest")
}

func init() {
	proto.RegisterFile("lorawan-stack/api/applicationserver_pubsub.proto", fileDescriptor_1dce56ec18597200)
}
func init() {
	golang_proto.RegisterFile("lorawan-stack/api/applicationserver_pubsub.proto", fileDescriptor_1dce56ec18597200)
}

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

func (x ApplicationPubSub_MQTTProvider_QoS) String() string {
	s, ok := ApplicationPubSub_MQTTProvider_QoS_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *ApplicationPubSubIdentifiers) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ApplicationPubSubIdentifiers)
	if !ok {
		that2, ok := that.(ApplicationPubSubIdentifiers)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ApplicationIdentifiers.Equal(&that1.ApplicationIdentifiers) {
		return false
	}
	if this.PubSubID != that1.PubSubID {
		return false
	}
	return true
}
func (this *ApplicationPubSub) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ApplicationPubSub)
	if !ok {
		that2, ok := that.(ApplicationPubSub)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ApplicationPubSubIdentifiers.Equal(&that1.ApplicationPubSubIdentifiers) {
		return false
	}
	if !this.CreatedAt.Equal(that1.CreatedAt) {
		return false
	}
	if !this.UpdatedAt.Equal(that1.UpdatedAt) {
		return false
	}
	if this.Format != that1.Format {
		return false
	}
	if that1.Provider == nil {
		if this.Provider != nil {
			return false
		}
	} else if this.Provider == nil {
		return false
	} else if !this.Provider.Equal(that1.Provider) {
		return false
	}
	if this.BaseTopic != that1.BaseTopic {
		return false
	}
	if !this.DownlinkPush.Equal(that1.DownlinkPush) {
		return false
	}
	if !this.DownlinkReplace.Equal(that1.DownlinkReplace) {
		return false
	}
	if !this.UplinkMessage.Equal(that1.UplinkMessage) {
		return false
	}
	if !this.JoinAccept.Equal(that1.JoinAccept) {
		return false
	}
	if !this.DownlinkAck.Equal(that1.DownlinkAck) {
		return false
	}
	if !this.DownlinkNack.Equal(that1.DownlinkNack) {
		return false
	}
	if !this.DownlinkSent.Equal(that1.DownlinkSent) {
		return false
	}
	if !this.DownlinkFailed.Equal(that1.DownlinkFailed) {
		return false
	}
	if !this.DownlinkQueued.Equal(that1.DownlinkQueued) {
		return false
	}
	if !this.LocationSolved.Equal(that1.LocationSolved) {
		return false
	}
	return true
}
func (this *ApplicationPubSub_NATS) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ApplicationPubSub_NATS)
	if !ok {
		that2, ok := that.(ApplicationPubSub_NATS)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.NATS.Equal(that1.NATS) {
		return false
	}
	return true
}
func (this *ApplicationPubSub_MQTT) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ApplicationPubSub_MQTT)
	if !ok {
		that2, ok := that.(ApplicationPubSub_MQTT)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.MQTT.Equal(that1.MQTT) {
		return false
	}
	return true
}
func (this *ApplicationPubSub_NATSProvider) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ApplicationPubSub_NATSProvider)
	if !ok {
		that2, ok := that.(ApplicationPubSub_NATSProvider)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ServerURL != that1.ServerURL {
		return false
	}
	return true
}
func (this *ApplicationPubSub_MQTTProvider) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ApplicationPubSub_MQTTProvider)
	if !ok {
		that2, ok := that.(ApplicationPubSub_MQTTProvider)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ServerURL != that1.ServerURL {
		return false
	}
	if this.ClientID != that1.ClientID {
		return false
	}
	if this.Username != that1.Username {
		return false
	}
	if this.Password != that1.Password {
		return false
	}
	if this.SubscribeQoS != that1.SubscribeQoS {
		return false
	}
	if this.PublishQoS != that1.PublishQoS {
		return false
	}
	if this.UseTLS != that1.UseTLS {
		return false
	}
	if !bytes.Equal(this.TLSCA, that1.TLSCA) {
		return false
	}
	if !bytes.Equal(this.TLSClientCert, that1.TLSClientCert) {
		return false
	}
	if !bytes.Equal(this.TLSClientKey, that1.TLSClientKey) {
		return false
	}
	return true
}
func (this *ApplicationPubSub_Message) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ApplicationPubSub_Message)
	if !ok {
		that2, ok := that.(ApplicationPubSub_Message)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Topic != that1.Topic {
		return false
	}
	return true
}
func (this *ApplicationPubSubs) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ApplicationPubSubs)
	if !ok {
		that2, ok := that.(ApplicationPubSubs)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Pubsubs) != len(that1.Pubsubs) {
		return false
	}
	for i := range this.Pubsubs {
		if !this.Pubsubs[i].Equal(that1.Pubsubs[i]) {
			return false
		}
	}
	return true
}
func (this *ApplicationPubSubFormats) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ApplicationPubSubFormats)
	if !ok {
		that2, ok := that.(ApplicationPubSubFormats)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Formats) != len(that1.Formats) {
		return false
	}
	for i := range this.Formats {
		if this.Formats[i] != that1.Formats[i] {
			return false
		}
	}
	return true
}
func (this *GetApplicationPubSubRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetApplicationPubSubRequest)
	if !ok {
		that2, ok := that.(GetApplicationPubSubRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ApplicationPubSubIdentifiers.Equal(&that1.ApplicationPubSubIdentifiers) {
		return false
	}
	if !this.FieldMask.Equal(&that1.FieldMask) {
		return false
	}
	return true
}
func (this *ListApplicationPubSubsRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ListApplicationPubSubsRequest)
	if !ok {
		that2, ok := that.(ListApplicationPubSubsRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ApplicationIdentifiers.Equal(&that1.ApplicationIdentifiers) {
		return false
	}
	if !this.FieldMask.Equal(&that1.FieldMask) {
		return false
	}
	return true
}
func (this *SetApplicationPubSubRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SetApplicationPubSubRequest)
	if !ok {
		that2, ok := that.(SetApplicationPubSubRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ApplicationPubSub.Equal(&that1.ApplicationPubSub) {
		return false
	}
	if !this.FieldMask.Equal(&that1.FieldMask) {
		return false
	}
	return true
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// ApplicationPubSubRegistryClient is the client API for ApplicationPubSubRegistry service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ApplicationPubSubRegistryClient interface {
	GetFormats(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*ApplicationPubSubFormats, error)
	Get(ctx context.Context, in *GetApplicationPubSubRequest, opts ...grpc.CallOption) (*ApplicationPubSub, error)
	List(ctx context.Context, in *ListApplicationPubSubsRequest, opts ...grpc.CallOption) (*ApplicationPubSubs, error)
	Set(ctx context.Context, in *SetApplicationPubSubRequest, opts ...grpc.CallOption) (*ApplicationPubSub, error)
	Delete(ctx context.Context, in *ApplicationPubSubIdentifiers, opts ...grpc.CallOption) (*types.Empty, error)
}

type applicationPubSubRegistryClient struct {
	cc *grpc.ClientConn
}

func NewApplicationPubSubRegistryClient(cc *grpc.ClientConn) ApplicationPubSubRegistryClient {
	return &applicationPubSubRegistryClient{cc}
}

func (c *applicationPubSubRegistryClient) GetFormats(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*ApplicationPubSubFormats, error) {
	out := new(ApplicationPubSubFormats)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.ApplicationPubSubRegistry/GetFormats", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *applicationPubSubRegistryClient) Get(ctx context.Context, in *GetApplicationPubSubRequest, opts ...grpc.CallOption) (*ApplicationPubSub, error) {
	out := new(ApplicationPubSub)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.ApplicationPubSubRegistry/Get", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *applicationPubSubRegistryClient) List(ctx context.Context, in *ListApplicationPubSubsRequest, opts ...grpc.CallOption) (*ApplicationPubSubs, error) {
	out := new(ApplicationPubSubs)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.ApplicationPubSubRegistry/List", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *applicationPubSubRegistryClient) Set(ctx context.Context, in *SetApplicationPubSubRequest, opts ...grpc.CallOption) (*ApplicationPubSub, error) {
	out := new(ApplicationPubSub)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.ApplicationPubSubRegistry/Set", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *applicationPubSubRegistryClient) Delete(ctx context.Context, in *ApplicationPubSubIdentifiers, opts ...grpc.CallOption) (*types.Empty, error) {
	out := new(types.Empty)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.ApplicationPubSubRegistry/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ApplicationPubSubRegistryServer is the server API for ApplicationPubSubRegistry service.
type ApplicationPubSubRegistryServer interface {
	GetFormats(context.Context, *types.Empty) (*ApplicationPubSubFormats, error)
	Get(context.Context, *GetApplicationPubSubRequest) (*ApplicationPubSub, error)
	List(context.Context, *ListApplicationPubSubsRequest) (*ApplicationPubSubs, error)
	Set(context.Context, *SetApplicationPubSubRequest) (*ApplicationPubSub, error)
	Delete(context.Context, *ApplicationPubSubIdentifiers) (*types.Empty, error)
}

// UnimplementedApplicationPubSubRegistryServer can be embedded to have forward compatible implementations.
type UnimplementedApplicationPubSubRegistryServer struct {
}

func (*UnimplementedApplicationPubSubRegistryServer) GetFormats(ctx context.Context, req *types.Empty) (*ApplicationPubSubFormats, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetFormats not implemented")
}
func (*UnimplementedApplicationPubSubRegistryServer) Get(ctx context.Context, req *GetApplicationPubSubRequest) (*ApplicationPubSub, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
}
func (*UnimplementedApplicationPubSubRegistryServer) List(ctx context.Context, req *ListApplicationPubSubsRequest) (*ApplicationPubSubs, error) {
	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
}
func (*UnimplementedApplicationPubSubRegistryServer) Set(ctx context.Context, req *SetApplicationPubSubRequest) (*ApplicationPubSub, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (*UnimplementedApplicationPubSubRegistryServer) Delete(ctx context.Context, req *ApplicationPubSubIdentifiers) (*types.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}

func RegisterApplicationPubSubRegistryServer(s *grpc.Server, srv ApplicationPubSubRegistryServer) {
	s.RegisterService(&_ApplicationPubSubRegistry_serviceDesc, srv)
}

func _ApplicationPubSubRegistry_GetFormats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(types.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationPubSubRegistryServer).GetFormats(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.ApplicationPubSubRegistry/GetFormats",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationPubSubRegistryServer).GetFormats(ctx, req.(*types.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApplicationPubSubRegistry_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetApplicationPubSubRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationPubSubRegistryServer).Get(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.ApplicationPubSubRegistry/Get",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationPubSubRegistryServer).Get(ctx, req.(*GetApplicationPubSubRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApplicationPubSubRegistry_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListApplicationPubSubsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationPubSubRegistryServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.ApplicationPubSubRegistry/List",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationPubSubRegistryServer).List(ctx, req.(*ListApplicationPubSubsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApplicationPubSubRegistry_Set_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetApplicationPubSubRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationPubSubRegistryServer).Set(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.ApplicationPubSubRegistry/Set",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationPubSubRegistryServer).Set(ctx, req.(*SetApplicationPubSubRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApplicationPubSubRegistry_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplicationPubSubIdentifiers)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationPubSubRegistryServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.ApplicationPubSubRegistry/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationPubSubRegistryServer).Delete(ctx, req.(*ApplicationPubSubIdentifiers))
	}
	return interceptor(ctx, in, info, handler)
}

var _ApplicationPubSubRegistry_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ttn.lorawan.v3.ApplicationPubSubRegistry",
	HandlerType: (*ApplicationPubSubRegistryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetFormats",
			Handler:    _ApplicationPubSubRegistry_GetFormats_Handler,
		},
		{
			MethodName: "Get",
			Handler:    _ApplicationPubSubRegistry_Get_Handler,
		},
		{
			MethodName: "List",
			Handler:    _ApplicationPubSubRegistry_List_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _ApplicationPubSubRegistry_Set_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _ApplicationPubSubRegistry_Delete_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "lorawan-stack/api/applicationserver_pubsub.proto",
}

func (m *ApplicationPubSubIdentifiers) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ApplicationPubSubIdentifiers) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ApplicationPubSubIdentifiers) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PubSubID) > 0 {
		i -= len(m.PubSubID)
		copy(dAtA[i:], m.PubSubID)
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(len(m.PubSubID)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.ApplicationIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *ApplicationPubSub) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ApplicationPubSub) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ApplicationPubSub) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Provider != nil {
		{
			size := m.Provider.Size()
			i -= size
			if _, err := m.Provider.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.LocationSolved != nil {
		{
			size, err := m.LocationSolved.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if m.DownlinkQueued != nil {
		{
			size, err := m.DownlinkQueued.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	if m.DownlinkFailed != nil {
		{
			size, err := m.DownlinkFailed.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x72
	}
	if m.DownlinkSent != nil {
		{
			size, err := m.DownlinkSent.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6a
	}
	if m.DownlinkNack != nil {
		{
			size, err := m.DownlinkNack.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	if m.DownlinkAck != nil {
		{
			size, err := m.DownlinkAck.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.JoinAccept != nil {
		{
			size, err := m.JoinAccept.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.UplinkMessage != nil {
		{
			size, err := m.UplinkMessage.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.DownlinkReplace != nil {
		{
			size, err := m.DownlinkReplace.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.DownlinkPush != nil {
		{
			size, err := m.DownlinkPush.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if len(m.BaseTopic) > 0 {
		i -= len(m.BaseTopic)
		copy(dAtA[i:], m.BaseTopic)
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(len(m.BaseTopic)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Format) > 0 {
		i -= len(m.Format)
		copy(dAtA[i:], m.Format)
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(len(m.Format)))
		i--
		dAtA[i] = 0x22
	}
	n12, err12 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt):])
	if err12 != nil {
		return 0, err12
	}
	i -= n12
	i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(n12))
	i--
	dAtA[i] = 0x1a
	n13, err13 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt):])
	if err13 != nil {
		return 0, err13
	}
	i -= n13
	i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(n13))
	i--
	dAtA[i] = 0x12
	{
		size, err := m.ApplicationPubSubIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *ApplicationPubSub_NATS) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ApplicationPubSub_NATS) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NATS != nil {
		{
			size, err := m.NATS.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	return len(dAtA) - i, nil
}
func (m *ApplicationPubSub_MQTT) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ApplicationPubSub_MQTT) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MQTT != nil {
		{
			size, err := m.MQTT.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xca
	}
	return len(dAtA) - i, nil
}
func (m *ApplicationPubSub_NATSProvider) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ApplicationPubSub_NATSProvider) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ApplicationPubSub_NATSProvider) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ServerURL) > 0 {
		i -= len(m.ServerURL)
		copy(dAtA[i:], m.ServerURL)
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(len(m.ServerURL)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ApplicationPubSub_MQTTProvider) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ApplicationPubSub_MQTTProvider) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ApplicationPubSub_MQTTProvider) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TLSClientKey) > 0 {
		i -= len(m.TLSClientKey)
		copy(dAtA[i:], m.TLSClientKey)
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(len(m.TLSClientKey)))
		i--
		dAtA[i] = 0x52
	}
	if len(m.TLSClientCert) > 0 {
		i -= len(m.TLSClientCert)
		copy(dAtA[i:], m.TLSClientCert)
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(len(m.TLSClientCert)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.TLSCA) > 0 {
		i -= len(m.TLSCA)
		copy(dAtA[i:], m.TLSCA)
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(len(m.TLSCA)))
		i--
		dAtA[i] = 0x42
	}
	if m.UseTLS {
		i--
		if m.UseTLS {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.PublishQoS != 0 {
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(m.PublishQoS))
		i--
		dAtA[i] = 0x30
	}
	if m.SubscribeQoS != 0 {
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(m.SubscribeQoS))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Password) > 0 {
		i -= len(m.Password)
		copy(dAtA[i:], m.Password)
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(len(m.Password)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Username) > 0 {
		i -= len(m.Username)
		copy(dAtA[i:], m.Username)
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(len(m.Username)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ClientID) > 0 {
		i -= len(m.ClientID)
		copy(dAtA[i:], m.ClientID)
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(len(m.ClientID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ServerURL) > 0 {
		i -= len(m.ServerURL)
		copy(dAtA[i:], m.ServerURL)
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(len(m.ServerURL)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ApplicationPubSub_Message) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ApplicationPubSub_Message) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ApplicationPubSub_Message) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Topic) > 0 {
		i -= len(m.Topic)
		copy(dAtA[i:], m.Topic)
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(len(m.Topic)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ApplicationPubSubs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ApplicationPubSubs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ApplicationPubSubs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Pubsubs) > 0 {
		for iNdEx := len(m.Pubsubs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Pubsubs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ApplicationPubSubFormats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ApplicationPubSubFormats) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ApplicationPubSubFormats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Formats) > 0 {
		for k := range m.Formats {
			v := m.Formats[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *GetApplicationPubSubRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetApplicationPubSubRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetApplicationPubSubRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.FieldMask.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.ApplicationPubSubIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *ListApplicationPubSubsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ListApplicationPubSubsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ListApplicationPubSubsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.FieldMask.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.ApplicationIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *SetApplicationPubSubRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SetApplicationPubSubRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SetApplicationPubSubRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.FieldMask.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.ApplicationPubSub.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintApplicationserverPubsub(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func encodeVarintApplicationserverPubsub(dAtA []byte, offset int, v uint64) int {
	offset -= sovApplicationserverPubsub(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedApplicationPubSubIdentifiers(r randyApplicationserverPubsub, easy bool) *ApplicationPubSubIdentifiers {
	this := &ApplicationPubSubIdentifiers{}
	v1 := NewPopulatedApplicationIdentifiers(r, easy)
	this.ApplicationIdentifiers = *v1
	this.PubSubID = randStringApplicationserverPubsub(r)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedApplicationPubSub(r randyApplicationserverPubsub, easy bool) *ApplicationPubSub {
	this := &ApplicationPubSub{}
	v2 := NewPopulatedApplicationPubSubIdentifiers(r, easy)
	this.ApplicationPubSubIdentifiers = *v2
	v3 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	this.CreatedAt = *v3
	v4 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	this.UpdatedAt = *v4
	this.Format = randStringApplicationserverPubsub(r)
	this.BaseTopic = randStringApplicationserverPubsub(r)
	if r.Intn(5) != 0 {
		this.DownlinkPush = NewPopulatedApplicationPubSub_Message(r, easy)
	}
	if r.Intn(5) != 0 {
		this.DownlinkReplace = NewPopulatedApplicationPubSub_Message(r, easy)
	}
	if r.Intn(5) != 0 {
		this.UplinkMessage = NewPopulatedApplicationPubSub_Message(r, easy)
	}
	if r.Intn(5) != 0 {
		this.JoinAccept = NewPopulatedApplicationPubSub_Message(r, easy)
	}
	if r.Intn(5) != 0 {
		this.DownlinkAck = NewPopulatedApplicationPubSub_Message(r, easy)
	}
	if r.Intn(5) != 0 {
		this.DownlinkNack = NewPopulatedApplicationPubSub_Message(r, easy)
	}
	if r.Intn(5) != 0 {
		this.DownlinkSent = NewPopulatedApplicationPubSub_Message(r, easy)
	}
	if r.Intn(5) != 0 {
		this.DownlinkFailed = NewPopulatedApplicationPubSub_Message(r, easy)
	}
	if r.Intn(5) != 0 {
		this.DownlinkQueued = NewPopulatedApplicationPubSub_Message(r, easy)
	}
	if r.Intn(5) != 0 {
		this.LocationSolved = NewPopulatedApplicationPubSub_Message(r, easy)
	}
	oneofNumber_Provider := []int32{17, 25}[r.Intn(2)]
	switch oneofNumber_Provider {
	case 17:
		this.Provider = NewPopulatedApplicationPubSub_NATS(r, easy)
	case 25:
		this.Provider = NewPopulatedApplicationPubSub_MQTT(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedApplicationPubSub_NATS(r randyApplicationserverPubsub, easy bool) *ApplicationPubSub_NATS {
	this := &ApplicationPubSub_NATS{}
	this.NATS = NewPopulatedApplicationPubSub_NATSProvider(r, easy)
	return this
}
func NewPopulatedApplicationPubSub_MQTT(r randyApplicationserverPubsub, easy bool) *ApplicationPubSub_MQTT {
	this := &ApplicationPubSub_MQTT{}
	this.MQTT = NewPopulatedApplicationPubSub_MQTTProvider(r, easy)
	return this
}
func NewPopulatedApplicationPubSub_NATSProvider(r randyApplicationserverPubsub, easy bool) *ApplicationPubSub_NATSProvider {
	this := &ApplicationPubSub_NATSProvider{}
	this.ServerURL = randStringApplicationserverPubsub(r)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedApplicationPubSub_MQTTProvider(r randyApplicationserverPubsub, easy bool) *ApplicationPubSub_MQTTProvider {
	this := &ApplicationPubSub_MQTTProvider{}
	this.ServerURL = randStringApplicationserverPubsub(r)
	this.ClientID = randStringApplicationserverPubsub(r)
	this.Username = randStringApplicationserverPubsub(r)
	this.Password = randStringApplicationserverPubsub(r)
	this.SubscribeQoS = ApplicationPubSub_MQTTProvider_QoS([]int32{0, 1, 2}[r.Intn(3)])
	this.PublishQoS = ApplicationPubSub_MQTTProvider_QoS([]int32{0, 1, 2}[r.Intn(3)])
	this.UseTLS = bool(r.Intn(2) == 0)
	v5 := r.Intn(100)
	this.TLSCA = make([]byte, v5)
	for i := 0; i < v5; i++ {
		this.TLSCA[i] = byte(r.Intn(256))
	}
	v6 := r.Intn(100)
	this.TLSClientCert = make([]byte, v6)
	for i := 0; i < v6; i++ {
		this.TLSClientCert[i] = byte(r.Intn(256))
	}
	v7 := r.Intn(100)
	this.TLSClientKey = make([]byte, v7)
	for i := 0; i < v7; i++ {
		this.TLSClientKey[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedApplicationPubSub_Message(r randyApplicationserverPubsub, easy bool) *ApplicationPubSub_Message {
	this := &ApplicationPubSub_Message{}
	this.Topic = randStringApplicationserverPubsub(r)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedApplicationPubSubs(r randyApplicationserverPubsub, easy bool) *ApplicationPubSubs {
	this := &ApplicationPubSubs{}
	if r.Intn(5) != 0 {
		v8 := r.Intn(5)
		this.Pubsubs = make([]*ApplicationPubSub, v8)
		for i := 0; i < v8; i++ {
			this.Pubsubs[i] = NewPopulatedApplicationPubSub(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedApplicationPubSubFormats(r randyApplicationserverPubsub, easy bool) *ApplicationPubSubFormats {
	this := &ApplicationPubSubFormats{}
	if r.Intn(5) != 0 {
		v9 := r.Intn(10)
		this.Formats = make(map[string]string)
		for i := 0; i < v9; i++ {
			this.Formats[randStringApplicationserverPubsub(r)] = randStringApplicationserverPubsub(r)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetApplicationPubSubRequest(r randyApplicationserverPubsub, easy bool) *GetApplicationPubSubRequest {
	this := &GetApplicationPubSubRequest{}
	v10 := NewPopulatedApplicationPubSubIdentifiers(r, easy)
	this.ApplicationPubSubIdentifiers = *v10
	v11 := types.NewPopulatedFieldMask(r, easy)
	this.FieldMask = *v11
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedListApplicationPubSubsRequest(r randyApplicationserverPubsub, easy bool) *ListApplicationPubSubsRequest {
	this := &ListApplicationPubSubsRequest{}
	v12 := NewPopulatedApplicationIdentifiers(r, easy)
	this.ApplicationIdentifiers = *v12
	v13 := types.NewPopulatedFieldMask(r, easy)
	this.FieldMask = *v13
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedSetApplicationPubSubRequest(r randyApplicationserverPubsub, easy bool) *SetApplicationPubSubRequest {
	this := &SetApplicationPubSubRequest{}
	v14 := NewPopulatedApplicationPubSub(r, easy)
	this.ApplicationPubSub = *v14
	v15 := types.NewPopulatedFieldMask(r, easy)
	this.FieldMask = *v15
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

type randyApplicationserverPubsub interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneApplicationserverPubsub(r randyApplicationserverPubsub) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringApplicationserverPubsub(r randyApplicationserverPubsub) string {
	v16 := r.Intn(100)
	tmps := make([]rune, v16)
	for i := 0; i < v16; i++ {
		tmps[i] = randUTF8RuneApplicationserverPubsub(r)
	}
	return string(tmps)
}
func randUnrecognizedApplicationserverPubsub(r randyApplicationserverPubsub, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldApplicationserverPubsub(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldApplicationserverPubsub(dAtA []byte, r randyApplicationserverPubsub, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateApplicationserverPubsub(dAtA, uint64(key))
		v17 := r.Int63()
		if r.Intn(2) == 0 {
			v17 *= -1
		}
		dAtA = encodeVarintPopulateApplicationserverPubsub(dAtA, uint64(v17))
	case 1:
		dAtA = encodeVarintPopulateApplicationserverPubsub(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateApplicationserverPubsub(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateApplicationserverPubsub(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateApplicationserverPubsub(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateApplicationserverPubsub(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(v&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *ApplicationPubSubIdentifiers) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ApplicationIdentifiers.Size()
	n += 1 + l + sovApplicationserverPubsub(uint64(l))
	l = len(m.PubSubID)
	if l > 0 {
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	return n
}

func (m *ApplicationPubSub) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ApplicationPubSubIdentifiers.Size()
	n += 1 + l + sovApplicationserverPubsub(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt)
	n += 1 + l + sovApplicationserverPubsub(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt)
	n += 1 + l + sovApplicationserverPubsub(uint64(l))
	l = len(m.Format)
	if l > 0 {
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	l = len(m.BaseTopic)
	if l > 0 {
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	if m.DownlinkPush != nil {
		l = m.DownlinkPush.Size()
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	if m.DownlinkReplace != nil {
		l = m.DownlinkReplace.Size()
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	if m.UplinkMessage != nil {
		l = m.UplinkMessage.Size()
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	if m.JoinAccept != nil {
		l = m.JoinAccept.Size()
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	if m.DownlinkAck != nil {
		l = m.DownlinkAck.Size()
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	if m.DownlinkNack != nil {
		l = m.DownlinkNack.Size()
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	if m.DownlinkSent != nil {
		l = m.DownlinkSent.Size()
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	if m.DownlinkFailed != nil {
		l = m.DownlinkFailed.Size()
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	if m.DownlinkQueued != nil {
		l = m.DownlinkQueued.Size()
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	if m.LocationSolved != nil {
		l = m.LocationSolved.Size()
		n += 2 + l + sovApplicationserverPubsub(uint64(l))
	}
	if m.Provider != nil {
		n += m.Provider.Size()
	}
	return n
}

func (m *ApplicationPubSub_NATS) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NATS != nil {
		l = m.NATS.Size()
		n += 2 + l + sovApplicationserverPubsub(uint64(l))
	}
	return n
}
func (m *ApplicationPubSub_MQTT) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MQTT != nil {
		l = m.MQTT.Size()
		n += 2 + l + sovApplicationserverPubsub(uint64(l))
	}
	return n
}
func (m *ApplicationPubSub_NATSProvider) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ServerURL)
	if l > 0 {
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	return n
}

func (m *ApplicationPubSub_MQTTProvider) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ServerURL)
	if l > 0 {
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	l = len(m.ClientID)
	if l > 0 {
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	l = len(m.Username)
	if l > 0 {
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	l = len(m.Password)
	if l > 0 {
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	if m.SubscribeQoS != 0 {
		n += 1 + sovApplicationserverPubsub(uint64(m.SubscribeQoS))
	}
	if m.PublishQoS != 0 {
		n += 1 + sovApplicationserverPubsub(uint64(m.PublishQoS))
	}
	if m.UseTLS {
		n += 2
	}
	l = len(m.TLSCA)
	if l > 0 {
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	l = len(m.TLSClientCert)
	if l > 0 {
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	l = len(m.TLSClientKey)
	if l > 0 {
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	return n
}

func (m *ApplicationPubSub_Message) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Topic)
	if l > 0 {
		n += 1 + l + sovApplicationserverPubsub(uint64(l))
	}
	return n
}

func (m *ApplicationPubSubs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Pubsubs) > 0 {
		for _, e := range m.Pubsubs {
			l = e.Size()
			n += 1 + l + sovApplicationserverPubsub(uint64(l))
		}
	}
	return n
}

func (m *ApplicationPubSubFormats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Formats) > 0 {
		for k, v := range m.Formats {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovApplicationserverPubsub(uint64(len(k))) + 1 + len(v) + sovApplicationserverPubsub(uint64(len(v)))
			n += mapEntrySize + 1 + sovApplicationserverPubsub(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *GetApplicationPubSubRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ApplicationPubSubIdentifiers.Size()
	n += 1 + l + sovApplicationserverPubsub(uint64(l))
	l = m.FieldMask.Size()
	n += 1 + l + sovApplicationserverPubsub(uint64(l))
	return n
}

func (m *ListApplicationPubSubsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ApplicationIdentifiers.Size()
	n += 1 + l + sovApplicationserverPubsub(uint64(l))
	l = m.FieldMask.Size()
	n += 1 + l + sovApplicationserverPubsub(uint64(l))
	return n
}

func (m *SetApplicationPubSubRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ApplicationPubSub.Size()
	n += 1 + l + sovApplicationserverPubsub(uint64(l))
	l = m.FieldMask.Size()
	n += 1 + l + sovApplicationserverPubsub(uint64(l))
	return n
}

func sovApplicationserverPubsub(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozApplicationserverPubsub(x uint64) (n int) {
	return sovApplicationserverPubsub((x << 1) ^ uint64((int64(x) >> 63)))
}
func (this *ApplicationPubSubIdentifiers) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ApplicationPubSubIdentifiers{`,
		`ApplicationIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ApplicationIdentifiers), "ApplicationIdentifiers", "ApplicationIdentifiers", 1), `&`, ``, 1) + `,`,
		`PubSubID:` + fmt.Sprintf("%v", this.PubSubID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ApplicationPubSub) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ApplicationPubSub{`,
		`ApplicationPubSubIdentifiers:` + strings.Replace(strings.Replace(this.ApplicationPubSubIdentifiers.String(), "ApplicationPubSubIdentifiers", "ApplicationPubSubIdentifiers", 1), `&`, ``, 1) + `,`,
		`CreatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.CreatedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
		`UpdatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.UpdatedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
		`Format:` + fmt.Sprintf("%v", this.Format) + `,`,
		`BaseTopic:` + fmt.Sprintf("%v", this.BaseTopic) + `,`,
		`DownlinkPush:` + strings.Replace(fmt.Sprintf("%v", this.DownlinkPush), "ApplicationPubSub_Message", "ApplicationPubSub_Message", 1) + `,`,
		`DownlinkReplace:` + strings.Replace(fmt.Sprintf("%v", this.DownlinkReplace), "ApplicationPubSub_Message", "ApplicationPubSub_Message", 1) + `,`,
		`UplinkMessage:` + strings.Replace(fmt.Sprintf("%v", this.UplinkMessage), "ApplicationPubSub_Message", "ApplicationPubSub_Message", 1) + `,`,
		`JoinAccept:` + strings.Replace(fmt.Sprintf("%v", this.JoinAccept), "ApplicationPubSub_Message", "ApplicationPubSub_Message", 1) + `,`,
		`DownlinkAck:` + strings.Replace(fmt.Sprintf("%v", this.DownlinkAck), "ApplicationPubSub_Message", "ApplicationPubSub_Message", 1) + `,`,
		`DownlinkNack:` + strings.Replace(fmt.Sprintf("%v", this.DownlinkNack), "ApplicationPubSub_Message", "ApplicationPubSub_Message", 1) + `,`,
		`DownlinkSent:` + strings.Replace(fmt.Sprintf("%v", this.DownlinkSent), "ApplicationPubSub_Message", "ApplicationPubSub_Message", 1) + `,`,
		`DownlinkFailed:` + strings.Replace(fmt.Sprintf("%v", this.DownlinkFailed), "ApplicationPubSub_Message", "ApplicationPubSub_Message", 1) + `,`,
		`DownlinkQueued:` + strings.Replace(fmt.Sprintf("%v", this.DownlinkQueued), "ApplicationPubSub_Message", "ApplicationPubSub_Message", 1) + `,`,
		`LocationSolved:` + strings.Replace(fmt.Sprintf("%v", this.LocationSolved), "ApplicationPubSub_Message", "ApplicationPubSub_Message", 1) + `,`,
		`Provider:` + fmt.Sprintf("%v", this.Provider) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ApplicationPubSub_NATS) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ApplicationPubSub_NATS{`,
		`NATS:` + strings.Replace(fmt.Sprintf("%v", this.NATS), "ApplicationPubSub_NATSProvider", "ApplicationPubSub_NATSProvider", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ApplicationPubSub_MQTT) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ApplicationPubSub_MQTT{`,
		`MQTT:` + strings.Replace(fmt.Sprintf("%v", this.MQTT), "ApplicationPubSub_MQTTProvider", "ApplicationPubSub_MQTTProvider", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ApplicationPubSub_NATSProvider) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ApplicationPubSub_NATSProvider{`,
		`ServerURL:` + fmt.Sprintf("%v", this.ServerURL) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ApplicationPubSub_MQTTProvider) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ApplicationPubSub_MQTTProvider{`,
		`ServerURL:` + fmt.Sprintf("%v", this.ServerURL) + `,`,
		`ClientID:` + fmt.Sprintf("%v", this.ClientID) + `,`,
		`Username:` + fmt.Sprintf("%v", this.Username) + `,`,
		`Password:` + fmt.Sprintf("%v", this.Password) + `,`,
		`SubscribeQoS:` + fmt.Sprintf("%v", this.SubscribeQoS) + `,`,
		`PublishQoS:` + fmt.Sprintf("%v", this.PublishQoS) + `,`,
		`UseTLS:` + fmt.Sprintf("%v", this.UseTLS) + `,`,
		`TLSCA:` + fmt.Sprintf("%v", this.TLSCA) + `,`,
		`TLSClientCert:` + fmt.Sprintf("%v", this.TLSClientCert) + `,`,
		`TLSClientKey:` + fmt.Sprintf("%v", this.TLSClientKey) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ApplicationPubSub_Message) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ApplicationPubSub_Message{`,
		`Topic:` + fmt.Sprintf("%v", this.Topic) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ApplicationPubSubs) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForPubsubs := "[]*ApplicationPubSub{"
	for _, f := range this.Pubsubs {
		repeatedStringForPubsubs += strings.Replace(f.String(), "ApplicationPubSub", "ApplicationPubSub", 1) + ","
	}
	repeatedStringForPubsubs += "}"
	s := strings.Join([]string{`&ApplicationPubSubs{`,
		`Pubsubs:` + repeatedStringForPubsubs + `,`,
		`}`,
	}, "")
	return s
}
func (this *ApplicationPubSubFormats) String() string {
	if this == nil {
		return "nil"
	}
	keysForFormats := make([]string, 0, len(this.Formats))
	for k := range this.Formats {
		keysForFormats = append(keysForFormats, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForFormats)
	mapStringForFormats := "map[string]string{"
	for _, k := range keysForFormats {
		mapStringForFormats += fmt.Sprintf("%v: %v,", k, this.Formats[k])
	}
	mapStringForFormats += "}"
	s := strings.Join([]string{`&ApplicationPubSubFormats{`,
		`Formats:` + mapStringForFormats + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetApplicationPubSubRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetApplicationPubSubRequest{`,
		`ApplicationPubSubIdentifiers:` + strings.Replace(strings.Replace(this.ApplicationPubSubIdentifiers.String(), "ApplicationPubSubIdentifiers", "ApplicationPubSubIdentifiers", 1), `&`, ``, 1) + `,`,
		`FieldMask:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.FieldMask), "FieldMask", "types.FieldMask", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ListApplicationPubSubsRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ListApplicationPubSubsRequest{`,
		`ApplicationIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ApplicationIdentifiers), "ApplicationIdentifiers", "ApplicationIdentifiers", 1), `&`, ``, 1) + `,`,
		`FieldMask:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.FieldMask), "FieldMask", "types.FieldMask", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SetApplicationPubSubRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SetApplicationPubSubRequest{`,
		`ApplicationPubSub:` + strings.Replace(strings.Replace(this.ApplicationPubSub.String(), "ApplicationPubSub", "ApplicationPubSub", 1), `&`, ``, 1) + `,`,
		`FieldMask:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.FieldMask), "FieldMask", "types.FieldMask", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringApplicationserverPubsub(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *ApplicationPubSubIdentifiers) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApplicationserverPubsub
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ApplicationPubSubIdentifiers: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ApplicationPubSubIdentifiers: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ApplicationIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PubSubID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PubSubID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApplicationserverPubsub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ApplicationPubSub) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApplicationserverPubsub
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ApplicationPubSub: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ApplicationPubSub: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationPubSubIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ApplicationPubSubIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreatedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdatedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Format = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BaseTopic", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BaseTopic = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownlinkPush", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DownlinkPush == nil {
				m.DownlinkPush = &ApplicationPubSub_Message{}
			}
			if err := m.DownlinkPush.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownlinkReplace", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DownlinkReplace == nil {
				m.DownlinkReplace = &ApplicationPubSub_Message{}
			}
			if err := m.DownlinkReplace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UplinkMessage", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UplinkMessage == nil {
				m.UplinkMessage = &ApplicationPubSub_Message{}
			}
			if err := m.UplinkMessage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JoinAccept", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.JoinAccept == nil {
				m.JoinAccept = &ApplicationPubSub_Message{}
			}
			if err := m.JoinAccept.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownlinkAck", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DownlinkAck == nil {
				m.DownlinkAck = &ApplicationPubSub_Message{}
			}
			if err := m.DownlinkAck.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownlinkNack", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DownlinkNack == nil {
				m.DownlinkNack = &ApplicationPubSub_Message{}
			}
			if err := m.DownlinkNack.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownlinkSent", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DownlinkSent == nil {
				m.DownlinkSent = &ApplicationPubSub_Message{}
			}
			if err := m.DownlinkSent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownlinkFailed", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DownlinkFailed == nil {
				m.DownlinkFailed = &ApplicationPubSub_Message{}
			}
			if err := m.DownlinkFailed.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownlinkQueued", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DownlinkQueued == nil {
				m.DownlinkQueued = &ApplicationPubSub_Message{}
			}
			if err := m.DownlinkQueued.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocationSolved", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LocationSolved == nil {
				m.LocationSolved = &ApplicationPubSub_Message{}
			}
			if err := m.LocationSolved.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NATS", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ApplicationPubSub_NATSProvider{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Provider = &ApplicationPubSub_NATS{v}
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MQTT", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ApplicationPubSub_MQTTProvider{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Provider = &ApplicationPubSub_MQTT{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApplicationserverPubsub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ApplicationPubSub_NATSProvider) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApplicationserverPubsub
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NATSProvider: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NATSProvider: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerURL", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServerURL = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApplicationserverPubsub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ApplicationPubSub_MQTTProvider) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApplicationserverPubsub
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MQTTProvider: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MQTTProvider: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerURL", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServerURL = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClientID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Username = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Password = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscribeQoS", wireType)
			}
			m.SubscribeQoS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SubscribeQoS |= ApplicationPubSub_MQTTProvider_QoS(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublishQoS", wireType)
			}
			m.PublishQoS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PublishQoS |= ApplicationPubSub_MQTTProvider_QoS(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseTLS", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UseTLS = bool(v != 0)
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TLSCA", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TLSCA = append(m.TLSCA[:0], dAtA[iNdEx:postIndex]...)
			if m.TLSCA == nil {
				m.TLSCA = []byte{}
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TLSClientCert", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TLSClientCert = append(m.TLSClientCert[:0], dAtA[iNdEx:postIndex]...)
			if m.TLSClientCert == nil {
				m.TLSClientCert = []byte{}
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TLSClientKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TLSClientKey = append(m.TLSClientKey[:0], dAtA[iNdEx:postIndex]...)
			if m.TLSClientKey == nil {
				m.TLSClientKey = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApplicationserverPubsub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ApplicationPubSub_Message) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApplicationserverPubsub
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Topic = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApplicationserverPubsub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ApplicationPubSubs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApplicationserverPubsub
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ApplicationPubSubs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ApplicationPubSubs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pubsubs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Pubsubs = append(m.Pubsubs, &ApplicationPubSub{})
			if err := m.Pubsubs[len(m.Pubsubs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApplicationserverPubsub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ApplicationPubSubFormats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApplicationserverPubsub
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ApplicationPubSubFormats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ApplicationPubSubFormats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Formats", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Formats == nil {
				m.Formats = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApplicationserverPubsub
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApplicationserverPubsub
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthApplicationserverPubsub
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthApplicationserverPubsub
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApplicationserverPubsub
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthApplicationserverPubsub
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthApplicationserverPubsub
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipApplicationserverPubsub(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthApplicationserverPubsub
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Formats[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApplicationserverPubsub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetApplicationPubSubRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApplicationserverPubsub
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetApplicationPubSubRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetApplicationPubSubRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationPubSubIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ApplicationPubSubIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FieldMask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.FieldMask.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApplicationserverPubsub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ListApplicationPubSubsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApplicationserverPubsub
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListApplicationPubSubsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListApplicationPubSubsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ApplicationIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FieldMask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.FieldMask.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApplicationserverPubsub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SetApplicationPubSubRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApplicationserverPubsub
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetApplicationPubSubRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetApplicationPubSubRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationPubSub", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ApplicationPubSub.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FieldMask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.FieldMask.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApplicationserverPubsub(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApplicationserverPubsub
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipApplicationserverPubsub(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowApplicationserverPubsub
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowApplicationserverPubsub
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthApplicationserverPubsub
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupApplicationserverPubsub
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthApplicationserverPubsub
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthApplicationserverPubsub        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowApplicationserverPubsub          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupApplicationserverPubsub = fmt.Errorf("proto: unexpected end of group")
)