msgs.pb.go

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

package types

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/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

// MsgCreateSubspace represents the message used to create a subspace
type MsgCreateSubspace struct {
	Name        string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty" yaml:"name"`
	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty" yaml:"description"`
	Treasury    string `protobuf:"bytes,3,opt,name=treasury,proto3" json:"treasury,omitempty" yaml:"treasury"`
	Owner       string `protobuf:"bytes,4,opt,name=owner,proto3" json:"owner,omitempty" yaml:"owner"`
	Creator     string `protobuf:"bytes,5,opt,name=creator,proto3" json:"creator,omitempty" yaml:"creator"`
}

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

var xxx_messageInfo_MsgCreateSubspace proto.InternalMessageInfo

// MsgCreateSubspaceResponse defines the Msg/CreateSubspace response type
type MsgCreateSubspaceResponse struct {
	SubspaceID uint64 `protobuf:"varint,1,opt,name=subspace_id,json=subspaceId,proto3" json:"subspace_id,omitempty" yaml:"subspace_id"`
}

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

var xxx_messageInfo_MsgCreateSubspaceResponse proto.InternalMessageInfo

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

// MsgEditSubspace represents the message used to edit a subspace fields
type MsgEditSubspace struct {
	SubspaceID  uint64 `protobuf:"varint,1,opt,name=subspace_id,json=subspaceId,proto3" json:"subspace_id,omitempty" yaml:"subspace_id"`
	Name        string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty" yaml:"name"`
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty" yaml:"description"`
	Treasury    string `protobuf:"bytes,4,opt,name=treasury,proto3" json:"treasury,omitempty" yaml:"treasury"`
	Owner       string `protobuf:"bytes,5,opt,name=owner,proto3" json:"owner,omitempty" yaml:"owner"`
	Signer      string `protobuf:"bytes,6,opt,name=signer,proto3" json:"signer,omitempty" yaml:"signer"`
}

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

var xxx_messageInfo_MsgEditSubspace proto.InternalMessageInfo

// MsgEditSubspaceResponse defines the Msg/EditSubspace response type
type MsgEditSubspaceResponse struct {
}

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

var xxx_messageInfo_MsgEditSubspaceResponse proto.InternalMessageInfo

// MsgDeleteSubspace represents the message used to delete a subspace
type MsgDeleteSubspace struct {
	SubspaceID uint64 `protobuf:"varint,1,opt,name=subspace_id,json=subspaceId,proto3" json:"subspace_id,omitempty" yaml:"subspace_id"`
	Signer     string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty" yaml:"signer"`
}

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

var xxx_messageInfo_MsgDeleteSubspace proto.InternalMessageInfo

// MsgDeleteSubspaceResponse defines the Msg/DeleteSubspace response type
type MsgDeleteSubspaceResponse struct {
}

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

var xxx_messageInfo_MsgDeleteSubspaceResponse proto.InternalMessageInfo

// MsgCreateUserGroup represents the message used to create a user group
type MsgCreateUserGroup struct {
	SubspaceID uint64 `protobuf:"varint,1,opt,name=subspace_id,json=subspaceId,proto3" json:"subspace_id,omitempty" yaml:"subspace_id"`
	// Name of the group
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty" yaml:"name"`
	// Optional description of the group
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty" yaml:"description"`
	// Default permissions to be applied to the group
	DefaultPermissions uint32 `protobuf:"varint,4,opt,name=default_permissions,json=defaultPermissions,proto3" json:"default_permissions,omitempty" yaml:"default_permissions"`
	// Creator of the group
	Creator string `protobuf:"bytes,5,opt,name=creator,proto3" json:"creator,omitempty" yaml:"creator"`
}

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

var xxx_messageInfo_MsgCreateUserGroup proto.InternalMessageInfo

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

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

func (m *MsgCreateUserGroup) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *MsgCreateUserGroup) GetDefaultPermissions() uint32 {
	if m != nil {
		return m.DefaultPermissions
	}
	return 0
}

func (m *MsgCreateUserGroup) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

// MsgCreateUserGroupResponse defines the Msg/CreateUserGroup response type
type MsgCreateUserGroupResponse struct {
	GroupID uint32 `protobuf:"varint,1,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty" yaml:"group_id"`
}

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

var xxx_messageInfo_MsgCreateUserGroupResponse proto.InternalMessageInfo

func (m *MsgCreateUserGroupResponse) GetGroupID() uint32 {
	if m != nil {
		return m.GroupID
	}
	return 0
}

// MsgEditUserGroup represents the message used to edit a user group
type MsgEditUserGroup struct {
	SubspaceID  uint64 `protobuf:"varint,1,opt,name=subspace_id,json=subspaceId,proto3" json:"subspace_id,omitempty" yaml:"subspace_id"`
	GroupID     uint32 `protobuf:"varint,2,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty" yaml:"group_id"`
	Name        string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty" yaml:"name"`
	Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty" yaml:"description"`
	Signer      string `protobuf:"bytes,5,opt,name=signer,proto3" json:"signer,omitempty" yaml:"signer"`
}

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

var xxx_messageInfo_MsgEditUserGroup proto.InternalMessageInfo

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

func (m *MsgEditUserGroup) GetGroupID() uint32 {
	if m != nil {
		return m.GroupID
	}
	return 0
}

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

func (m *MsgEditUserGroup) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *MsgEditUserGroup) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

// MsgEditUserGroupResponse defines the Msg/EditUserGroup response type
type MsgEditUserGroupResponse struct {
}

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

var xxx_messageInfo_MsgEditUserGroupResponse proto.InternalMessageInfo

// MsgSetUserGroupPermissions represents the message used to set the permissions
// of a user group
type MsgSetUserGroupPermissions struct {
	SubspaceID  uint64 `protobuf:"varint,1,opt,name=subspace_id,json=subspaceId,proto3" json:"subspace_id,omitempty" yaml:"subspace_id"`
	GroupID     uint32 `protobuf:"varint,2,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty" yaml:"group_id"`
	Permissions uint32 `protobuf:"varint,3,opt,name=permissions,proto3" json:"permissions,omitempty" yaml:"permissions"`
	Signer      string `protobuf:"bytes,4,opt,name=signer,proto3" json:"signer,omitempty" yaml:"signer"`
}

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

var xxx_messageInfo_MsgSetUserGroupPermissions proto.InternalMessageInfo

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

func (m *MsgSetUserGroupPermissions) GetGroupID() uint32 {
	if m != nil {
		return m.GroupID
	}
	return 0
}

func (m *MsgSetUserGroupPermissions) GetPermissions() uint32 {
	if m != nil {
		return m.Permissions
	}
	return 0
}

func (m *MsgSetUserGroupPermissions) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

// MsgSetUserGroupPermissionsResponse defines the
// Msg/SetUserGroupPermissionsResponse response type
type MsgSetUserGroupPermissionsResponse struct {
}

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

var xxx_messageInfo_MsgSetUserGroupPermissionsResponse proto.InternalMessageInfo

// MsgDeleteUserGroup represents the message used to delete a user group
type MsgDeleteUserGroup struct {
	SubspaceID uint64 `protobuf:"varint,1,opt,name=subspace_id,json=subspaceId,proto3" json:"subspace_id,omitempty" yaml:"subspace_id"`
	GroupID    uint32 `protobuf:"varint,2,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty" yaml:"group_id"`
	Signer     string `protobuf:"bytes,3,opt,name=signer,proto3" json:"signer,omitempty" yaml:"signer"`
}

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

var xxx_messageInfo_MsgDeleteUserGroup proto.InternalMessageInfo

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

func (m *MsgDeleteUserGroup) GetGroupID() uint32 {
	if m != nil {
		return m.GroupID
	}
	return 0
}

func (m *MsgDeleteUserGroup) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

// MsgDeleteUserGroupResponse defines the Msg/DeleteUserGroup response type
type MsgDeleteUserGroupResponse struct {
}

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

var xxx_messageInfo_MsgDeleteUserGroupResponse proto.InternalMessageInfo

// MsgAddUserToUserGroup represents the message used to add a user to a user
// group
type MsgAddUserToUserGroup struct {
	SubspaceID uint64 `protobuf:"varint,1,opt,name=subspace_id,json=subspaceId,proto3" json:"subspace_id,omitempty" yaml:"subspace_id"`
	GroupID    uint32 `protobuf:"varint,2,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty" yaml:"group_id"`
	User       string `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty" yaml:"user"`
	Signer     string `protobuf:"bytes,4,opt,name=signer,proto3" json:"signer,omitempty" yaml:"signer"`
}

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

var xxx_messageInfo_MsgAddUserToUserGroup proto.InternalMessageInfo

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

func (m *MsgAddUserToUserGroup) GetGroupID() uint32 {
	if m != nil {
		return m.GroupID
	}
	return 0
}

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

func (m *MsgAddUserToUserGroup) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

// MsgAddUserToUserGroupResponse defines the Msg/AddUserToUserGroupResponse
// response type
type MsgAddUserToUserGroupResponse struct {
}

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

var xxx_messageInfo_MsgAddUserToUserGroupResponse proto.InternalMessageInfo

// MsgRemoveUserFromUserGroup represents the message used to remove a user from
// a user group
type MsgRemoveUserFromUserGroup struct {
	SubspaceID uint64 `protobuf:"varint,1,opt,name=subspace_id,json=subspaceId,proto3" json:"subspace_id,omitempty" yaml:"subspace_id"`
	GroupID    uint32 `protobuf:"varint,2,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty" yaml:"group_id"`
	User       string `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty" yaml:"user"`
	Signer     string `protobuf:"bytes,4,opt,name=signer,proto3" json:"signer,omitempty" yaml:"signer"`
}

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

var xxx_messageInfo_MsgRemoveUserFromUserGroup proto.InternalMessageInfo

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

func (m *MsgRemoveUserFromUserGroup) GetGroupID() uint32 {
	if m != nil {
		return m.GroupID
	}
	return 0
}

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

func (m *MsgRemoveUserFromUserGroup) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

// MsgRemoveUserFromUserGroupResponse defines the
// Msg/RemoveUserFromUserGroupResponse response type
type MsgRemoveUserFromUserGroupResponse struct {
}

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

var xxx_messageInfo_MsgRemoveUserFromUserGroupResponse proto.InternalMessageInfo

// MsgSetUserPermissions represents the message used to set the permissions of a
// specific user
type MsgSetUserPermissions struct {
	SubspaceID  uint64 `protobuf:"varint,1,opt,name=subspace_id,json=subspaceId,proto3" json:"subspace_id,omitempty" yaml:"subspace_id"`
	User        string `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty" yaml:"user"`
	Permissions uint32 `protobuf:"varint,3,opt,name=permissions,proto3" json:"permissions,omitempty" yaml:"permissions"`
	Signer      string `protobuf:"bytes,4,opt,name=signer,proto3" json:"signer,omitempty" yaml:"signer"`
}

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

var xxx_messageInfo_MsgSetUserPermissions proto.InternalMessageInfo

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

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

func (m *MsgSetUserPermissions) GetPermissions() uint32 {
	if m != nil {
		return m.Permissions
	}
	return 0
}

func (m *MsgSetUserPermissions) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

// MsgSetUserPermissionsResponse defines the Msg/SetPermissionsResponse
// response type
type MsgSetUserPermissionsResponse struct {
}

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

var xxx_messageInfo_MsgSetUserPermissionsResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgCreateSubspace)(nil), "desmos.subspaces.v1.MsgCreateSubspace")
	proto.RegisterType((*MsgCreateSubspaceResponse)(nil), "desmos.subspaces.v1.MsgCreateSubspaceResponse")
	proto.RegisterType((*MsgEditSubspace)(nil), "desmos.subspaces.v1.MsgEditSubspace")
	proto.RegisterType((*MsgEditSubspaceResponse)(nil), "desmos.subspaces.v1.MsgEditSubspaceResponse")
	proto.RegisterType((*MsgDeleteSubspace)(nil), "desmos.subspaces.v1.MsgDeleteSubspace")
	proto.RegisterType((*MsgDeleteSubspaceResponse)(nil), "desmos.subspaces.v1.MsgDeleteSubspaceResponse")
	proto.RegisterType((*MsgCreateUserGroup)(nil), "desmos.subspaces.v1.MsgCreateUserGroup")
	proto.RegisterType((*MsgCreateUserGroupResponse)(nil), "desmos.subspaces.v1.MsgCreateUserGroupResponse")
	proto.RegisterType((*MsgEditUserGroup)(nil), "desmos.subspaces.v1.MsgEditUserGroup")
	proto.RegisterType((*MsgEditUserGroupResponse)(nil), "desmos.subspaces.v1.MsgEditUserGroupResponse")
	proto.RegisterType((*MsgSetUserGroupPermissions)(nil), "desmos.subspaces.v1.MsgSetUserGroupPermissions")
	proto.RegisterType((*MsgSetUserGroupPermissionsResponse)(nil), "desmos.subspaces.v1.MsgSetUserGroupPermissionsResponse")
	proto.RegisterType((*MsgDeleteUserGroup)(nil), "desmos.subspaces.v1.MsgDeleteUserGroup")
	proto.RegisterType((*MsgDeleteUserGroupResponse)(nil), "desmos.subspaces.v1.MsgDeleteUserGroupResponse")
	proto.RegisterType((*MsgAddUserToUserGroup)(nil), "desmos.subspaces.v1.MsgAddUserToUserGroup")
	proto.RegisterType((*MsgAddUserToUserGroupResponse)(nil), "desmos.subspaces.v1.MsgAddUserToUserGroupResponse")
	proto.RegisterType((*MsgRemoveUserFromUserGroup)(nil), "desmos.subspaces.v1.MsgRemoveUserFromUserGroup")
	proto.RegisterType((*MsgRemoveUserFromUserGroupResponse)(nil), "desmos.subspaces.v1.MsgRemoveUserFromUserGroupResponse")
	proto.RegisterType((*MsgSetUserPermissions)(nil), "desmos.subspaces.v1.MsgSetUserPermissions")
	proto.RegisterType((*MsgSetUserPermissionsResponse)(nil), "desmos.subspaces.v1.MsgSetUserPermissionsResponse")
}

func init() { proto.RegisterFile("desmos/subspaces/v1/msgs.proto", fileDescriptor_c16a431ff9a3b35b) }

var fileDescriptor_c16a431ff9a3b35b = []byte{
	// 920 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0x4b, 0x6f, 0xe3, 0x44,
	0x1c, 0x8f, 0x9d, 0xa4, 0x0d, 0xff, 0x6c, 0x9a, 0x5d, 0x17, 0xd8, 0xac, 0x01, 0x7b, 0x35, 0x94,
	0x5d, 0x58, 0xed, 0xc6, 0xda, 0xec, 0x81, 0x65, 0x6f, 0x84, 0x2d, 0xa8, 0x12, 0x11, 0xc8, 0x05,
	0x21, 0x71, 0xa9, 0x92, 0x78, 0x70, 0x2d, 0xe2, 0x4c, 0xe4, 0x71, 0x02, 0x3d, 0xf7, 0xc2, 0x0d,
	0x3e, 0x01, 0xea, 0xd7, 0xe0, 0xc8, 0x01, 0x89, 0x63, 0x8f, 0x9c, 0x2c, 0x94, 0x5e, 0xca, 0x85,
	0x43, 0x0e, 0x9c, 0x91, 0xc7, 0xf6, 0x64, 0xf2, 0x70, 0xe2, 0xa0, 0x02, 0x85, 0x9b, 0x33, 0xff,
	0xdf, 0x3c, 0x7e, 0x8f, 0x79, 0x28, 0xa0, 0x59, 0x98, 0xba, 0x84, 0x1a, 0x74, 0xd8, 0xa1, 0x83,
	0x76, 0x17, 0x53, 0x63, 0xf4, 0xd8, 0x70, 0xa9, 0x4d, 0xeb, 0x03, 0x8f, 0xf8, 0x44, 0xd9, 0x8d,
	0xea, 0x75, 0x5e, 0xaf, 0x8f, 0x1e, 0xab, 0x2f, 0xda, 0xc4, 0x26, 0xac, 0x6e, 0x84, 0x5f, 0x11,
	0x54, 0xbd, 0xbb, 0x74, 0x28, 0x62, 0xe1, 0x5e, 0x3c, 0x18, 0x3a, 0x95, 0xe1, 0x56, 0x8b, 0xda,
	0xef, 0x79, 0xb8, 0xed, 0xe3, 0xc3, 0x18, 0xa6, 0xbc, 0x0e, 0x85, 0x7e, 0xdb, 0xc5, 0x35, 0xe9,
	0xae, 0xf4, 0xe6, 0x0b, 0xcd, 0xea, 0x24, 0xd0, 0xcb, 0x27, 0x6d, 0xb7, 0xf7, 0x0c, 0x85, 0xad,
	0xc8, 0x64, 0x45, 0xe5, 0x29, 0x94, 0x2d, 0x4c, 0xbb, 0x9e, 0x33, 0xf0, 0x1d, 0xd2, 0xaf, 0xc9,
	0x0c, 0xfb, 0xf2, 0x24, 0xd0, 0x95, 0x08, 0x2b, 0x14, 0x91, 0x29, 0x42, 0x15, 0x03, 0x4a, 0xbe,
	0x87, 0xdb, 0x74, 0xe8, 0x9d, 0xd4, 0xf2, 0xac, 0xdb, 0xee, 0x24, 0xd0, 0xab, 0x51, 0xb7, 0xa4,
	0x82, 0x4c, 0x0e, 0x52, 0xee, 0x41, 0x91, 0x7c, 0xd5, 0xc7, 0x5e, 0xad, 0xc0, 0xd0, 0x37, 0x27,
	0x81, 0x7e, 0x23, 0x42, 0xb3, 0x66, 0x64, 0x46, 0x65, 0xe5, 0x21, 0x6c, 0x77, 0x43, 0x26, 0xc4,
	0xab, 0x15, 0x19, 0x52, 0x99, 0x04, 0xfa, 0x4e, 0x84, 0x8c, 0x0b, 0xc8, 0x4c, 0x20, 0xcf, 0x4a,
	0xdf, 0x9c, 0xe9, 0xb9, 0xcb, 0x33, 0x3d, 0x87, 0x3a, 0x70, 0x67, 0x41, 0x04, 0x13, 0xd3, 0x01,
	0xe9, 0x53, 0xac, 0xec, 0x43, 0x39, 0xd1, 0xef, 0xc8, 0xb1, 0x98, 0x26, 0x85, 0xe6, 0xde, 0x38,
	0xd0, 0x21, 0x81, 0x1e, 0x3c, 0x9f, 0xb2, 0x16, 0xa0, 0xc8, 0x84, 0xe4, 0xd7, 0x81, 0x85, 0x7e,
	0x92, 0xa1, 0xda, 0xa2, 0xf6, 0xbe, 0xe5, 0xf8, 0x5c, 0xe7, 0xab, 0x19, 0x9a, 0xdb, 0x25, 0x6f,
	0x60, 0x57, 0xfe, 0xaf, 0xd9, 0x55, 0xd8, 0xc8, 0xae, 0xe2, 0x6a, 0xbb, 0xde, 0x82, 0x2d, 0xea,
	0xd8, 0x21, 0x70, 0x8b, 0x01, 0x6f, 0x4d, 0x02, 0xbd, 0x12, 0x73, 0x65, 0xed, 0xc8, 0x8c, 0x01,
	0x82, 0x57, 0x77, 0xe0, 0xf6, 0x9c, 0x8c, 0x89, 0x53, 0xe8, 0x5b, 0x89, 0x85, 0xf9, 0x39, 0xee,
	0x61, 0x21, 0xcc, 0x57, 0x24, 0xf2, 0x74, 0xb1, 0x72, 0xf6, 0xc5, 0xbe, 0xc2, 0x82, 0x35, 0xbb,
	0x20, 0xbe, 0xdc, 0x1f, 0x64, 0x50, 0x78, 0xec, 0x3e, 0xa5, 0xd8, 0xfb, 0xc0, 0x23, 0xc3, 0xc1,
	0x7f, 0x24, 0x14, 0x1f, 0xc1, 0xae, 0x85, 0xbf, 0x68, 0x0f, 0x7b, 0xfe, 0xd1, 0x00, 0x7b, 0xae,
	0x43, 0xa9, 0x43, 0xfa, 0x94, 0xe5, 0xa3, 0xd2, 0xd4, 0x26, 0x81, 0xae, 0x26, 0x23, 0x2c, 0x80,
	0x90, 0xa9, 0xc4, 0xad, 0x1f, 0x4f, 0x1b, 0x37, 0xdb, 0xbb, 0xe8, 0x33, 0x50, 0x17, 0xa5, 0xe3,
	0x5b, 0xf6, 0x1d, 0x28, 0xd9, 0x61, 0x43, 0xa2, 0x5f, 0xa5, 0xa9, 0x8d, 0x03, 0x7d, 0x9b, 0x81,
	0x98, 0x78, 0x71, 0x78, 0x13, 0x10, 0x32, 0xb7, 0xd9, 0xe7, 0x81, 0x85, 0xbe, 0x97, 0xe1, 0x66,
	0x9c, 0xaf, 0x2b, 0xb7, 0x44, 0x5c, 0x96, 0xbc, 0xd1, 0xb2, 0xb8, 0x9b, 0xf9, 0x0d, 0xdc, 0x2c,
	0x64, 0x77, 0x73, 0x1a, 0xee, 0xe2, 0x9a, 0x70, 0x23, 0x15, 0x6a, 0xf3, 0xfa, 0xf0, 0x44, 0x9f,
	0xca, 0xcc, 0x96, 0x43, 0x3c, 0xad, 0x89, 0x16, 0xff, 0xfb, 0x32, 0x3e, 0x85, 0xb2, 0x98, 0xd6,
	0x3c, 0xeb, 0x2d, 0x28, 0x34, 0x93, 0x52, 0x11, 0x2a, 0x28, 0x54, 0x58, 0xa7, 0xd0, 0x1e, 0xa0,
	0x74, 0x11, 0xb8, 0x56, 0x3f, 0x4a, 0x6c, 0xf7, 0x47, 0x67, 0xc3, 0x75, 0x8a, 0xda, 0x94, 0x69,
	0x7e, 0x1d, 0xd3, 0x57, 0x99, 0xdd, 0x73, 0x14, 0x38, 0xc3, 0xdf, 0x24, 0x78, 0xa9, 0x45, 0xed,
	0x77, 0x2d, 0x2b, 0xac, 0x7d, 0x42, 0xae, 0xd9, 0x7e, 0x1a, 0x52, 0x4e, 0x51, 0xd8, 0x4f, 0x61,
	0x2b, 0x32, 0x59, 0x71, 0x13, 0xcf, 0x75, 0x78, 0x6d, 0x29, 0x55, 0x2e, 0xc6, 0xef, 0x12, 0xd3,
	0xca, 0xc4, 0x2e, 0x19, 0x31, 0xad, 0xde, 0xf7, 0x88, 0xfb, 0x7f, 0x56, 0x24, 0xda, 0x05, 0x29,
	0x7c, 0xb9, 0x2c, 0x97, 0x51, 0x46, 0xe2, 0xcd, 0xf2, 0x37, 0x1c, 0x16, 0x09, 0x2d, 0x79, 0x15,
	0xad, 0x7f, 0xe4, 0x58, 0x88, 0x22, 0xb2, 0xc8, 0x34, 0xd1, 0xa2, 0xf1, 0x47, 0x09, 0xf2, 0x2d,
	0x6a, 0x2b, 0xc7, 0xb0, 0x33, 0xf7, 0x1e, 0xbf, 0x57, 0x5f, 0xf2, 0xe6, 0xaf, 0x2f, 0x3c, 0x59,
	0xd5, 0x7a, 0x36, 0x1c, 0xbf, 0x27, 0x3b, 0x70, 0x63, 0xe6, 0x3d, 0xba, 0x97, 0xd6, 0x5f, 0x44,
	0xa9, 0x0f, 0xb3, 0xa0, 0xf8, 0x1c, 0xc7, 0xb0, 0x33, 0xf7, 0x20, 0x4b, 0x65, 0x33, 0x8b, 0x4b,
	0x67, 0xb3, 0xfc, 0x3d, 0xa5, 0x7c, 0x09, 0xd5, 0xf9, 0xb7, 0xd4, 0xfd, 0xd5, 0x82, 0x70, 0xa0,
	0x6a, 0x64, 0x04, 0xf2, 0xc9, 0x30, 0x54, 0x66, 0xdf, 0x08, 0x6f, 0xac, 0x52, 0x65, 0x3a, 0xd1,
	0xa3, 0x4c, 0x30, 0x3e, 0xcd, 0xa9, 0x04, 0xb7, 0xd3, 0xae, 0xd3, 0xd4, 0x35, 0xa7, 0x74, 0x50,
	0xdf, 0xde, 0xb0, 0x83, 0xa8, 0xec, 0xfc, 0x3d, 0x75, 0x7f, 0xb5, 0x39, 0x19, 0x94, 0x4d, 0xb9,
	0x36, 0x14, 0x1f, 0x94, 0x25, 0x57, 0xc6, 0x83, 0xb4, 0x61, 0x16, 0xb1, 0x6a, 0x23, 0x3b, 0x76,
	0x46, 0xe8, 0xb4, 0xc3, 0x39, 0x95, 0x42, 0x4a, 0x87, 0x74, 0xa1, 0xd7, 0x1c, 0x87, 0x21, 0xf7,
	0x25, 0x47, 0xe1, 0x83, 0x35, 0xbe, 0x89, 0x1e, 0x37, 0xb2, 0x63, 0x93, 0x59, 0x9b, 0x1f, 0xfe,
	0x3c, 0xd6, 0xa4, 0xf3, 0xb1, 0x26, 0xfd, 0x3a, 0xd6, 0xa4, 0xef, 0x2e, 0xb4, 0xdc, 0xf9, 0x85,
	0x96, 0xfb, 0xe5, 0x42, 0xcb, 0x7d, 0xde, 0xb0, 0x1d, 0xff, 0x78, 0xd8, 0xa9, 0x77, 0x89, 0x6b,
	0x44, 0xe3, 0x3e, 0xea, 0xb5, 0x3b, 0x34, 0xfe, 0x36, 0x46, 0x4f, 0x8c, 0xaf, 0x85, 0x3f, 0x17,
	0xfc, 0x93, 0x01, 0xa6, 0x9d, 0x2d, 0xf6, 0xcf, 0xc2, 0x93, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff,
	0x07, 0x7e, 0x40, 0x3d, 0xc8, 0x10, 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 {
	// CreateSubspace allows to create a subspace
	CreateSubspace(ctx context.Context, in *MsgCreateSubspace, opts ...grpc.CallOption) (*MsgCreateSubspaceResponse, error)
	// EditSubspace allows to edit a subspace
	EditSubspace(ctx context.Context, in *MsgEditSubspace, opts ...grpc.CallOption) (*MsgEditSubspaceResponse, error)
	// DeleteSubspace allows to delete a subspace
	DeleteSubspace(ctx context.Context, in *MsgDeleteSubspace, opts ...grpc.CallOption) (*MsgDeleteSubspaceResponse, error)
	// CreateUserGroup allows to create a user group
	CreateUserGroup(ctx context.Context, in *MsgCreateUserGroup, opts ...grpc.CallOption) (*MsgCreateUserGroupResponse, error)
	// EditUserGroup allows to edit a user group
	EditUserGroup(ctx context.Context, in *MsgEditUserGroup, opts ...grpc.CallOption) (*MsgEditUserGroupResponse, error)
	// SetUserGroupPermissions allows to set the permissions for a specific group
	SetUserGroupPermissions(ctx context.Context, in *MsgSetUserGroupPermissions, opts ...grpc.CallOption) (*MsgSetUserGroupPermissionsResponse, error)
	// DeleteUserGroup allows to delete an existing user group
	DeleteUserGroup(ctx context.Context, in *MsgDeleteUserGroup, opts ...grpc.CallOption) (*MsgDeleteUserGroupResponse, error)
	// AddUserToUserGroup allows to add a specific user to a specific user group
	AddUserToUserGroup(ctx context.Context, in *MsgAddUserToUserGroup, opts ...grpc.CallOption) (*MsgAddUserToUserGroupResponse, error)
	// RemoveUserFromUserGroup allows to remove a specific user from a specific
	// user group
	RemoveUserFromUserGroup(ctx context.Context, in *MsgRemoveUserFromUserGroup, opts ...grpc.CallOption) (*MsgRemoveUserFromUserGroupResponse, error)
	// SetUserPermissions allows to set the permissions for a specific user
	SetUserPermissions(ctx context.Context, in *MsgSetUserPermissions, opts ...grpc.CallOption) (*MsgSetUserPermissionsResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

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

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

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

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

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

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

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

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

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

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

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

// MsgServer is the server API for Msg service.
type MsgServer interface {
	// CreateSubspace allows to create a subspace
	CreateSubspace(context.Context, *MsgCreateSubspace) (*MsgCreateSubspaceResponse, error)
	// EditSubspace allows to edit a subspace
	EditSubspace(context.Context, *MsgEditSubspace) (*MsgEditSubspaceResponse, error)
	// DeleteSubspace allows to delete a subspace
	DeleteSubspace(context.Context, *MsgDeleteSubspace) (*MsgDeleteSubspaceResponse, error)
	// CreateUserGroup allows to create a user group
	CreateUserGroup(context.Context, *MsgCreateUserGroup) (*MsgCreateUserGroupResponse, error)
	// EditUserGroup allows to edit a user group
	EditUserGroup(context.Context, *MsgEditUserGroup) (*MsgEditUserGroupResponse, error)
	// SetUserGroupPermissions allows to set the permissions for a specific group
	SetUserGroupPermissions(context.Context, *MsgSetUserGroupPermissions) (*MsgSetUserGroupPermissionsResponse, error)
	// DeleteUserGroup allows to delete an existing user group
	DeleteUserGroup(context.Context, *MsgDeleteUserGroup) (*MsgDeleteUserGroupResponse, error)
	// AddUserToUserGroup allows to add a specific user to a specific user group
	AddUserToUserGroup(context.Context, *MsgAddUserToUserGroup) (*MsgAddUserToUserGroupResponse, error)
	// RemoveUserFromUserGroup allows to remove a specific user from a specific
	// user group
	RemoveUserFromUserGroup(context.Context, *MsgRemoveUserFromUserGroup) (*MsgRemoveUserFromUserGroupResponse, error)
	// SetUserPermissions allows to set the permissions for a specific user
	SetUserPermissions(context.Context, *MsgSetUserPermissions) (*MsgSetUserPermissionsResponse, error)
}

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

func (*UnimplementedMsgServer) CreateSubspace(ctx context.Context, req *MsgCreateSubspace) (*MsgCreateSubspaceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSubspace not implemented")
}
func (*UnimplementedMsgServer) EditSubspace(ctx context.Context, req *MsgEditSubspace) (*MsgEditSubspaceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EditSubspace not implemented")
}
func (*UnimplementedMsgServer) DeleteSubspace(ctx context.Context, req *MsgDeleteSubspace) (*MsgDeleteSubspaceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteSubspace not implemented")
}
func (*UnimplementedMsgServer) CreateUserGroup(ctx context.Context, req *MsgCreateUserGroup) (*MsgCreateUserGroupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateUserGroup not implemented")
}
func (*UnimplementedMsgServer) EditUserGroup(ctx context.Context, req *MsgEditUserGroup) (*MsgEditUserGroupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EditUserGroup not implemented")
}
func (*UnimplementedMsgServer) SetUserGroupPermissions(ctx context.Context, req *MsgSetUserGroupPermissions) (*MsgSetUserGroupPermissionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetUserGroupPermissions not implemented")
}
func (*UnimplementedMsgServer) DeleteUserGroup(ctx context.Context, req *MsgDeleteUserGroup) (*MsgDeleteUserGroupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteUserGroup not implemented")
}
func (*UnimplementedMsgServer) AddUserToUserGroup(ctx context.Context, req *MsgAddUserToUserGroup) (*MsgAddUserToUserGroupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddUserToUserGroup not implemented")
}
func (*UnimplementedMsgServer) RemoveUserFromUserGroup(ctx context.Context, req *MsgRemoveUserFromUserGroup) (*MsgRemoveUserFromUserGroupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveUserFromUserGroup not implemented")
}
func (*UnimplementedMsgServer) SetUserPermissions(ctx context.Context, req *MsgSetUserPermissions) (*MsgSetUserPermissionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetUserPermissions not implemented")
}

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

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

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

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

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

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

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

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

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

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

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

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "desmos.subspaces.v1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateSubspace",
			Handler:    _Msg_CreateSubspace_Handler,
		},
		{
			MethodName: "EditSubspace",
			Handler:    _Msg_EditSubspace_Handler,
		},
		{
			MethodName: "DeleteSubspace",
			Handler:    _Msg_DeleteSubspace_Handler,
		},
		{
			MethodName: "CreateUserGroup",
			Handler:    _Msg_CreateUserGroup_Handler,
		},
		{
			MethodName: "EditUserGroup",
			Handler:    _Msg_EditUserGroup_Handler,
		},
		{
			MethodName: "SetUserGroupPermissions",
			Handler:    _Msg_SetUserGroupPermissions_Handler,
		},
		{
			MethodName: "DeleteUserGroup",
			Handler:    _Msg_DeleteUserGroup_Handler,
		},
		{
			MethodName: "AddUserToUserGroup",
			Handler:    _Msg_AddUserToUserGroup_Handler,
		},
		{
			MethodName: "RemoveUserFromUserGroup",
			Handler:    _Msg_RemoveUserFromUserGroup_Handler,
		},
		{
			MethodName: "SetUserPermissions",
			Handler:    _Msg_SetUserPermissions_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "desmos/subspaces/v1/msgs.proto",
}

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

func (m *MsgCreateSubspace) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Treasury) > 0 {
		i -= len(m.Treasury)
		copy(dAtA[i:], m.Treasury)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Treasury)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgEditSubspace) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Signer) > 0 {
		i -= len(m.Signer)
		copy(dAtA[i:], m.Signer)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Signer)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Treasury) > 0 {
		i -= len(m.Treasury)
		copy(dAtA[i:], m.Treasury)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Treasury)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Name)))
		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 *MsgEditSubspaceResponse) 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 *MsgEditSubspaceResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *MsgDeleteSubspace) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Signer) > 0 {
		i -= len(m.Signer)
		copy(dAtA[i:], m.Signer)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Signer)))
		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 *MsgDeleteSubspaceResponse) 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 *MsgDeleteSubspaceResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *MsgCreateUserGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0x2a
	}
	if m.DefaultPermissions != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.DefaultPermissions))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Name)))
		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 *MsgCreateUserGroupResponse) 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 *MsgCreateUserGroupResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *MsgEditUserGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Signer) > 0 {
		i -= len(m.Signer)
		copy(dAtA[i:], m.Signer)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Signer)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if m.GroupID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.GroupID))
		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 *MsgEditUserGroupResponse) 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 *MsgEditUserGroupResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *MsgSetUserGroupPermissions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Signer) > 0 {
		i -= len(m.Signer)
		copy(dAtA[i:], m.Signer)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Signer)))
		i--
		dAtA[i] = 0x22
	}
	if m.Permissions != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.Permissions))
		i--
		dAtA[i] = 0x18
	}
	if m.GroupID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.GroupID))
		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 *MsgSetUserGroupPermissionsResponse) 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 *MsgSetUserGroupPermissionsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *MsgDeleteUserGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Signer) > 0 {
		i -= len(m.Signer)
		copy(dAtA[i:], m.Signer)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Signer)))
		i--
		dAtA[i] = 0x1a
	}
	if m.GroupID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.GroupID))
		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 *MsgDeleteUserGroupResponse) 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 *MsgDeleteUserGroupResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *MsgAddUserToUserGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Signer) > 0 {
		i -= len(m.Signer)
		copy(dAtA[i:], m.Signer)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Signer)))
		i--
		dAtA[i] = 0x22
	}
	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.GroupID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.GroupID))
		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 *MsgAddUserToUserGroupResponse) 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 *MsgAddUserToUserGroupResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *MsgRemoveUserFromUserGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Signer) > 0 {
		i -= len(m.Signer)
		copy(dAtA[i:], m.Signer)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Signer)))
		i--
		dAtA[i] = 0x22
	}
	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.GroupID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.GroupID))
		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 *MsgRemoveUserFromUserGroupResponse) 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 *MsgRemoveUserFromUserGroupResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *MsgSetUserPermissions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Signer) > 0 {
		i -= len(m.Signer)
		copy(dAtA[i:], m.Signer)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Signer)))
		i--
		dAtA[i] = 0x22
	}
	if m.Permissions != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.Permissions))
		i--
		dAtA[i] = 0x18
	}
	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] = 0x12
	}
	if m.SubspaceID != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.SubspaceID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgSetUserPermissionsResponse) 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 *MsgCreateSubspace) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Treasury)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

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

func (m *MsgEditSubspace) 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.Name)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Treasury)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

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

func (m *MsgDeleteSubspace) 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.Signer)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

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

func (m *MsgCreateUserGroup) 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.Name)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	if m.DefaultPermissions != 0 {
		n += 1 + sovMsgs(uint64(m.DefaultPermissions))
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

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

func (m *MsgEditUserGroup) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SubspaceID != 0 {
		n += 1 + sovMsgs(uint64(m.SubspaceID))
	}
	if m.GroupID != 0 {
		n += 1 + sovMsgs(uint64(m.GroupID))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

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

func (m *MsgSetUserGroupPermissions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SubspaceID != 0 {
		n += 1 + sovMsgs(uint64(m.SubspaceID))
	}
	if m.GroupID != 0 {
		n += 1 + sovMsgs(uint64(m.GroupID))
	}
	if m.Permissions != 0 {
		n += 1 + sovMsgs(uint64(m.Permissions))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

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

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

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

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

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

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

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

func (m *MsgSetUserPermissions) 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.User)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	if m.Permissions != 0 {
		n += 1 + sovMsgs(uint64(m.Permissions))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

func (m *MsgSetUserPermissionsResponse) 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 *MsgCreateSubspace) 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: MsgCreateSubspace: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateSubspace: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", 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.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", 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.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Treasury", 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.Treasury = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", 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.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = 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 *MsgCreateSubspaceResponse) 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: MsgCreateSubspaceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateSubspaceResponse: 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
				}
			}
		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 *MsgEditSubspace) 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: MsgEditSubspace: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgEditSubspace: 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 Name", 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.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", 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.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Treasury", 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.Treasury = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", 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.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = 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 *MsgEditSubspaceResponse) 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: MsgEditSubspaceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgEditSubspaceResponse: 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 *MsgDeleteSubspace) 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: MsgDeleteSubspace: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeleteSubspace: 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 Signer", 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.Signer = 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 *MsgDeleteSubspaceResponse) 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: MsgDeleteSubspaceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeleteSubspaceResponse: 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 *MsgCreateUserGroup) 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: MsgCreateUserGroup: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateUserGroup: 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 Name", 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.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", 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.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultPermissions", wireType)
			}
			m.DefaultPermissions = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DefaultPermissions |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = 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 *MsgCreateUserGroupResponse) 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: MsgCreateUserGroupResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateUserGroupResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupID", wireType)
			}
			m.GroupID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupID |= 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 *MsgEditUserGroup) 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: MsgEditUserGroup: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgEditUserGroup: 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 GroupID", wireType)
			}
			m.GroupID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", 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.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", 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.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = 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 *MsgEditUserGroupResponse) 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: MsgEditUserGroupResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgEditUserGroupResponse: 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 *MsgSetUserGroupPermissions) 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: MsgSetUserGroupPermissions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSetUserGroupPermissions: 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 GroupID", wireType)
			}
			m.GroupID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Permissions", wireType)
			}
			m.Permissions = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Permissions |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = 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 *MsgSetUserGroupPermissionsResponse) 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: MsgSetUserGroupPermissionsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSetUserGroupPermissionsResponse: 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 *MsgDeleteUserGroup) 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: MsgDeleteUserGroup: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeleteUserGroup: 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 GroupID", wireType)
			}
			m.GroupID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = 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 *MsgDeleteUserGroupResponse) 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: MsgDeleteUserGroupResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeleteUserGroupResponse: 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 *MsgAddUserToUserGroup) 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: MsgAddUserToUserGroup: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddUserToUserGroup: 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 GroupID", wireType)
			}
			m.GroupID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupID |= 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
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = 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 *MsgAddUserToUserGroupResponse) 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: MsgAddUserToUserGroupResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddUserToUserGroupResponse: 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 *MsgRemoveUserFromUserGroup) 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: MsgRemoveUserFromUserGroup: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRemoveUserFromUserGroup: 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 GroupID", wireType)
			}
			m.GroupID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupID |= 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
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = 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 *MsgRemoveUserFromUserGroupResponse) 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: MsgRemoveUserFromUserGroupResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRemoveUserFromUserGroupResponse: 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 *MsgSetUserPermissions) 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: MsgSetUserPermissions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSetUserPermissions: 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 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
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Permissions", wireType)
			}
			m.Permissions = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Permissions |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = 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 *MsgSetUserPermissionsResponse) 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: MsgSetUserPermissionsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSetUserPermissionsResponse: 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")
)