cert.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: cert.proto

package types

import (
	fmt "fmt"
	math "math"

	proto "github.com/golang/protobuf/proto"
)

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

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

type Cert struct {
	CertId               []byte   `protobuf:"bytes,1,opt,name=certId,proto3" json:"certId,omitempty"`
	CreateTime           int64    `protobuf:"varint,2,opt,name=createTime,proto3" json:"createTime,omitempty"`
	Key                  string   `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
	Value                []byte   `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Cert) Reset()         { *m = Cert{} }
func (m *Cert) String() string { return proto.CompactTextString(m) }
func (*Cert) ProtoMessage()    {}
func (*Cert) Descriptor() ([]byte, []int) {
	return fileDescriptor_a142e29cbef9b1cf, []int{0}
}

func (m *Cert) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Cert.Unmarshal(m, b)
}
func (m *Cert) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Cert.Marshal(b, m, deterministic)
}
func (m *Cert) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cert.Merge(m, src)
}
func (m *Cert) XXX_Size() int {
	return xxx_messageInfo_Cert.Size(m)
}
func (m *Cert) XXX_DiscardUnknown() {
	xxx_messageInfo_Cert.DiscardUnknown(m)
}

var xxx_messageInfo_Cert proto.InternalMessageInfo

func (m *Cert) GetCertId() []byte {
	if m != nil {
		return m.CertId
	}
	return nil
}

func (m *Cert) GetCreateTime() int64 {
	if m != nil {
		return m.CreateTime
	}
	return 0
}

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

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

type CertAction struct {
	// Types that are valid to be assigned to Value:
	//	*CertAction_New
	//	*CertAction_Update
	//	*CertAction_Normal
	Value                isCertAction_Value `protobuf_oneof:"value"`
	Ty                   int32              `protobuf:"varint,4,opt,name=ty,proto3" json:"ty,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *CertAction) Reset()         { *m = CertAction{} }
func (m *CertAction) String() string { return proto.CompactTextString(m) }
func (*CertAction) ProtoMessage()    {}
func (*CertAction) Descriptor() ([]byte, []int) {
	return fileDescriptor_a142e29cbef9b1cf, []int{1}
}

func (m *CertAction) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CertAction.Unmarshal(m, b)
}
func (m *CertAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CertAction.Marshal(b, m, deterministic)
}
func (m *CertAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CertAction.Merge(m, src)
}
func (m *CertAction) XXX_Size() int {
	return xxx_messageInfo_CertAction.Size(m)
}
func (m *CertAction) XXX_DiscardUnknown() {
	xxx_messageInfo_CertAction.DiscardUnknown(m)
}

var xxx_messageInfo_CertAction proto.InternalMessageInfo

type isCertAction_Value interface {
	isCertAction_Value()
}

type CertAction_New struct {
	New *CertNew `protobuf:"bytes,1,opt,name=new,proto3,oneof"`
}

type CertAction_Update struct {
	Update *CertUpdate `protobuf:"bytes,2,opt,name=update,proto3,oneof"`
}

type CertAction_Normal struct {
	Normal *CertNormal `protobuf:"bytes,3,opt,name=normal,proto3,oneof"`
}

func (*CertAction_New) isCertAction_Value() {}

func (*CertAction_Update) isCertAction_Value() {}

func (*CertAction_Normal) isCertAction_Value() {}

func (m *CertAction) GetValue() isCertAction_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *CertAction) GetNew() *CertNew {
	if x, ok := m.GetValue().(*CertAction_New); ok {
		return x.New
	}
	return nil
}

func (m *CertAction) GetUpdate() *CertUpdate {
	if x, ok := m.GetValue().(*CertAction_Update); ok {
		return x.Update
	}
	return nil
}

func (m *CertAction) GetNormal() *CertNormal {
	if x, ok := m.GetValue().(*CertAction_Normal); ok {
		return x.Normal
	}
	return nil
}

func (m *CertAction) GetTy() int32 {
	if m != nil {
		return m.Ty
	}
	return 0
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*CertAction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _CertAction_OneofMarshaler, _CertAction_OneofUnmarshaler, _CertAction_OneofSizer, []interface{}{
		(*CertAction_New)(nil),
		(*CertAction_Update)(nil),
		(*CertAction_Normal)(nil),
	}
}

func _CertAction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*CertAction)
	// value
	switch x := m.Value.(type) {
	case *CertAction_New:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.New); err != nil {
			return err
		}
	case *CertAction_Update:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Update); err != nil {
			return err
		}
	case *CertAction_Normal:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Normal); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("CertAction.Value has unexpected type %T", x)
	}
	return nil
}

func _CertAction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*CertAction)
	switch tag {
	case 1: // value.new
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CertNew)
		err := b.DecodeMessage(msg)
		m.Value = &CertAction_New{msg}
		return true, err
	case 2: // value.update
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CertUpdate)
		err := b.DecodeMessage(msg)
		m.Value = &CertAction_Update{msg}
		return true, err
	case 3: // value.normal
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CertNormal)
		err := b.DecodeMessage(msg)
		m.Value = &CertAction_Normal{msg}
		return true, err
	default:
		return false, nil
	}
}

func _CertAction_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*CertAction)
	// value
	switch x := m.Value.(type) {
	case *CertAction_New:
		s := proto.Size(x.New)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *CertAction_Update:
		s := proto.Size(x.Update)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *CertAction_Normal:
		s := proto.Size(x.Normal)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type CertNew struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value                []byte   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CertNew) Reset()         { *m = CertNew{} }
func (m *CertNew) String() string { return proto.CompactTextString(m) }
func (*CertNew) ProtoMessage()    {}
func (*CertNew) Descriptor() ([]byte, []int) {
	return fileDescriptor_a142e29cbef9b1cf, []int{2}
}

func (m *CertNew) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CertNew.Unmarshal(m, b)
}
func (m *CertNew) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CertNew.Marshal(b, m, deterministic)
}
func (m *CertNew) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CertNew.Merge(m, src)
}
func (m *CertNew) XXX_Size() int {
	return xxx_messageInfo_CertNew.Size(m)
}
func (m *CertNew) XXX_DiscardUnknown() {
	xxx_messageInfo_CertNew.DiscardUnknown(m)
}

var xxx_messageInfo_CertNew proto.InternalMessageInfo

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

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

type CertUpdate struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value                []byte   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CertUpdate) Reset()         { *m = CertUpdate{} }
func (m *CertUpdate) String() string { return proto.CompactTextString(m) }
func (*CertUpdate) ProtoMessage()    {}
func (*CertUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_a142e29cbef9b1cf, []int{3}
}

func (m *CertUpdate) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CertUpdate.Unmarshal(m, b)
}
func (m *CertUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CertUpdate.Marshal(b, m, deterministic)
}
func (m *CertUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CertUpdate.Merge(m, src)
}
func (m *CertUpdate) XXX_Size() int {
	return xxx_messageInfo_CertUpdate.Size(m)
}
func (m *CertUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_CertUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_CertUpdate proto.InternalMessageInfo

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

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

type CertNormal struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value                []byte   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CertNormal) Reset()         { *m = CertNormal{} }
func (m *CertNormal) String() string { return proto.CompactTextString(m) }
func (*CertNormal) ProtoMessage()    {}
func (*CertNormal) Descriptor() ([]byte, []int) {
	return fileDescriptor_a142e29cbef9b1cf, []int{4}
}

func (m *CertNormal) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CertNormal.Unmarshal(m, b)
}
func (m *CertNormal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CertNormal.Marshal(b, m, deterministic)
}
func (m *CertNormal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CertNormal.Merge(m, src)
}
func (m *CertNormal) XXX_Size() int {
	return xxx_messageInfo_CertNormal.Size(m)
}
func (m *CertNormal) XXX_DiscardUnknown() {
	xxx_messageInfo_CertNormal.DiscardUnknown(m)
}

var xxx_messageInfo_CertNormal proto.InternalMessageInfo

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

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

type Authority struct {
	Enable               bool     `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"`
	CryptoPath           string   `protobuf:"bytes,2,opt,name=cryptoPath,proto3" json:"cryptoPath,omitempty"`
	SignType             string   `protobuf:"bytes,3,opt,name=signType,proto3" json:"signType,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Authority) Reset()         { *m = Authority{} }
func (m *Authority) String() string { return proto.CompactTextString(m) }
func (*Authority) ProtoMessage()    {}
func (*Authority) Descriptor() ([]byte, []int) {
	return fileDescriptor_a142e29cbef9b1cf, []int{5}
}

func (m *Authority) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Authority.Unmarshal(m, b)
}
func (m *Authority) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Authority.Marshal(b, m, deterministic)
}
func (m *Authority) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Authority.Merge(m, src)
}
func (m *Authority) XXX_Size() int {
	return xxx_messageInfo_Authority.Size(m)
}
func (m *Authority) XXX_DiscardUnknown() {
	xxx_messageInfo_Authority.DiscardUnknown(m)
}

var xxx_messageInfo_Authority proto.InternalMessageInfo

func (m *Authority) GetEnable() bool {
	if m != nil {
		return m.Enable
	}
	return false
}

func (m *Authority) GetCryptoPath() string {
	if m != nil {
		return m.CryptoPath
	}
	return ""
}

func (m *Authority) GetSignType() string {
	if m != nil {
		return m.SignType
	}
	return ""
}

func init() {
	proto.RegisterType((*Cert)(nil), "types.Cert")
	proto.RegisterType((*CertAction)(nil), "types.CertAction")
	proto.RegisterType((*CertNew)(nil), "types.CertNew")
	proto.RegisterType((*CertUpdate)(nil), "types.CertUpdate")
	proto.RegisterType((*CertNormal)(nil), "types.CertNormal")
	proto.RegisterType((*Authority)(nil), "types.Authority")
}

func init() { proto.RegisterFile("cert.proto", fileDescriptor_a142e29cbef9b1cf) }

var fileDescriptor_a142e29cbef9b1cf = []byte{
	// 300 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x52, 0xcd, 0x4a, 0xf3, 0x40,
	0x14, 0xed, 0x24, 0xfd, 0xbd, 0xfd, 0x28, 0x9f, 0x83, 0x48, 0x70, 0x21, 0x25, 0xab, 0x82, 0x10,
	0xb0, 0xfa, 0x02, 0xd5, 0x4d, 0xdd, 0x14, 0x19, 0xea, 0x5a, 0xa6, 0xe9, 0xd5, 0x06, 0xd3, 0x4c,
	0x98, 0xde, 0x58, 0xe6, 0x79, 0x7c, 0x51, 0x99, 0x1f, 0x25, 0x82, 0x0b, 0xdd, 0xe5, 0xdc, 0x73,
	0x4e, 0xee, 0x39, 0xdc, 0x01, 0xc8, 0x51, 0x53, 0x56, 0x6b, 0x45, 0x8a, 0xf7, 0xc8, 0xd4, 0x78,
	0x48, 0x9f, 0xa1, 0x7b, 0x87, 0x9a, 0xf8, 0x19, 0xf4, 0x2d, 0x79, 0xbf, 0x4d, 0xd8, 0x94, 0xcd,
	0xfe, 0x89, 0x80, 0xf8, 0x05, 0x40, 0xae, 0x51, 0x12, 0xae, 0x8b, 0x3d, 0x26, 0xd1, 0x94, 0xcd,
	0x62, 0xd1, 0x9a, 0xf0, 0xff, 0x10, 0xbf, 0xa2, 0x49, 0xe2, 0x29, 0x9b, 0x8d, 0x84, 0xfd, 0xe4,
	0xa7, 0xd0, 0x7b, 0x93, 0x65, 0x83, 0x49, 0xd7, 0xfd, 0xc8, 0x83, 0xf4, 0x9d, 0x01, 0xd8, 0x45,
	0x8b, 0x9c, 0x0a, 0x55, 0xf1, 0x14, 0xe2, 0x0a, 0x8f, 0x6e, 0xd7, 0x78, 0x3e, 0xc9, 0x5c, 0x96,
	0xcc, 0xf2, 0x2b, 0x3c, 0x2e, 0x3b, 0xc2, 0x92, 0xfc, 0x12, 0xfa, 0x4d, 0xbd, 0x95, 0xe4, 0xd7,
	0x8e, 0xe7, 0x27, 0x2d, 0xd9, 0xa3, 0x23, 0x96, 0x1d, 0x11, 0x24, 0x56, 0x5c, 0x29, 0xbd, 0x97,
	0xa5, 0x8b, 0xf2, 0x5d, 0xbc, 0x72, 0x84, 0x15, 0x7b, 0x09, 0x9f, 0x40, 0x44, 0xc6, 0xe5, 0xeb,
	0x89, 0x88, 0xcc, 0xed, 0x20, 0x44, 0x4e, 0xaf, 0x60, 0x10, 0x42, 0x7c, 0x16, 0x63, 0x3f, 0x14,
	0x8b, 0xda, 0xc5, 0x6e, 0x7c, 0x2f, 0x1f, 0xe8, 0xaf, 0x2e, 0x9f, 0xec, 0xd7, 0xae, 0x27, 0x18,
	0x2d, 0x1a, 0xda, 0x29, 0x5d, 0x90, 0xb1, 0x17, 0xc3, 0x4a, 0x6e, 0x4a, 0x74, 0xbe, 0xa1, 0x08,
	0xc8, 0x5f, 0xcc, 0xd4, 0xa4, 0x1e, 0x24, 0xed, 0x9c, 0x7f, 0x24, 0x5a, 0x13, 0x7e, 0x0e, 0xc3,
	0x43, 0xf1, 0x52, 0xad, 0x4d, 0x8d, 0xe1, 0x6c, 0x5f, 0x78, 0xd3, 0x77, 0x6f, 0xe3, 0xfa, 0x23,
	0x00, 0x00, 0xff, 0xff, 0x1d, 0xbc, 0xa5, 0x33, 0x29, 0x02, 0x00, 0x00,
}