role.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: github.com/elojah/trax/internal/user/role.proto

package user

import (
	fmt "fmt"
	_ "github.com/elojah/trax/pkg/gogoproto"
	github_com_elojah_trax_pkg_ulid "github.com/elojah/trax/pkg/ulid"
	proto "github.com/gogo/protobuf/proto"
	golang_proto "github.com/golang/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = golang_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

type Resource int32

const (
	R_asset     Resource = 0
	R_entity    Resource = 1
	R_operation Resource = 2
	R_role      Resource = 3
	R_user      Resource = 4
)

var Resource_name = map[int32]string{
	0: "R_asset",
	1: "R_entity",
	2: "R_operation",
	3: "R_role",
	4: "R_user",
}

var Resource_value = map[string]int32{
	"R_asset":     0,
	"R_entity":    1,
	"R_operation": 2,
	"R_role":      3,
	"R_user":      4,
}

func (Resource) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ceafa32622959d52, []int{0}
}

type Command int32

const (
	C_read   Command = 0
	C_create Command = 1
	C_update Command = 2
	C_delete Command = 3
)

var Command_name = map[int32]string{
	0: "C_read",
	1: "C_create",
	2: "C_update",
	3: "C_delete",
}

var Command_value = map[string]int32{
	"C_read":   0,
	"C_create": 1,
	"C_update": 2,
	"C_delete": 3,
}

func (Command) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ceafa32622959d52, []int{1}
}

type Role struct {
	ID        github_com_elojah_trax_pkg_ulid.ID `protobuf:"bytes,1,opt,name=ID,proto3,customtype=github.com/elojah/trax/pkg/ulid.ID" json:"ID"`
	EntityID  github_com_elojah_trax_pkg_ulid.ID `protobuf:"bytes,2,opt,name=EntityID,proto3,customtype=github.com/elojah/trax/pkg/ulid.ID" json:"EntityID"`
	Name      string                             `protobuf:"bytes,3,opt,name=Name,proto3" json:"Name,omitempty"`
	CreatedAt int64                              `protobuf:"varint,4,opt,name=CreatedAt,proto3" json:"CreatedAt,omitempty"`
	UpdatedAt int64                              `protobuf:"varint,5,opt,name=UpdatedAt,proto3" json:"UpdatedAt,omitempty"`
}

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

var xxx_messageInfo_Role proto.InternalMessageInfo

type Permission struct {
	RoleID    github_com_elojah_trax_pkg_ulid.ID `protobuf:"bytes,1,opt,name=RoleID,proto3,customtype=github.com/elojah/trax/pkg/ulid.ID" json:"RoleID"`
	Resource  Resource                           `protobuf:"varint,2,opt,name=Resource,proto3,enum=user.Resource" json:"Resource,omitempty"`
	Command   Command                            `protobuf:"varint,3,opt,name=Command,proto3,enum=user.Command" json:"Command,omitempty"`
	CreatedAt int64                              `protobuf:"varint,4,opt,name=CreatedAt,proto3" json:"CreatedAt,omitempty"`
	UpdatedAt int64                              `protobuf:"varint,5,opt,name=UpdatedAt,proto3" json:"UpdatedAt,omitempty"`
}

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

var xxx_messageInfo_Permission proto.InternalMessageInfo

type RoleUser struct {
	RoleID    github_com_elojah_trax_pkg_ulid.ID `protobuf:"bytes,1,opt,name=RoleID,proto3,customtype=github.com/elojah/trax/pkg/ulid.ID" json:"RoleID"`
	UserID    github_com_elojah_trax_pkg_ulid.ID `protobuf:"bytes,2,opt,name=UserID,proto3,customtype=github.com/elojah/trax/pkg/ulid.ID" json:"UserID"`
	CreatedAt int64                              `protobuf:"varint,3,opt,name=CreatedAt,proto3" json:"CreatedAt,omitempty"`
	UpdatedAt int64                              `protobuf:"varint,4,opt,name=UpdatedAt,proto3" json:"UpdatedAt,omitempty"`
}

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

var xxx_messageInfo_RoleUser proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("user.Resource", Resource_name, Resource_value)
	golang_proto.RegisterEnum("user.Resource", Resource_name, Resource_value)
	proto.RegisterEnum("user.Command", Command_name, Command_value)
	golang_proto.RegisterEnum("user.Command", Command_name, Command_value)
	proto.RegisterType((*Role)(nil), "user.Role")
	golang_proto.RegisterType((*Role)(nil), "user.Role")
	proto.RegisterType((*Permission)(nil), "user.Permission")
	golang_proto.RegisterType((*Permission)(nil), "user.Permission")
	proto.RegisterType((*RoleUser)(nil), "user.RoleUser")
	golang_proto.RegisterType((*RoleUser)(nil), "user.RoleUser")
}

func init() {
	proto.RegisterFile("github.com/elojah/trax/internal/user/role.proto", fileDescriptor_ceafa32622959d52)
}
func init() {
	golang_proto.RegisterFile("github.com/elojah/trax/internal/user/role.proto", fileDescriptor_ceafa32622959d52)
}

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

func (x Resource) String() string {
	s, ok := Resource_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x Command) String() string {
	s, ok := Command_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *Role) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Role)
	if !ok {
		that2, ok := that.(Role)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ID.Equal(that1.ID) {
		return false
	}
	if !this.EntityID.Equal(that1.EntityID) {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.CreatedAt != that1.CreatedAt {
		return false
	}
	if this.UpdatedAt != that1.UpdatedAt {
		return false
	}
	return true
}
func (this *Permission) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Permission)
	if !ok {
		that2, ok := that.(Permission)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.RoleID.Equal(that1.RoleID) {
		return false
	}
	if this.Resource != that1.Resource {
		return false
	}
	if this.Command != that1.Command {
		return false
	}
	if this.CreatedAt != that1.CreatedAt {
		return false
	}
	if this.UpdatedAt != that1.UpdatedAt {
		return false
	}
	return true
}
func (this *RoleUser) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RoleUser)
	if !ok {
		that2, ok := that.(RoleUser)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.RoleID.Equal(that1.RoleID) {
		return false
	}
	if !this.UserID.Equal(that1.UserID) {
		return false
	}
	if this.CreatedAt != that1.CreatedAt {
		return false
	}
	if this.UpdatedAt != that1.UpdatedAt {
		return false
	}
	return true
}
func (this *Role) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&user.Role{")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	s = append(s, "EntityID: "+fmt.Sprintf("%#v", this.EntityID)+",\n")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "CreatedAt: "+fmt.Sprintf("%#v", this.CreatedAt)+",\n")
	s = append(s, "UpdatedAt: "+fmt.Sprintf("%#v", this.UpdatedAt)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Permission) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&user.Permission{")
	s = append(s, "RoleID: "+fmt.Sprintf("%#v", this.RoleID)+",\n")
	s = append(s, "Resource: "+fmt.Sprintf("%#v", this.Resource)+",\n")
	s = append(s, "Command: "+fmt.Sprintf("%#v", this.Command)+",\n")
	s = append(s, "CreatedAt: "+fmt.Sprintf("%#v", this.CreatedAt)+",\n")
	s = append(s, "UpdatedAt: "+fmt.Sprintf("%#v", this.UpdatedAt)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RoleUser) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&user.RoleUser{")
	s = append(s, "RoleID: "+fmt.Sprintf("%#v", this.RoleID)+",\n")
	s = append(s, "UserID: "+fmt.Sprintf("%#v", this.UserID)+",\n")
	s = append(s, "CreatedAt: "+fmt.Sprintf("%#v", this.CreatedAt)+",\n")
	s = append(s, "UpdatedAt: "+fmt.Sprintf("%#v", this.UpdatedAt)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringRole(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *Role) 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 *Role) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Role) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UpdatedAt != 0 {
		i = encodeVarintRole(dAtA, i, uint64(m.UpdatedAt))
		i--
		dAtA[i] = 0x28
	}
	if m.CreatedAt != 0 {
		i = encodeVarintRole(dAtA, i, uint64(m.CreatedAt))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRole(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size := m.EntityID.Size()
		i -= size
		if _, err := m.EntityID.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintRole(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.ID.Size()
		i -= size
		if _, err := m.ID.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintRole(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *Permission) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UpdatedAt != 0 {
		i = encodeVarintRole(dAtA, i, uint64(m.UpdatedAt))
		i--
		dAtA[i] = 0x28
	}
	if m.CreatedAt != 0 {
		i = encodeVarintRole(dAtA, i, uint64(m.CreatedAt))
		i--
		dAtA[i] = 0x20
	}
	if m.Command != 0 {
		i = encodeVarintRole(dAtA, i, uint64(m.Command))
		i--
		dAtA[i] = 0x18
	}
	if m.Resource != 0 {
		i = encodeVarintRole(dAtA, i, uint64(m.Resource))
		i--
		dAtA[i] = 0x10
	}
	{
		size := m.RoleID.Size()
		i -= size
		if _, err := m.RoleID.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintRole(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *RoleUser) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UpdatedAt != 0 {
		i = encodeVarintRole(dAtA, i, uint64(m.UpdatedAt))
		i--
		dAtA[i] = 0x20
	}
	if m.CreatedAt != 0 {
		i = encodeVarintRole(dAtA, i, uint64(m.CreatedAt))
		i--
		dAtA[i] = 0x18
	}
	{
		size := m.UserID.Size()
		i -= size
		if _, err := m.UserID.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintRole(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.RoleID.Size()
		i -= size
		if _, err := m.RoleID.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintRole(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func encodeVarintRole(dAtA []byte, offset int, v uint64) int {
	offset -= sovRole(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedRole(r randyRole, easy bool) *Role {
	this := &Role{}
	v1 := github_com_elojah_trax_pkg_ulid.NewPopulatedID(r)
	this.ID = *v1
	v2 := github_com_elojah_trax_pkg_ulid.NewPopulatedID(r)
	this.EntityID = *v2
	this.Name = string(randStringRole(r))
	this.CreatedAt = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.CreatedAt *= -1
	}
	this.UpdatedAt = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.UpdatedAt *= -1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPermission(r randyRole, easy bool) *Permission {
	this := &Permission{}
	v3 := github_com_elojah_trax_pkg_ulid.NewPopulatedID(r)
	this.RoleID = *v3
	this.Resource = Resource([]int32{0, 1, 2, 3, 4}[r.Intn(5)])
	this.Command = Command([]int32{0, 1, 2, 3}[r.Intn(4)])
	this.CreatedAt = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.CreatedAt *= -1
	}
	this.UpdatedAt = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.UpdatedAt *= -1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRoleUser(r randyRole, easy bool) *RoleUser {
	this := &RoleUser{}
	v4 := github_com_elojah_trax_pkg_ulid.NewPopulatedID(r)
	this.RoleID = *v4
	v5 := github_com_elojah_trax_pkg_ulid.NewPopulatedID(r)
	this.UserID = *v5
	this.CreatedAt = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.CreatedAt *= -1
	}
	this.UpdatedAt = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.UpdatedAt *= -1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

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

func randUTF8RuneRole(r randyRole) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringRole(r randyRole) string {
	v6 := r.Intn(100)
	tmps := make([]rune, v6)
	for i := 0; i < v6; i++ {
		tmps[i] = randUTF8RuneRole(r)
	}
	return string(tmps)
}
func randUnrecognizedRole(r randyRole, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldRole(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldRole(dAtA []byte, r randyRole, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateRole(dAtA, uint64(key))
		v7 := r.Int63()
		if r.Intn(2) == 0 {
			v7 *= -1
		}
		dAtA = encodeVarintPopulateRole(dAtA, uint64(v7))
	case 1:
		dAtA = encodeVarintPopulateRole(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateRole(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateRole(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateRole(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateRole(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *Role) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ID.Size()
	n += 1 + l + sovRole(uint64(l))
	l = m.EntityID.Size()
	n += 1 + l + sovRole(uint64(l))
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRole(uint64(l))
	}
	if m.CreatedAt != 0 {
		n += 1 + sovRole(uint64(m.CreatedAt))
	}
	if m.UpdatedAt != 0 {
		n += 1 + sovRole(uint64(m.UpdatedAt))
	}
	return n
}

func (m *Permission) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.RoleID.Size()
	n += 1 + l + sovRole(uint64(l))
	if m.Resource != 0 {
		n += 1 + sovRole(uint64(m.Resource))
	}
	if m.Command != 0 {
		n += 1 + sovRole(uint64(m.Command))
	}
	if m.CreatedAt != 0 {
		n += 1 + sovRole(uint64(m.CreatedAt))
	}
	if m.UpdatedAt != 0 {
		n += 1 + sovRole(uint64(m.UpdatedAt))
	}
	return n
}

func (m *RoleUser) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.RoleID.Size()
	n += 1 + l + sovRole(uint64(l))
	l = m.UserID.Size()
	n += 1 + l + sovRole(uint64(l))
	if m.CreatedAt != 0 {
		n += 1 + sovRole(uint64(m.CreatedAt))
	}
	if m.UpdatedAt != 0 {
		n += 1 + sovRole(uint64(m.UpdatedAt))
	}
	return n
}

func sovRole(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozRole(x uint64) (n int) {
	return sovRole(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Role) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Role{`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`EntityID:` + fmt.Sprintf("%v", this.EntityID) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`CreatedAt:` + fmt.Sprintf("%v", this.CreatedAt) + `,`,
		`UpdatedAt:` + fmt.Sprintf("%v", this.UpdatedAt) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Permission) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Permission{`,
		`RoleID:` + fmt.Sprintf("%v", this.RoleID) + `,`,
		`Resource:` + fmt.Sprintf("%v", this.Resource) + `,`,
		`Command:` + fmt.Sprintf("%v", this.Command) + `,`,
		`CreatedAt:` + fmt.Sprintf("%v", this.CreatedAt) + `,`,
		`UpdatedAt:` + fmt.Sprintf("%v", this.UpdatedAt) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RoleUser) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RoleUser{`,
		`RoleID:` + fmt.Sprintf("%v", this.RoleID) + `,`,
		`UserID:` + fmt.Sprintf("%v", this.UserID) + `,`,
		`CreatedAt:` + fmt.Sprintf("%v", this.CreatedAt) + `,`,
		`UpdatedAt:` + fmt.Sprintf("%v", this.UpdatedAt) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringRole(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Role) 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 ErrIntOverflowRole
			}
			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: Role: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Role: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRole
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRole
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRole
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntityID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRole
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRole
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRole
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.EntityID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		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 ErrIntOverflowRole
				}
				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 ErrInvalidLengthRole
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRole
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			m.CreatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRole
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
			}
			m.UpdatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRole
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpdatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRole(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRole
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRole
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Permission) 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 ErrIntOverflowRole
			}
			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: Permission: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Permission: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RoleID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRole
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRole
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRole
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RoleID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
			}
			m.Resource = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRole
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Resource |= Resource(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Command", wireType)
			}
			m.Command = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRole
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Command |= Command(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			m.CreatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRole
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
			}
			m.UpdatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRole
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpdatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRole(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRole
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRole
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RoleUser) 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 ErrIntOverflowRole
			}
			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: RoleUser: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RoleUser: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RoleID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRole
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRole
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRole
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RoleID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRole
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRole
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRole
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.UserID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			m.CreatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRole
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
			}
			m.UpdatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRole
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpdatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRole(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRole
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRole
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthRole        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRole          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupRole = fmt.Errorf("proto: unexpected end of group")
)