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

package wg

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

type PeerStatusReq struct {
	NicName              string   `protobuf:"bytes,1,opt,name=nicName,proto3" json:"nicName,omitempty"`
	PublicKey            string   `protobuf:"bytes,2,opt,name=publicKey,proto3" json:"publicKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PeerStatusReq proto.InternalMessageInfo

func (m *PeerStatusReq) GetNicName() string {
	if m != nil {
		return m.NicName
	}
	return ""
}

func (m *PeerStatusReq) GetPublicKey() string {
	if m != nil {
		return m.PublicKey
	}
	return ""
}

type PeerStatusResp struct {
	// connected or not connected
	Status               bool     `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PeerStatusResp proto.InternalMessageInfo

func (m *PeerStatusResp) GetStatus() bool {
	if m != nil {
		return m.Status
	}
	return false
}

type AddPReq struct {
	Nic                  string   `protobuf:"bytes,1,opt,name=nic,proto3" json:"nic,omitempty"`
	AllowedIPs           string   `protobuf:"bytes,2,opt,name=allowedIPs,proto3" json:"allowedIPs,omitempty"`
	PublicKey            string   `protobuf:"bytes,3,opt,name=publicKey,proto3" json:"publicKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_AddPReq proto.InternalMessageInfo

func (m *AddPReq) GetNic() string {
	if m != nil {
		return m.Nic
	}
	return ""
}

func (m *AddPReq) GetAllowedIPs() string {
	if m != nil {
		return m.AllowedIPs
	}
	return ""
}

func (m *AddPReq) GetPublicKey() string {
	if m != nil {
		return m.PublicKey
	}
	return ""
}

type AddPResp struct {
	Message              string   `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_AddPResp proto.InternalMessageInfo

func (m *AddPResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type ListPeersReq struct {
	Nicname              string   `protobuf:"bytes,1,opt,name=nicname,proto3" json:"nicname,omitempty"`
	Error                string   `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ListPeersReq proto.InternalMessageInfo

func (m *ListPeersReq) GetNicname() string {
	if m != nil {
		return m.Nicname
	}
	return ""
}

func (m *ListPeersReq) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

type ListPeersResp struct {
	Response             string   `protobuf:"bytes,1,opt,name=response,proto3" json:"response,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ListPeersResp proto.InternalMessageInfo

func (m *ListPeersResp) GetResponse() string {
	if m != nil {
		return m.Response
	}
	return ""
}

type IReq struct {
	Address              string   `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	ListenPort           uint32   `protobuf:"varint,2,opt,name=listenPort,proto3" json:"listenPort,omitempty"`
	SaveConfig           bool     `protobuf:"varint,3,opt,name=saveConfig,proto3" json:"saveConfig,omitempty"`
	PrivateKey           string   `protobuf:"bytes,4,opt,name=privateKey,proto3" json:"privateKey,omitempty"`
	Eth                  string   `protobuf:"bytes,5,opt,name=eth,proto3" json:"eth,omitempty"`
	IName                string   `protobuf:"bytes,6,opt,name=iName,proto3" json:"iName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *IReq) Reset()         { *m = IReq{} }
func (m *IReq) String() string { return proto.CompactTextString(m) }
func (*IReq) ProtoMessage()    {}
func (*IReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_44e0f2c0b3aafb52, []int{6}
}

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

var xxx_messageInfo_IReq proto.InternalMessageInfo

func (m *IReq) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *IReq) GetListenPort() uint32 {
	if m != nil {
		return m.ListenPort
	}
	return 0
}

func (m *IReq) GetSaveConfig() bool {
	if m != nil {
		return m.SaveConfig
	}
	return false
}

func (m *IReq) GetPrivateKey() string {
	if m != nil {
		return m.PrivateKey
	}
	return ""
}

func (m *IReq) GetEth() string {
	if m != nil {
		return m.Eth
	}
	return ""
}

func (m *IReq) GetIName() string {
	if m != nil {
		return m.IName
	}
	return ""
}

type IResp struct {
	// message could be error or ordinary result depend on function result.
	Message              string   `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *IResp) Reset()         { *m = IResp{} }
func (m *IResp) String() string { return proto.CompactTextString(m) }
func (*IResp) ProtoMessage()    {}
func (*IResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_44e0f2c0b3aafb52, []int{7}
}

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

var xxx_messageInfo_IResp proto.InternalMessageInfo

func (m *IResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type DelPReq struct {
	PeerPublicKey        string   `protobuf:"bytes,1,opt,name=peerPublicKey,proto3" json:"peerPublicKey,omitempty"`
	IpAddress            string   `protobuf:"bytes,2,opt,name=ipAddress,proto3" json:"ipAddress,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DelPReq) Reset()         { *m = DelPReq{} }
func (m *DelPReq) String() string { return proto.CompactTextString(m) }
func (*DelPReq) ProtoMessage()    {}
func (*DelPReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_44e0f2c0b3aafb52, []int{8}
}

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

var xxx_messageInfo_DelPReq proto.InternalMessageInfo

func (m *DelPReq) GetPeerPublicKey() string {
	if m != nil {
		return m.PeerPublicKey
	}
	return ""
}

func (m *DelPReq) GetIpAddress() string {
	if m != nil {
		return m.IpAddress
	}
	return ""
}

type DelPResp struct {
	Message              string   `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DelPResp) Reset()         { *m = DelPResp{} }
func (m *DelPResp) String() string { return proto.CompactTextString(m) }
func (*DelPResp) ProtoMessage()    {}
func (*DelPResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_44e0f2c0b3aafb52, []int{9}
}

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

var xxx_messageInfo_DelPResp proto.InternalMessageInfo

func (m *DelPResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type ManageNICReq struct {
	//    manage NIC is responsible to up and down given interface
	Nic                  string   `protobuf:"bytes,1,opt,name=nic,proto3" json:"nic,omitempty"`
	Cmd                  string   `protobuf:"bytes,2,opt,name=cmd,proto3" json:"cmd,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ManageNICReq) Reset()         { *m = ManageNICReq{} }
func (m *ManageNICReq) String() string { return proto.CompactTextString(m) }
func (*ManageNICReq) ProtoMessage()    {}
func (*ManageNICReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_44e0f2c0b3aafb52, []int{10}
}

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

var xxx_messageInfo_ManageNICReq proto.InternalMessageInfo

func (m *ManageNICReq) GetNic() string {
	if m != nil {
		return m.Nic
	}
	return ""
}

func (m *ManageNICReq) GetCmd() string {
	if m != nil {
		return m.Cmd
	}
	return ""
}

type ManageNICResp struct {
	Message              string   `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ManageNICResp) Reset()         { *m = ManageNICResp{} }
func (m *ManageNICResp) String() string { return proto.CompactTextString(m) }
func (*ManageNICResp) ProtoMessage()    {}
func (*ManageNICResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_44e0f2c0b3aafb52, []int{11}
}

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

var xxx_messageInfo_ManageNICResp proto.InternalMessageInfo

func (m *ManageNICResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type NICInfoReq struct {
	Interface            string   `protobuf:"bytes,1,opt,name=interface,proto3" json:"interface,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NICInfoReq) Reset()         { *m = NICInfoReq{} }
func (m *NICInfoReq) String() string { return proto.CompactTextString(m) }
func (*NICInfoReq) ProtoMessage()    {}
func (*NICInfoReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_44e0f2c0b3aafb52, []int{12}
}

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

var xxx_messageInfo_NICInfoReq proto.InternalMessageInfo

func (m *NICInfoReq) GetInterface() string {
	if m != nil {
		return m.Interface
	}
	return ""
}

type NICInfoResp struct {
	Message              string   `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NICInfoResp) Reset()         { *m = NICInfoResp{} }
func (m *NICInfoResp) String() string { return proto.CompactTextString(m) }
func (*NICInfoResp) ProtoMessage()    {}
func (*NICInfoResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_44e0f2c0b3aafb52, []int{13}
}

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

var xxx_messageInfo_NICInfoResp proto.InternalMessageInfo

func (m *NICInfoResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type PubKeyReq struct {
	PubKeyName           string   `protobuf:"bytes,1,opt,name=pubKeyName,proto3" json:"pubKeyName,omitempty"`
	PrivKeyName          string   `protobuf:"bytes,2,opt,name=privKeyName,proto3" json:"privKeyName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PubKeyReq) Reset()         { *m = PubKeyReq{} }
func (m *PubKeyReq) String() string { return proto.CompactTextString(m) }
func (*PubKeyReq) ProtoMessage()    {}
func (*PubKeyReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_44e0f2c0b3aafb52, []int{14}
}

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

var xxx_messageInfo_PubKeyReq proto.InternalMessageInfo

func (m *PubKeyReq) GetPubKeyName() string {
	if m != nil {
		return m.PubKeyName
	}
	return ""
}

func (m *PubKeyReq) GetPrivKeyName() string {
	if m != nil {
		return m.PrivKeyName
	}
	return ""
}

type PubKeyResp struct {
	Message              string   `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PubKeyResp) Reset()         { *m = PubKeyResp{} }
func (m *PubKeyResp) String() string { return proto.CompactTextString(m) }
func (*PubKeyResp) ProtoMessage()    {}
func (*PubKeyResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_44e0f2c0b3aafb52, []int{15}
}

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

var xxx_messageInfo_PubKeyResp proto.InternalMessageInfo

func (m *PubKeyResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type PrivKeyReq struct {
	PrivateKeyName       string   `protobuf:"bytes,1,opt,name=privateKeyName,proto3" json:"privateKeyName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PrivKeyReq) Reset()         { *m = PrivKeyReq{} }
func (m *PrivKeyReq) String() string { return proto.CompactTextString(m) }
func (*PrivKeyReq) ProtoMessage()    {}
func (*PrivKeyReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_44e0f2c0b3aafb52, []int{16}
}

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

var xxx_messageInfo_PrivKeyReq proto.InternalMessageInfo

func (m *PrivKeyReq) GetPrivateKeyName() string {
	if m != nil {
		return m.PrivateKeyName
	}
	return ""
}

type PrivKeyResp struct {
	Message              string   `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PrivKeyResp) Reset()         { *m = PrivKeyResp{} }
func (m *PrivKeyResp) String() string { return proto.CompactTextString(m) }
func (*PrivKeyResp) ProtoMessage()    {}
func (*PrivKeyResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_44e0f2c0b3aafb52, []int{17}
}

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

var xxx_messageInfo_PrivKeyResp proto.InternalMessageInfo

func (m *PrivKeyResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func init() {
	proto.RegisterType((*PeerStatusReq)(nil), "PeerStatusReq")
	proto.RegisterType((*PeerStatusResp)(nil), "PeerStatusResp")
	proto.RegisterType((*AddPReq)(nil), "AddPReq")
	proto.RegisterType((*AddPResp)(nil), "AddPResp")
	proto.RegisterType((*ListPeersReq)(nil), "ListPeersReq")
	proto.RegisterType((*ListPeersResp)(nil), "ListPeersResp")
	proto.RegisterType((*IReq)(nil), "IReq")
	proto.RegisterType((*IResp)(nil), "IResp")
	proto.RegisterType((*DelPReq)(nil), "DelPReq")
	proto.RegisterType((*DelPResp)(nil), "DelPResp")
	proto.RegisterType((*ManageNICReq)(nil), "ManageNICReq")
	proto.RegisterType((*ManageNICResp)(nil), "ManageNICResp")
	proto.RegisterType((*NICInfoReq)(nil), "NICInfoReq")
	proto.RegisterType((*NICInfoResp)(nil), "NICInfoResp")
	proto.RegisterType((*PubKeyReq)(nil), "PubKeyReq")
	proto.RegisterType((*PubKeyResp)(nil), "PubKeyResp")
	proto.RegisterType((*PrivKeyReq)(nil), "PrivKeyReq")
	proto.RegisterType((*PrivKeyResp)(nil), "PrivKeyResp")
}

func init() { proto.RegisterFile("wg.proto", fileDescriptor_44e0f2c0b3aafb52) }

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

// WireguardClient is the client API for Wireguard service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type WireguardClient interface {
	InitializeI(ctx context.Context, in *IReq, opts ...grpc.CallOption) (*IResp, error)
	AddPeer(ctx context.Context, in *AddPReq, opts ...grpc.CallOption) (*AddPResp, error)
	DelPeer(ctx context.Context, in *DelPReq, opts ...grpc.CallOption) (*DelPResp, error)
	ListPeers(ctx context.Context, in *ListPeersReq, opts ...grpc.CallOption) (*ListPeersResp, error)
	ManageNIC(ctx context.Context, in *ManageNICReq, opts ...grpc.CallOption) (*ManageNICResp, error)
	GetPeerStatus(ctx context.Context, in *PeerStatusReq, opts ...grpc.CallOption) (*PeerStatusResp, error)
	GetNICInfo(ctx context.Context, in *NICInfoReq, opts ...grpc.CallOption) (*NICInfoResp, error)
	GenPublicKey(ctx context.Context, in *PubKeyReq, opts ...grpc.CallOption) (*PubKeyResp, error)
	GenPrivateKey(ctx context.Context, in *PrivKeyReq, opts ...grpc.CallOption) (*PrivKeyResp, error)
	GetPrivateKey(ctx context.Context, in *PrivKeyReq, opts ...grpc.CallOption) (*PrivKeyResp, error)
	GetPublicKey(ctx context.Context, in *PubKeyReq, opts ...grpc.CallOption) (*PubKeyResp, error)
}

type wireguardClient struct {
	cc *grpc.ClientConn
}

func NewWireguardClient(cc *grpc.ClientConn) WireguardClient {
	return &wireguardClient{cc}
}

func (c *wireguardClient) InitializeI(ctx context.Context, in *IReq, opts ...grpc.CallOption) (*IResp, error) {
	out := new(IResp)
	err := c.cc.Invoke(ctx, "/Wireguard/InitializeI", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *wireguardClient) AddPeer(ctx context.Context, in *AddPReq, opts ...grpc.CallOption) (*AddPResp, error) {
	out := new(AddPResp)
	err := c.cc.Invoke(ctx, "/Wireguard/AddPeer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *wireguardClient) DelPeer(ctx context.Context, in *DelPReq, opts ...grpc.CallOption) (*DelPResp, error) {
	out := new(DelPResp)
	err := c.cc.Invoke(ctx, "/Wireguard/DelPeer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *wireguardClient) ListPeers(ctx context.Context, in *ListPeersReq, opts ...grpc.CallOption) (*ListPeersResp, error) {
	out := new(ListPeersResp)
	err := c.cc.Invoke(ctx, "/Wireguard/ListPeers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *wireguardClient) ManageNIC(ctx context.Context, in *ManageNICReq, opts ...grpc.CallOption) (*ManageNICResp, error) {
	out := new(ManageNICResp)
	err := c.cc.Invoke(ctx, "/Wireguard/ManageNIC", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *wireguardClient) GetPeerStatus(ctx context.Context, in *PeerStatusReq, opts ...grpc.CallOption) (*PeerStatusResp, error) {
	out := new(PeerStatusResp)
	err := c.cc.Invoke(ctx, "/Wireguard/GetPeerStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *wireguardClient) GetNICInfo(ctx context.Context, in *NICInfoReq, opts ...grpc.CallOption) (*NICInfoResp, error) {
	out := new(NICInfoResp)
	err := c.cc.Invoke(ctx, "/Wireguard/GetNICInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *wireguardClient) GenPublicKey(ctx context.Context, in *PubKeyReq, opts ...grpc.CallOption) (*PubKeyResp, error) {
	out := new(PubKeyResp)
	err := c.cc.Invoke(ctx, "/Wireguard/GenPublicKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *wireguardClient) GenPrivateKey(ctx context.Context, in *PrivKeyReq, opts ...grpc.CallOption) (*PrivKeyResp, error) {
	out := new(PrivKeyResp)
	err := c.cc.Invoke(ctx, "/Wireguard/GenPrivateKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *wireguardClient) GetPrivateKey(ctx context.Context, in *PrivKeyReq, opts ...grpc.CallOption) (*PrivKeyResp, error) {
	out := new(PrivKeyResp)
	err := c.cc.Invoke(ctx, "/Wireguard/GetPrivateKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *wireguardClient) GetPublicKey(ctx context.Context, in *PubKeyReq, opts ...grpc.CallOption) (*PubKeyResp, error) {
	out := new(PubKeyResp)
	err := c.cc.Invoke(ctx, "/Wireguard/GetPublicKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// WireguardServer is the server API for Wireguard service.
type WireguardServer interface {
	InitializeI(context.Context, *IReq) (*IResp, error)
	AddPeer(context.Context, *AddPReq) (*AddPResp, error)
	DelPeer(context.Context, *DelPReq) (*DelPResp, error)
	ListPeers(context.Context, *ListPeersReq) (*ListPeersResp, error)
	ManageNIC(context.Context, *ManageNICReq) (*ManageNICResp, error)
	GetPeerStatus(context.Context, *PeerStatusReq) (*PeerStatusResp, error)
	GetNICInfo(context.Context, *NICInfoReq) (*NICInfoResp, error)
	GenPublicKey(context.Context, *PubKeyReq) (*PubKeyResp, error)
	GenPrivateKey(context.Context, *PrivKeyReq) (*PrivKeyResp, error)
	GetPrivateKey(context.Context, *PrivKeyReq) (*PrivKeyResp, error)
	GetPublicKey(context.Context, *PubKeyReq) (*PubKeyResp, error)
}

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

func (*UnimplementedWireguardServer) InitializeI(ctx context.Context, req *IReq) (*IResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InitializeI not implemented")
}
func (*UnimplementedWireguardServer) AddPeer(ctx context.Context, req *AddPReq) (*AddPResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddPeer not implemented")
}
func (*UnimplementedWireguardServer) DelPeer(ctx context.Context, req *DelPReq) (*DelPResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DelPeer not implemented")
}
func (*UnimplementedWireguardServer) ListPeers(ctx context.Context, req *ListPeersReq) (*ListPeersResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPeers not implemented")
}
func (*UnimplementedWireguardServer) ManageNIC(ctx context.Context, req *ManageNICReq) (*ManageNICResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ManageNIC not implemented")
}
func (*UnimplementedWireguardServer) GetPeerStatus(ctx context.Context, req *PeerStatusReq) (*PeerStatusResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPeerStatus not implemented")
}
func (*UnimplementedWireguardServer) GetNICInfo(ctx context.Context, req *NICInfoReq) (*NICInfoResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetNICInfo not implemented")
}
func (*UnimplementedWireguardServer) GenPublicKey(ctx context.Context, req *PubKeyReq) (*PubKeyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenPublicKey not implemented")
}
func (*UnimplementedWireguardServer) GenPrivateKey(ctx context.Context, req *PrivKeyReq) (*PrivKeyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenPrivateKey not implemented")
}
func (*UnimplementedWireguardServer) GetPrivateKey(ctx context.Context, req *PrivKeyReq) (*PrivKeyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrivateKey not implemented")
}
func (*UnimplementedWireguardServer) GetPublicKey(ctx context.Context, req *PubKeyReq) (*PubKeyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPublicKey not implemented")
}

func RegisterWireguardServer(s *grpc.Server, srv WireguardServer) {
	s.RegisterService(&_Wireguard_serviceDesc, srv)
}

func _Wireguard_InitializeI_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WireguardServer).InitializeI(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Wireguard/InitializeI",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WireguardServer).InitializeI(ctx, req.(*IReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Wireguard_AddPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddPReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WireguardServer).AddPeer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Wireguard/AddPeer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WireguardServer).AddPeer(ctx, req.(*AddPReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Wireguard_DelPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelPReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WireguardServer).DelPeer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Wireguard/DelPeer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WireguardServer).DelPeer(ctx, req.(*DelPReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Wireguard_ListPeers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListPeersReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WireguardServer).ListPeers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Wireguard/ListPeers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WireguardServer).ListPeers(ctx, req.(*ListPeersReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Wireguard_ManageNIC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ManageNICReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WireguardServer).ManageNIC(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Wireguard/ManageNIC",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WireguardServer).ManageNIC(ctx, req.(*ManageNICReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Wireguard_GetPeerStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PeerStatusReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WireguardServer).GetPeerStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Wireguard/GetPeerStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WireguardServer).GetPeerStatus(ctx, req.(*PeerStatusReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Wireguard_GetNICInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NICInfoReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WireguardServer).GetNICInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Wireguard/GetNICInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WireguardServer).GetNICInfo(ctx, req.(*NICInfoReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Wireguard_GenPublicKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PubKeyReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WireguardServer).GenPublicKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Wireguard/GenPublicKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WireguardServer).GenPublicKey(ctx, req.(*PubKeyReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Wireguard_GenPrivateKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PrivKeyReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WireguardServer).GenPrivateKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Wireguard/GenPrivateKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WireguardServer).GenPrivateKey(ctx, req.(*PrivKeyReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Wireguard_GetPrivateKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PrivKeyReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WireguardServer).GetPrivateKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Wireguard/GetPrivateKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WireguardServer).GetPrivateKey(ctx, req.(*PrivKeyReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Wireguard_GetPublicKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PubKeyReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WireguardServer).GetPublicKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/Wireguard/GetPublicKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WireguardServer).GetPublicKey(ctx, req.(*PubKeyReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _Wireguard_serviceDesc = grpc.ServiceDesc{
	ServiceName: "Wireguard",
	HandlerType: (*WireguardServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "InitializeI",
			Handler:    _Wireguard_InitializeI_Handler,
		},
		{
			MethodName: "AddPeer",
			Handler:    _Wireguard_AddPeer_Handler,
		},
		{
			MethodName: "DelPeer",
			Handler:    _Wireguard_DelPeer_Handler,
		},
		{
			MethodName: "ListPeers",
			Handler:    _Wireguard_ListPeers_Handler,
		},
		{
			MethodName: "ManageNIC",
			Handler:    _Wireguard_ManageNIC_Handler,
		},
		{
			MethodName: "GetPeerStatus",
			Handler:    _Wireguard_GetPeerStatus_Handler,
		},
		{
			MethodName: "GetNICInfo",
			Handler:    _Wireguard_GetNICInfo_Handler,
		},
		{
			MethodName: "GenPublicKey",
			Handler:    _Wireguard_GenPublicKey_Handler,
		},
		{
			MethodName: "GenPrivateKey",
			Handler:    _Wireguard_GenPrivateKey_Handler,
		},
		{
			MethodName: "GetPrivateKey",
			Handler:    _Wireguard_GetPrivateKey_Handler,
		},
		{
			MethodName: "GetPublicKey",
			Handler:    _Wireguard_GetPublicKey_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "wg.proto",
}
