msgs.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: desmos/reactions/v1/msgs.proto

package types

import (
	context "context"
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	types "github.com/cosmos/cosmos-sdk/codec/types"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// MsgAddReaction represents the message to be used to add a post reaction
type MsgAddReaction struct {
	// Id of the subspace inside which the post to react to is
	SubspaceID uint64 `protobuf:"varint,1,opt,name=subspace_id,json=subspaceId,proto3" json:"subspace_id,omitempty" yaml:"subspace_id"`
	// Id of the post to react to
	PostID uint64 `protobuf:"varint,2,opt,name=post_id,json=postId,proto3" json:"post_id,omitempty" yaml:"post_id"`
	// Value of the reaction
	Value *types.Any `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty" yaml:"value"`
	// User reacting to the post
	User string `protobuf:"bytes,4,opt,name=user,proto3" json:"user,omitempty" yaml:"user"`
}

func (m *MsgAddReaction) Reset()         { *m = MsgAddReaction{} }
func (m *MsgAddReaction) String() string { return proto.CompactTextString(m) }
func (*MsgAddReaction) ProtoMessage()    {}
func (*MsgAddReaction) Descriptor() ([]byte, []int) {
	return fileDescriptor_de4e0bd9e58b59f1, []int{0}
}
func (m *MsgAddReaction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgAddReaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgAddReaction.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 *MsgAddReaction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgAddReaction.Merge(m, src)
}
func (m *MsgAddReaction) XXX_Size() int {
	return m.Size()
}
func (m *MsgAddReaction) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgAddReaction.DiscardUnknown(m)
}

var xxx_messageInfo_MsgAddReaction proto.InternalMessageInfo

func (m *MsgAddReaction) GetSubspaceID() uint64 {
	if m != nil {
		return m.SubspaceID
	}
	return 0
}

func (m *MsgAddReaction) GetPostID() uint64 {
	if m != nil {
		return m.PostID
	}
	return 0
}

func (m *MsgAddReaction) GetValue() *types.Any {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *MsgAddReaction) GetUser() string {
	if m != nil {
		return m.User
	}
	return ""
}

// MsgAddReactionResponse represents the Msg/AddReaction response type
type MsgAddReactionResponse struct {
	// Id of the newly added reaction
	ReactionID uint32 `protobuf:"varint,1,opt,name=reaction_id,json=reactionId,proto3" json:"reaction_id,omitempty" yaml:"reaction_id"`
}

func (m *MsgAddReactionResponse) Reset()         { *m = MsgAddReactionResponse{} }
func (m *MsgAddReactionResponse) String() string { return proto.CompactTextString(m) }
func (*MsgAddReactionResponse) ProtoMessage()    {}
func (*MsgAddReactionResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_de4e0bd9e58b59f1, []int{1}
}
func (m *MsgAddReactionResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgAddReactionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgAddReactionResponse.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 *MsgAddReactionResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgAddReactionResponse.Merge(m, src)
}
func (m *MsgAddReactionResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgAddReactionResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgAddReactionResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgAddReactionResponse proto.InternalMessageInfo

func (m *MsgAddReactionResponse) GetReactionID() uint32 {
	if m != nil {
		return m.ReactionID
	}
	return 0
}

// MsgRemoveReaction represents the message to be used to remove an
// existing reaction from a post
type MsgRemoveReaction struct {
	// Id of the subspace inside which the reaction to remove is
	SubspaceID uint64 `protobuf:"varint,1,opt,name=subspace_id,json=subspaceId,proto3" json:"subspace_id,omitempty" yaml:"subspace_id"`
	// Id of the post from which to remove the reaction
	PostID uint64 `protobuf:"varint,2,opt,name=post_id,json=postId,proto3" json:"post_id,omitempty" yaml:"post_id"`
	// Id of the reaction to be removed
	ReactionID uint32 `protobuf:"varint,3,opt,name=reaction_id,json=reactionId,proto3" json:"reaction_id,omitempty" yaml:"reaction_id"`
	// User removing the reaction
	User string `protobuf:"bytes,4,opt,name=user,proto3" json:"user,omitempty" yaml:"user"`
}

func (m *MsgRemoveReaction) Reset()         { *m = MsgRemoveReaction{} }
func (m *MsgRemoveReaction) String() string { return proto.CompactTextString(m) }
func (*MsgRemoveReaction) ProtoMessage()    {}
func (*MsgRemoveReaction) Descriptor() ([]byte, []int) {
	return fileDescriptor_de4e0bd9e58b59f1, []int{2}
}
func (m *MsgRemoveReaction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgRemoveReaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgRemoveReaction.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 *MsgRemoveReaction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgRemoveReaction.Merge(m, src)
}
func (m *MsgRemoveReaction) XXX_Size() int {
	return m.Size()
}
func (m *MsgRemoveReaction) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgRemoveReaction.DiscardUnknown(m)
}

var xxx_messageInfo_MsgRemoveReaction proto.InternalMessageInfo

func (m *MsgRemoveReaction) GetSubspaceID() uint64 {
	if m != nil {
		return m.SubspaceID
	}
	return 0
}

func (m *MsgRemoveReaction) GetPostID() uint64 {
	if m != nil {
		return m.PostID
	}
	return 0
}

func (m *MsgRemoveReaction) GetReactionID() uint32 {
	if m != nil {
		return m.ReactionID
	}
	return 0
}

func (m *MsgRemoveReaction) GetUser() string {
	if m != nil {
		return m.User
	}
	return ""
}

// MsgRemoveReactionResponse represents the Msg/RemoveReaction response type
type MsgRemoveReactionResponse struct {
}

func (m *MsgRemoveReactionResponse) Reset()         { *m = MsgRemoveReactionResponse{} }
func (m *MsgRemoveReactionResponse) String() string { return proto.CompactTextString(m) }
func (*MsgRemoveReactionResponse) ProtoMessage()    {}
func (*MsgRemoveReactionResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_de4e0bd9e58b59f1, []int{3}
}
func (m *MsgRemoveReactionResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgRemoveReactionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgRemoveReactionResponse.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 *MsgRemoveReactionResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgRemoveReactionResponse.Merge(m, src)
}
func (m *MsgRemoveReactionResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgRemoveReactionResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgRemoveReactionResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgRemoveReactionResponse proto.InternalMessageInfo

// MsgAddRegisteredReaction represents the message to be used to
// register a new supported reaction
type MsgAddRegisteredReaction struct {
	// Id of the subspace inside which this reaction should be registered
	SubspaceID uint64 `protobuf:"varint,1,opt,name=subspace_id,json=subspaceId,proto3" json:"subspace_id,omitempty" yaml:"subspace_id"`
	// Shorthand code of the reaction
	ShorthandCode string `protobuf:"bytes,2,opt,name=shorthand_code,json=shorthandCode,proto3" json:"shorthand_code,omitempty" yaml:"shorthand_code"`
	// Display value of the reaction
	DisplayValue string `protobuf:"bytes,3,opt,name=display_value,json=displayValue,proto3" json:"display_value,omitempty" yaml:"display_value"`
	// User adding the supported reaction
	User string `protobuf:"bytes,4,opt,name=user,proto3" json:"user,omitempty" yaml:"user"`
}

func (m *MsgAddRegisteredReaction) Reset()         { *m = MsgAddRegisteredReaction{} }
func (m *MsgAddRegisteredReaction) String() string { return proto.CompactTextString(m) }
func (*MsgAddRegisteredReaction) ProtoMessage()    {}
func (*MsgAddRegisteredReaction) Descriptor() ([]byte, []int) {
	return fileDescriptor_de4e0bd9e58b59f1, []int{4}
}
func (m *MsgAddRegisteredReaction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgAddRegisteredReaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgAddRegisteredReaction.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 *MsgAddRegisteredReaction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgAddRegisteredReaction.Merge(m, src)
}
func (m *MsgAddRegisteredReaction) XXX_Size() int {
	return m.Size()
}
func (m *MsgAddRegisteredReaction) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgAddRegisteredReaction.DiscardUnknown(m)
}

var xxx_messageInfo_MsgAddRegisteredReaction proto.InternalMessageInfo

func (m *MsgAddRegisteredReaction) GetSubspaceID() uint64 {
	if m != nil {
		return m.SubspaceID
	}
	return 0
}

func (m *MsgAddRegisteredReaction) GetShorthandCode() string {
	if m != nil {
		return m.ShorthandCode
	}
	return ""
}

func (m *MsgAddRegisteredReaction) GetDisplayValue() string {
	if m != nil {
		return m.DisplayValue
	}
	return ""
}

func (m *MsgAddRegisteredReaction) GetUser() string {
	if m != nil {
		return m.User
	}
	return ""
}

// MsgAddRegisteredReactionResponse represents the
// Msg/AddRegisteredReaction response type
type MsgAddRegisteredReactionResponse struct {
	// Id of the newly registered reaction
	RegisteredReactionID uint32 `protobuf:"varint,1,opt,name=registered_reaction_id,json=registeredReactionId,proto3" json:"registered_reaction_id,omitempty" yaml:"registered_reaction_id"`
}

func (m *MsgAddRegisteredReactionResponse) Reset()         { *m = MsgAddRegisteredReactionResponse{} }
func (m *MsgAddRegisteredReactionResponse) String() string { return proto.CompactTextString(m) }
func (*MsgAddRegisteredReactionResponse) ProtoMessage()    {}
func (*MsgAddRegisteredReactionResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_de4e0bd9e58b59f1, []int{5}
}
func (m *MsgAddRegisteredReactionResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgAddRegisteredReactionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgAddRegisteredReactionResponse.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 *MsgAddRegisteredReactionResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgAddRegisteredReactionResponse.Merge(m, src)
}
func (m *MsgAddRegisteredReactionResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgAddRegisteredReactionResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgAddRegisteredReactionResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgAddRegisteredReactionResponse proto.InternalMessageInfo

func (m *MsgAddRegisteredReactionResponse) GetRegisteredReactionID() uint32 {
	if m != nil {
		return m.RegisteredReactionID
	}
	return 0
}

// MsgEditRegisteredReaction represents the message to be used to edit a
// registered reaction
type MsgEditRegisteredReaction struct {
	// Id of the subspace inside which the reaction to edit is
	SubspaceID uint64 `protobuf:"varint,1,opt,name=subspace_id,json=subspaceId,proto3" json:"subspace_id,omitempty" yaml:"subspace_id"`
	// Id of the registered reaction to edit
	RegisteredReactionID uint32 `protobuf:"varint,2,opt,name=registered_reaction_id,json=registeredReactionId,proto3" json:"registered_reaction_id,omitempty" yaml:"registered_reaction_id"`
	// New shorthand code to be set
	ShorthandCode string `protobuf:"bytes,3,opt,name=shorthand_code,json=shorthandCode,proto3" json:"shorthand_code,omitempty" yaml:"shorthand_code"`
	// Display value to be set
	DisplayValue string `protobuf:"bytes,4,opt,name=display_value,json=displayValue,proto3" json:"display_value,omitempty" yaml:"display_value"`
	// User editing the registered reaction
	User string `protobuf:"bytes,5,opt,name=user,proto3" json:"user,omitempty" yaml:"user"`
}

func (m *MsgEditRegisteredReaction) Reset()         { *m = MsgEditRegisteredReaction{} }
func (m *MsgEditRegisteredReaction) String() string { return proto.CompactTextString(m) }
func (*MsgEditRegisteredReaction) ProtoMessage()    {}
func (*MsgEditRegisteredReaction) Descriptor() ([]byte, []int) {
	return fileDescriptor_de4e0bd9e58b59f1, []int{6}
}
func (m *MsgEditRegisteredReaction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgEditRegisteredReaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgEditRegisteredReaction.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 *MsgEditRegisteredReaction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgEditRegisteredReaction.Merge(m, src)
}
func (m *MsgEditRegisteredReaction) XXX_Size() int {
	return m.Size()
}
func (m *MsgEditRegisteredReaction) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgEditRegisteredReaction.DiscardUnknown(m)
}

var xxx_messageInfo_MsgEditRegisteredReaction proto.InternalMessageInfo

func (m *MsgEditRegisteredReaction) GetSubspaceID() uint64 {
	if m != nil {
		return m.SubspaceID
	}
	return 0
}

func (m *MsgEditRegisteredReaction) GetRegisteredReactionID() uint32 {
	if m != nil {
		return m.RegisteredReactionID
	}
	return 0
}

func (m *MsgEditRegisteredReaction) GetShorthandCode() string {
	if m != nil {
		return m.ShorthandCode
	}
	return ""
}

func (m *MsgEditRegisteredReaction) GetDisplayValue() string {
	if m != nil {
		return m.DisplayValue
	}
	return ""
}

func (m *MsgEditRegisteredReaction) GetUser() string {
	if m != nil {
		return m.User
	}
	return ""
}

// MsgEditRegisteredReactionResponse represents the Msg/EditRegisteredReaction
// response type
type MsgEditRegisteredReactionResponse struct {
}

func (m *MsgEditRegisteredReactionResponse) Reset()         { *m = MsgEditRegisteredReactionResponse{} }
func (m *MsgEditRegisteredReactionResponse) String() string { return proto.CompactTextString(m) }
func (*MsgEditRegisteredReactionResponse) ProtoMessage()    {}
func (*MsgEditRegisteredReactionResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_de4e0bd9e58b59f1, []int{7}
}
func (m *MsgEditRegisteredReactionResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgEditRegisteredReactionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgEditRegisteredReactionResponse.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 *MsgEditRegisteredReactionResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgEditRegisteredReactionResponse.Merge(m, src)
}
func (m *MsgEditRegisteredReactionResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgEditRegisteredReactionResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgEditRegisteredReactionResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgEditRegisteredReactionResponse proto.InternalMessageInfo

// MsgRemoveRegisteredReaction represents the message to be used to
// remove an existing registered reaction
type MsgRemoveRegisteredReaction struct {
	// Id of the subspace from which to remove the registered reaction
	SubspaceID uint64 `protobuf:"varint,1,opt,name=subspace_id,json=subspaceId,proto3" json:"subspace_id,omitempty" yaml:"subspace_id"`
	// Id of the registered reaction to be removed
	RegisteredReactionID uint32 `protobuf:"varint,2,opt,name=registered_reaction_id,json=registeredReactionId,proto3" json:"registered_reaction_id,omitempty" yaml:"registered_reaction_id"`
	// User removing the registered reaction
	User string `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty" yaml:"user"`
}

func (m *MsgRemoveRegisteredReaction) Reset()         { *m = MsgRemoveRegisteredReaction{} }
func (m *MsgRemoveRegisteredReaction) String() string { return proto.CompactTextString(m) }
func (*MsgRemoveRegisteredReaction) ProtoMessage()    {}
func (*MsgRemoveRegisteredReaction) Descriptor() ([]byte, []int) {
	return fileDescriptor_de4e0bd9e58b59f1, []int{8}
}
func (m *MsgRemoveRegisteredReaction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgRemoveRegisteredReaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgRemoveRegisteredReaction.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 *MsgRemoveRegisteredReaction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgRemoveRegisteredReaction.Merge(m, src)
}
func (m *MsgRemoveRegisteredReaction) XXX_Size() int {
	return m.Size()
}
func (m *MsgRemoveRegisteredReaction) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgRemoveRegisteredReaction.DiscardUnknown(m)
}

var xxx_messageInfo_MsgRemoveRegisteredReaction proto.InternalMessageInfo

func (m *MsgRemoveRegisteredReaction) GetSubspaceID() uint64 {
	if m != nil {
		return m.SubspaceID
	}
	return 0
}

func (m *MsgRemoveRegisteredReaction) GetRegisteredReactionID() uint32 {
	if m != nil {
		return m.RegisteredReactionID
	}
	return 0
}

func (m *MsgRemoveRegisteredReaction) GetUser() string {
	if m != nil {
		return m.User
	}
	return ""
}

// MsgRemoveRegisteredReactionResponse represents the
// Msg/RemoveRegisteredReaction response type
type MsgRemoveRegisteredReactionResponse struct {
}

func (m *MsgRemoveRegisteredReactionResponse) Reset()         { *m = MsgRemoveRegisteredReactionResponse{} }
func (m *MsgRemoveRegisteredReactionResponse) String() string { return proto.CompactTextString(m) }
func (*MsgRemoveRegisteredReactionResponse) ProtoMessage()    {}
func (*MsgRemoveRegisteredReactionResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_de4e0bd9e58b59f1, []int{9}
}
func (m *MsgRemoveRegisteredReactionResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgRemoveRegisteredReactionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgRemoveRegisteredReactionResponse.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 *MsgRemoveRegisteredReactionResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgRemoveRegisteredReactionResponse.Merge(m, src)
}
func (m *MsgRemoveRegisteredReactionResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgRemoveRegisteredReactionResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgRemoveRegisteredReactionResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgRemoveRegisteredReactionResponse proto.InternalMessageInfo

// MsgSetReactionsParams represents the message to be used when setting
// a subspace reactions params
type MsgSetReactionsParams struct {
	// Id of the subspace for which to set the params
	SubspaceID uint64 `protobuf:"varint,1,opt,name=subspace_id,json=subspaceId,proto3" json:"subspace_id,omitempty" yaml:"subspace_id"`
	// Params related to RegisteredReactionValue reactions
	RegisteredReaction RegisteredReactionValueParams `protobuf:"bytes,2,opt,name=registered_reaction,json=registeredReaction,proto3" json:"registered_reaction" yaml:"registered_reaction"`
	// Params related to FreeTextValue reactions
	FreeText FreeTextValueParams `protobuf:"bytes,3,opt,name=free_text,json=freeText,proto3" json:"free_text" yaml:"free_text"`
	// User setting the params
	User string `protobuf:"bytes,4,opt,name=user,proto3" json:"user,omitempty" yaml:"user"`
}

func (m *MsgSetReactionsParams) Reset()         { *m = MsgSetReactionsParams{} }
func (m *MsgSetReactionsParams) String() string { return proto.CompactTextString(m) }
func (*MsgSetReactionsParams) ProtoMessage()    {}
func (*MsgSetReactionsParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_de4e0bd9e58b59f1, []int{10}
}
func (m *MsgSetReactionsParams) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgSetReactionsParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgSetReactionsParams.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 *MsgSetReactionsParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgSetReactionsParams.Merge(m, src)
}
func (m *MsgSetReactionsParams) XXX_Size() int {
	return m.Size()
}
func (m *MsgSetReactionsParams) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgSetReactionsParams.DiscardUnknown(m)
}

var xxx_messageInfo_MsgSetReactionsParams proto.InternalMessageInfo

func (m *MsgSetReactionsParams) GetSubspaceID() uint64 {
	if m != nil {
		return m.SubspaceID
	}
	return 0
}

func (m *MsgSetReactionsParams) GetRegisteredReaction() RegisteredReactionValueParams {
	if m != nil {
		return m.RegisteredReaction
	}
	return RegisteredReactionValueParams{}
}

func (m *MsgSetReactionsParams) GetFreeText() FreeTextValueParams {
	if m != nil {
		return m.FreeText
	}
	return FreeTextValueParams{}
}

func (m *MsgSetReactionsParams) GetUser() string {
	if m != nil {
		return m.User
	}
	return ""
}

// MsgSetReactionsParamsResponse represents the Msg/SetReactionsParams response
// type
type MsgSetReactionsParamsResponse struct {
}

func (m *MsgSetReactionsParamsResponse) Reset()         { *m = MsgSetReactionsParamsResponse{} }
func (m *MsgSetReactionsParamsResponse) String() string { return proto.CompactTextString(m) }
func (*MsgSetReactionsParamsResponse) ProtoMessage()    {}
func (*MsgSetReactionsParamsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_de4e0bd9e58b59f1, []int{11}
}
func (m *MsgSetReactionsParamsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgSetReactionsParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgSetReactionsParamsResponse.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 *MsgSetReactionsParamsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgSetReactionsParamsResponse.Merge(m, src)
}
func (m *MsgSetReactionsParamsResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgSetReactionsParamsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgSetReactionsParamsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgSetReactionsParamsResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgAddReaction)(nil), "desmos.reactions.v1.MsgAddReaction")
	proto.RegisterType((*MsgAddReactionResponse)(nil), "desmos.reactions.v1.MsgAddReactionResponse")
	proto.RegisterType((*MsgRemoveReaction)(nil), "desmos.reactions.v1.MsgRemoveReaction")
	proto.RegisterType((*MsgRemoveReactionResponse)(nil), "desmos.reactions.v1.MsgRemoveReactionResponse")
	proto.RegisterType((*MsgAddRegisteredReaction)(nil), "desmos.reactions.v1.MsgAddRegisteredReaction")
	proto.RegisterType((*MsgAddRegisteredReactionResponse)(nil), "desmos.reactions.v1.MsgAddRegisteredReactionResponse")
	proto.RegisterType((*MsgEditRegisteredReaction)(nil), "desmos.reactions.v1.MsgEditRegisteredReaction")
	proto.RegisterType((*MsgEditRegisteredReactionResponse)(nil), "desmos.reactions.v1.MsgEditRegisteredReactionResponse")
	proto.RegisterType((*MsgRemoveRegisteredReaction)(nil), "desmos.reactions.v1.MsgRemoveRegisteredReaction")
	proto.RegisterType((*MsgRemoveRegisteredReactionResponse)(nil), "desmos.reactions.v1.MsgRemoveRegisteredReactionResponse")
	proto.RegisterType((*MsgSetReactionsParams)(nil), "desmos.reactions.v1.MsgSetReactionsParams")
	proto.RegisterType((*MsgSetReactionsParamsResponse)(nil), "desmos.reactions.v1.MsgSetReactionsParamsResponse")
}

func init() { proto.RegisterFile("desmos/reactions/v1/msgs.proto", fileDescriptor_de4e0bd9e58b59f1) }

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

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

// MsgClient is the client API for Msg service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MsgClient interface {
	// AddReaction allows to add a post reaction
	AddReaction(ctx context.Context, in *MsgAddReaction, opts ...grpc.CallOption) (*MsgAddReactionResponse, error)
	// RemoveReaction allows to remove an existing post reaction
	RemoveReaction(ctx context.Context, in *MsgRemoveReaction, opts ...grpc.CallOption) (*MsgRemoveReactionResponse, error)
	// AddRegisteredReaction allows to registered a new supported reaction
	AddRegisteredReaction(ctx context.Context, in *MsgAddRegisteredReaction, opts ...grpc.CallOption) (*MsgAddRegisteredReactionResponse, error)
	// EditRegisteredReaction allows to edit a registered reaction
	EditRegisteredReaction(ctx context.Context, in *MsgEditRegisteredReaction, opts ...grpc.CallOption) (*MsgEditRegisteredReactionResponse, error)
	// RemoveRegisteredReaction allows to remove an existing supported reaction
	RemoveRegisteredReaction(ctx context.Context, in *MsgRemoveRegisteredReaction, opts ...grpc.CallOption) (*MsgRemoveRegisteredReactionResponse, error)
	// SetReactionsParams allows to set the reactions params
	SetReactionsParams(ctx context.Context, in *MsgSetReactionsParams, opts ...grpc.CallOption) (*MsgSetReactionsParamsResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

func NewMsgClient(cc grpc1.ClientConn) MsgClient {
	return &msgClient{cc}
}

func (c *msgClient) AddReaction(ctx context.Context, in *MsgAddReaction, opts ...grpc.CallOption) (*MsgAddReactionResponse, error) {
	out := new(MsgAddReactionResponse)
	err := c.cc.Invoke(ctx, "/desmos.reactions.v1.Msg/AddReaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) RemoveReaction(ctx context.Context, in *MsgRemoveReaction, opts ...grpc.CallOption) (*MsgRemoveReactionResponse, error) {
	out := new(MsgRemoveReactionResponse)
	err := c.cc.Invoke(ctx, "/desmos.reactions.v1.Msg/RemoveReaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) AddRegisteredReaction(ctx context.Context, in *MsgAddRegisteredReaction, opts ...grpc.CallOption) (*MsgAddRegisteredReactionResponse, error) {
	out := new(MsgAddRegisteredReactionResponse)
	err := c.cc.Invoke(ctx, "/desmos.reactions.v1.Msg/AddRegisteredReaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) EditRegisteredReaction(ctx context.Context, in *MsgEditRegisteredReaction, opts ...grpc.CallOption) (*MsgEditRegisteredReactionResponse, error) {
	out := new(MsgEditRegisteredReactionResponse)
	err := c.cc.Invoke(ctx, "/desmos.reactions.v1.Msg/EditRegisteredReaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) RemoveRegisteredReaction(ctx context.Context, in *MsgRemoveRegisteredReaction, opts ...grpc.CallOption) (*MsgRemoveRegisteredReactionResponse, error) {
	out := new(MsgRemoveRegisteredReactionResponse)
	err := c.cc.Invoke(ctx, "/desmos.reactions.v1.Msg/RemoveRegisteredReaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) SetReactionsParams(ctx context.Context, in *MsgSetReactionsParams, opts ...grpc.CallOption) (*MsgSetReactionsParamsResponse, error) {
	out := new(MsgSetReactionsParamsResponse)
	err := c.cc.Invoke(ctx, "/desmos.reactions.v1.Msg/SetReactionsParams", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	// AddReaction allows to add a post reaction
	AddReaction(context.Context, *MsgAddReaction) (*MsgAddReactionResponse, error)
	// RemoveReaction allows to remove an existing post reaction
	RemoveReaction(context.Context, *MsgRemoveReaction) (*MsgRemoveReactionResponse, error)
	// AddRegisteredReaction allows to registered a new supported reaction
	AddRegisteredReaction(context.Context, *MsgAddRegisteredReaction) (*MsgAddRegisteredReactionResponse, error)
	// EditRegisteredReaction allows to edit a registered reaction
	EditRegisteredReaction(context.Context, *MsgEditRegisteredReaction) (*MsgEditRegisteredReactionResponse, error)
	// RemoveRegisteredReaction allows to remove an existing supported reaction
	RemoveRegisteredReaction(context.Context, *MsgRemoveRegisteredReaction) (*MsgRemoveRegisteredReactionResponse, error)
	// SetReactionsParams allows to set the reactions params
	SetReactionsParams(context.Context, *MsgSetReactionsParams) (*MsgSetReactionsParamsResponse, error)
}

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

func (*UnimplementedMsgServer) AddReaction(ctx context.Context, req *MsgAddReaction) (*MsgAddReactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddReaction not implemented")
}
func (*UnimplementedMsgServer) RemoveReaction(ctx context.Context, req *MsgRemoveReaction) (*MsgRemoveReactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveReaction not implemented")
}
func (*UnimplementedMsgServer) AddRegisteredReaction(ctx context.Context, req *MsgAddRegisteredReaction) (*MsgAddRegisteredReactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddRegisteredReaction not implemented")
}
func (*UnimplementedMsgServer) EditRegisteredReaction(ctx context.Context, req *MsgEditRegisteredReaction) (*MsgEditRegisteredReactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EditRegisteredReaction not implemented")
}
func (*UnimplementedMsgServer) RemoveRegisteredReaction(ctx context.Context, req *MsgRemoveRegisteredReaction) (*MsgRemoveRegisteredReactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveRegisteredReaction not implemented")
}
func (*UnimplementedMsgServer) SetReactionsParams(ctx context.Context, req *MsgSetReactionsParams) (*MsgSetReactionsParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetReactionsParams not implemented")
}

func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
	s.RegisterService(&_Msg_serviceDesc, srv)
}

func _Msg_AddReaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgAddReaction)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).AddReaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/desmos.reactions.v1.Msg/AddReaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).AddReaction(ctx, req.(*MsgAddReaction))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_RemoveReaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgRemoveReaction)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).RemoveReaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/desmos.reactions.v1.Msg/RemoveReaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).RemoveReaction(ctx, req.(*MsgRemoveReaction))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_AddRegisteredReaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgAddRegisteredReaction)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).AddRegisteredReaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/desmos.reactions.v1.Msg/AddRegisteredReaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).AddRegisteredReaction(ctx, req.(*MsgAddRegisteredReaction))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_EditRegisteredReaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgEditRegisteredReaction)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).EditRegisteredReaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/desmos.reactions.v1.Msg/EditRegisteredReaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).EditRegisteredReaction(ctx, req.(*MsgEditRegisteredReaction))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_RemoveRegisteredReaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgRemoveRegisteredReaction)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).RemoveRegisteredReaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/desmos.reactions.v1.Msg/RemoveRegisteredReaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).RemoveRegisteredReaction(ctx, req.(*MsgRemoveRegisteredReaction))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_SetReactionsParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSetReactionsParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SetReactionsParams(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/desmos.reactions.v1.Msg/SetReactionsParams",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SetReactionsParams(ctx, req.(*MsgSetReactionsParams))
	}
	return interceptor(ctx, in, info, handler)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "desmos.reactions.v1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "AddReaction",
			Handler:    _Msg_AddReaction_Handler,
		},
		{
			MethodName: "RemoveReaction",
			Handler:    _Msg_RemoveReaction_Handler,
		},
		{
			MethodName: "AddRegisteredReaction",
			Handler:    _Msg_AddRegisteredReaction_Handler,
		},
		{
			MethodName: "EditRegisteredReaction",
			Handler:    _Msg_EditRegisteredReaction_Handler,
		},
		{
			MethodName: "RemoveRegisteredReaction",
			Handler:    _Msg_RemoveRegisteredReaction_Handler,
		},
		{
			MethodName: "SetReactionsParams",
			Handler:    _Msg_SetReactionsParams_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "desmos/reactions/v1/msgs.proto",
}

func (m *MsgAddReaction) 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 *MsgAddReaction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgAddReaction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.User) > 0 {
		i -= len(m.User)
		copy(dAtA[i:], m.User)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.User)))
		i--
		dAtA[i] = 0x22
	}
	if m.Value != nil {
		{
			size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMsgs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.PostID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.PostID))
		i--
		dAtA[i] = 0x10
	}
	if m.SubspaceID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.SubspaceID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgAddReactionResponse) 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 *MsgAddReactionResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgAddReactionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ReactionID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.ReactionID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgRemoveReaction) 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 *MsgRemoveReaction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgRemoveReaction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.User) > 0 {
		i -= len(m.User)
		copy(dAtA[i:], m.User)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.User)))
		i--
		dAtA[i] = 0x22
	}
	if m.ReactionID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.ReactionID))
		i--
		dAtA[i] = 0x18
	}
	if m.PostID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.PostID))
		i--
		dAtA[i] = 0x10
	}
	if m.SubspaceID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.SubspaceID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgRemoveReactionResponse) 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 *MsgRemoveReactionResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgRemoveReactionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgAddRegisteredReaction) 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 *MsgAddRegisteredReaction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgAddRegisteredReaction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.User) > 0 {
		i -= len(m.User)
		copy(dAtA[i:], m.User)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.User)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.DisplayValue) > 0 {
		i -= len(m.DisplayValue)
		copy(dAtA[i:], m.DisplayValue)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.DisplayValue)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ShorthandCode) > 0 {
		i -= len(m.ShorthandCode)
		copy(dAtA[i:], m.ShorthandCode)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.ShorthandCode)))
		i--
		dAtA[i] = 0x12
	}
	if m.SubspaceID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.SubspaceID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgAddRegisteredReactionResponse) 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 *MsgAddRegisteredReactionResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgAddRegisteredReactionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RegisteredReactionID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.RegisteredReactionID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgEditRegisteredReaction) 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 *MsgEditRegisteredReaction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgEditRegisteredReaction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.User) > 0 {
		i -= len(m.User)
		copy(dAtA[i:], m.User)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.User)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.DisplayValue) > 0 {
		i -= len(m.DisplayValue)
		copy(dAtA[i:], m.DisplayValue)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.DisplayValue)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ShorthandCode) > 0 {
		i -= len(m.ShorthandCode)
		copy(dAtA[i:], m.ShorthandCode)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.ShorthandCode)))
		i--
		dAtA[i] = 0x1a
	}
	if m.RegisteredReactionID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.RegisteredReactionID))
		i--
		dAtA[i] = 0x10
	}
	if m.SubspaceID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.SubspaceID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgEditRegisteredReactionResponse) 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 *MsgEditRegisteredReactionResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgEditRegisteredReactionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgRemoveRegisteredReaction) 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 *MsgRemoveRegisteredReaction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgRemoveRegisteredReaction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.User) > 0 {
		i -= len(m.User)
		copy(dAtA[i:], m.User)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.User)))
		i--
		dAtA[i] = 0x1a
	}
	if m.RegisteredReactionID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.RegisteredReactionID))
		i--
		dAtA[i] = 0x10
	}
	if m.SubspaceID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.SubspaceID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgRemoveRegisteredReactionResponse) 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 *MsgRemoveRegisteredReactionResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgRemoveRegisteredReactionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgSetReactionsParams) 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 *MsgSetReactionsParams) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgSetReactionsParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.User) > 0 {
		i -= len(m.User)
		copy(dAtA[i:], m.User)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.User)))
		i--
		dAtA[i] = 0x22
	}
	{
		size, err := m.FreeText.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMsgs(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.RegisteredReaction.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMsgs(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.SubspaceID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.SubspaceID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MsgSetReactionsParamsResponse) 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 *MsgSetReactionsParamsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgSetReactionsParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func encodeVarintMsgs(dAtA []byte, offset int, v uint64) int {
	offset -= sovMsgs(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *MsgAddReaction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SubspaceID != 0 {
		n += 1 + sovMsgs(uint64(m.SubspaceID))
	}
	if m.PostID != 0 {
		n += 1 + sovMsgs(uint64(m.PostID))
	}
	if m.Value != nil {
		l = m.Value.Size()
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.User)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

func (m *MsgAddReactionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ReactionID != 0 {
		n += 1 + sovMsgs(uint64(m.ReactionID))
	}
	return n
}

func (m *MsgRemoveReaction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SubspaceID != 0 {
		n += 1 + sovMsgs(uint64(m.SubspaceID))
	}
	if m.PostID != 0 {
		n += 1 + sovMsgs(uint64(m.PostID))
	}
	if m.ReactionID != 0 {
		n += 1 + sovMsgs(uint64(m.ReactionID))
	}
	l = len(m.User)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

func (m *MsgRemoveReactionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgAddRegisteredReaction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SubspaceID != 0 {
		n += 1 + sovMsgs(uint64(m.SubspaceID))
	}
	l = len(m.ShorthandCode)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.DisplayValue)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.User)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

func (m *MsgAddRegisteredReactionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RegisteredReactionID != 0 {
		n += 1 + sovMsgs(uint64(m.RegisteredReactionID))
	}
	return n
}

func (m *MsgEditRegisteredReaction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SubspaceID != 0 {
		n += 1 + sovMsgs(uint64(m.SubspaceID))
	}
	if m.RegisteredReactionID != 0 {
		n += 1 + sovMsgs(uint64(m.RegisteredReactionID))
	}
	l = len(m.ShorthandCode)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.DisplayValue)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.User)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

func (m *MsgEditRegisteredReactionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgRemoveRegisteredReaction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SubspaceID != 0 {
		n += 1 + sovMsgs(uint64(m.SubspaceID))
	}
	if m.RegisteredReactionID != 0 {
		n += 1 + sovMsgs(uint64(m.RegisteredReactionID))
	}
	l = len(m.User)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

func (m *MsgRemoveRegisteredReactionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgSetReactionsParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SubspaceID != 0 {
		n += 1 + sovMsgs(uint64(m.SubspaceID))
	}
	l = m.RegisteredReaction.Size()
	n += 1 + l + sovMsgs(uint64(l))
	l = m.FreeText.Size()
	n += 1 + l + sovMsgs(uint64(l))
	l = len(m.User)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

func (m *MsgSetReactionsParamsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func sovMsgs(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMsgs(x uint64) (n int) {
	return sovMsgs(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MsgAddReaction) 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 ErrIntOverflowMsgs
			}
			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: MsgAddReaction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddReaction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubspaceID", wireType)
			}
			m.SubspaceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SubspaceID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PostID", wireType)
			}
			m.PostID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PostID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Value == nil {
				m.Value = &types.Any{}
			}
			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.User = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgAddReactionResponse) 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 ErrIntOverflowMsgs
			}
			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: MsgAddReactionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddReactionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReactionID", wireType)
			}
			m.ReactionID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReactionID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgRemoveReaction) 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 ErrIntOverflowMsgs
			}
			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: MsgRemoveReaction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRemoveReaction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubspaceID", wireType)
			}
			m.SubspaceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SubspaceID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PostID", wireType)
			}
			m.PostID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PostID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReactionID", wireType)
			}
			m.ReactionID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReactionID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.User = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgRemoveReactionResponse) 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 ErrIntOverflowMsgs
			}
			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: MsgRemoveReactionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRemoveReactionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgAddRegisteredReaction) 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 ErrIntOverflowMsgs
			}
			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: MsgAddRegisteredReaction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddRegisteredReaction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubspaceID", wireType)
			}
			m.SubspaceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SubspaceID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShorthandCode", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ShorthandCode = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisplayValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DisplayValue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.User = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgAddRegisteredReactionResponse) 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 ErrIntOverflowMsgs
			}
			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: MsgAddRegisteredReactionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddRegisteredReactionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegisteredReactionID", wireType)
			}
			m.RegisteredReactionID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RegisteredReactionID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgEditRegisteredReaction) 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 ErrIntOverflowMsgs
			}
			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: MsgEditRegisteredReaction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgEditRegisteredReaction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubspaceID", wireType)
			}
			m.SubspaceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SubspaceID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegisteredReactionID", wireType)
			}
			m.RegisteredReactionID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RegisteredReactionID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShorthandCode", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ShorthandCode = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisplayValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DisplayValue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.User = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgEditRegisteredReactionResponse) 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 ErrIntOverflowMsgs
			}
			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: MsgEditRegisteredReactionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgEditRegisteredReactionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgRemoveRegisteredReaction) 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 ErrIntOverflowMsgs
			}
			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: MsgRemoveRegisteredReaction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRemoveRegisteredReaction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubspaceID", wireType)
			}
			m.SubspaceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SubspaceID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegisteredReactionID", wireType)
			}
			m.RegisteredReactionID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RegisteredReactionID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.User = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgRemoveRegisteredReactionResponse) 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 ErrIntOverflowMsgs
			}
			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: MsgRemoveRegisteredReactionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRemoveRegisteredReactionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgSetReactionsParams) 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 ErrIntOverflowMsgs
			}
			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: MsgSetReactionsParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSetReactionsParams: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubspaceID", wireType)
			}
			m.SubspaceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SubspaceID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegisteredReaction", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RegisteredReaction.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FreeText", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.FreeText.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.User = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgSetReactionsParamsResponse) 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 ErrIntOverflowMsgs
			}
			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: MsgSetReactionsParamsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSetReactionsParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipMsgs(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, ErrIntOverflowMsgs
			}
			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, ErrIntOverflowMsgs
				}
				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, ErrIntOverflowMsgs
				}
				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, ErrInvalidLengthMsgs
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupMsgs
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthMsgs
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthMsgs        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMsgs          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMsgs = fmt.Errorf("proto: unexpected end of group")
)