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

package pb

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	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 VPNProto int32

const (
	VPNProto_NOPREF VPNProto = 0
	VPNProto_UDP    VPNProto = 1
	VPNProto_TCP    VPNProto = 2
)

var VPNProto_name = map[int32]string{
	0: "NOPREF",
	1: "UDP",
	2: "TCP",
}

var VPNProto_value = map[string]int32{
	"NOPREF": 0,
	"UDP":    1,
	"TCP":    2,
}

func (x VPNProto) String() string {
	return proto.EnumName(VPNProto_name, int32(x))
}

func (VPNProto) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_75c5922f473942e1, []int{0}
}

type VPNLZOPref int32

const (
	VPNLZOPref_USE_LZO_NOPREF  VPNLZOPref = 0
	VPNLZOPref_USE_LZO_ENABLE  VPNLZOPref = 1
	VPNLZOPref_USE_LZO_DISABLE VPNLZOPref = 3
)

var VPNLZOPref_name = map[int32]string{
	0: "USE_LZO_NOPREF",
	1: "USE_LZO_ENABLE",
	3: "USE_LZO_DISABLE",
}

var VPNLZOPref_value = map[string]int32{
	"USE_LZO_NOPREF":  0,
	"USE_LZO_ENABLE":  1,
	"USE_LZO_DISABLE": 3,
}

func (x VPNLZOPref) String() string {
	return proto.EnumName(VPNLZOPref_name, int32(x))
}

func (VPNLZOPref) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_75c5922f473942e1, []int{1}
}

type VPNStatusRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_VPNStatusRequest proto.InternalMessageInfo

type VPNInitRequest struct {
	Hostname             string   `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	Port                 string   `protobuf:"bytes,2,opt,name=port,proto3" json:"port,omitempty"`
	ProtoPref            VPNProto `protobuf:"varint,3,opt,name=proto_pref,json=protoPref,proto3,enum=pb.VPNProto" json:"proto_pref,omitempty"`
	IpBlock              string   `protobuf:"bytes,4,opt,name=ip_block,json=ipBlock,proto3" json:"ip_block,omitempty"`
	Dns                  string   `protobuf:"bytes,5,opt,name=dns,proto3" json:"dns,omitempty"`
	KeepalivePeriod      string   `protobuf:"bytes,6,opt,name=keepalive_period,json=keepalivePeriod,proto3" json:"keepalive_period,omitempty"`
	KeepaliveTimeout     string   `protobuf:"bytes,7,opt,name=keepalive_timeout,json=keepaliveTimeout,proto3" json:"keepalive_timeout,omitempty"`
	UseLzo               bool     `protobuf:"varint,8,opt,name=use_lzo,json=useLzo,proto3" json:"use_lzo,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_VPNInitRequest proto.InternalMessageInfo

func (m *VPNInitRequest) GetHostname() string {
	if m != nil {
		return m.Hostname
	}
	return ""
}

func (m *VPNInitRequest) GetPort() string {
	if m != nil {
		return m.Port
	}
	return ""
}

func (m *VPNInitRequest) GetProtoPref() VPNProto {
	if m != nil {
		return m.ProtoPref
	}
	return VPNProto_NOPREF
}

func (m *VPNInitRequest) GetIpBlock() string {
	if m != nil {
		return m.IpBlock
	}
	return ""
}

func (m *VPNInitRequest) GetDns() string {
	if m != nil {
		return m.Dns
	}
	return ""
}

func (m *VPNInitRequest) GetKeepalivePeriod() string {
	if m != nil {
		return m.KeepalivePeriod
	}
	return ""
}

func (m *VPNInitRequest) GetKeepaliveTimeout() string {
	if m != nil {
		return m.KeepaliveTimeout
	}
	return ""
}

func (m *VPNInitRequest) GetUseLzo() bool {
	if m != nil {
		return m.UseLzo
	}
	return false
}

type VPNUpdateRequest struct {
	IpBlock              string     `protobuf:"bytes,1,opt,name=ip_block,json=ipBlock,proto3" json:"ip_block,omitempty"`
	Dns                  string     `protobuf:"bytes,2,opt,name=dns,proto3" json:"dns,omitempty"`
	LzoPref              VPNLZOPref `protobuf:"varint,3,opt,name=lzo_pref,json=lzoPref,proto3,enum=pb.VPNLZOPref" json:"lzo_pref,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

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

var xxx_messageInfo_VPNUpdateRequest proto.InternalMessageInfo

func (m *VPNUpdateRequest) GetIpBlock() string {
	if m != nil {
		return m.IpBlock
	}
	return ""
}

func (m *VPNUpdateRequest) GetDns() string {
	if m != nil {
		return m.Dns
	}
	return ""
}

func (m *VPNUpdateRequest) GetLzoPref() VPNLZOPref {
	if m != nil {
		return m.LzoPref
	}
	return VPNLZOPref_USE_LZO_NOPREF
}

type VPNRestartRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_VPNRestartRequest proto.InternalMessageInfo

type VPNStatusResponse struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	SerialNumber         string   `protobuf:"bytes,2,opt,name=serial_number,json=serialNumber,proto3" json:"serial_number,omitempty"`
	Hostname             string   `protobuf:"bytes,3,opt,name=hostname,proto3" json:"hostname,omitempty"`
	Port                 string   `protobuf:"bytes,4,opt,name=port,proto3" json:"port,omitempty"`
	Cert                 string   `protobuf:"bytes,5,opt,name=cert,proto3" json:"cert,omitempty"`
	CaCert               string   `protobuf:"bytes,6,opt,name=ca_cert,json=caCert,proto3" json:"ca_cert,omitempty"`
	Net                  string   `protobuf:"bytes,7,opt,name=net,proto3" json:"net,omitempty"`
	Mask                 string   `protobuf:"bytes,8,opt,name=mask,proto3" json:"mask,omitempty"`
	CreatedAt            string   `protobuf:"bytes,9,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	Proto                string   `protobuf:"bytes,10,opt,name=proto,proto3" json:"proto,omitempty"`
	Dns                  string   `protobuf:"bytes,11,opt,name=dns,proto3" json:"dns,omitempty"`
	ExpiresAt            string   `protobuf:"bytes,12,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"`
	CaExpiresAt          string   `protobuf:"bytes,13,opt,name=ca_expires_at,json=caExpiresAt,proto3" json:"ca_expires_at,omitempty"`
	UseLzo               bool     `protobuf:"varint,14,opt,name=use_lzo,json=useLzo,proto3" json:"use_lzo,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_VPNStatusResponse proto.InternalMessageInfo

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

func (m *VPNStatusResponse) GetSerialNumber() string {
	if m != nil {
		return m.SerialNumber
	}
	return ""
}

func (m *VPNStatusResponse) GetHostname() string {
	if m != nil {
		return m.Hostname
	}
	return ""
}

func (m *VPNStatusResponse) GetPort() string {
	if m != nil {
		return m.Port
	}
	return ""
}

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

func (m *VPNStatusResponse) GetCaCert() string {
	if m != nil {
		return m.CaCert
	}
	return ""
}

func (m *VPNStatusResponse) GetNet() string {
	if m != nil {
		return m.Net
	}
	return ""
}

func (m *VPNStatusResponse) GetMask() string {
	if m != nil {
		return m.Mask
	}
	return ""
}

func (m *VPNStatusResponse) GetCreatedAt() string {
	if m != nil {
		return m.CreatedAt
	}
	return ""
}

func (m *VPNStatusResponse) GetProto() string {
	if m != nil {
		return m.Proto
	}
	return ""
}

func (m *VPNStatusResponse) GetDns() string {
	if m != nil {
		return m.Dns
	}
	return ""
}

func (m *VPNStatusResponse) GetExpiresAt() string {
	if m != nil {
		return m.ExpiresAt
	}
	return ""
}

func (m *VPNStatusResponse) GetCaExpiresAt() string {
	if m != nil {
		return m.CaExpiresAt
	}
	return ""
}

func (m *VPNStatusResponse) GetUseLzo() bool {
	if m != nil {
		return m.UseLzo
	}
	return false
}

type VPNInitResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_VPNInitResponse proto.InternalMessageInfo

type VPNUpdateResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_VPNUpdateResponse proto.InternalMessageInfo

type VPNRestartResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_VPNRestartResponse proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("pb.VPNProto", VPNProto_name, VPNProto_value)
	proto.RegisterEnum("pb.VPNLZOPref", VPNLZOPref_name, VPNLZOPref_value)
	proto.RegisterType((*VPNStatusRequest)(nil), "pb.VPNStatusRequest")
	proto.RegisterType((*VPNInitRequest)(nil), "pb.VPNInitRequest")
	proto.RegisterType((*VPNUpdateRequest)(nil), "pb.VPNUpdateRequest")
	proto.RegisterType((*VPNRestartRequest)(nil), "pb.VPNRestartRequest")
	proto.RegisterType((*VPNStatusResponse)(nil), "pb.VPNStatusResponse")
	proto.RegisterType((*VPNInitResponse)(nil), "pb.VPNInitResponse")
	proto.RegisterType((*VPNUpdateResponse)(nil), "pb.VPNUpdateResponse")
	proto.RegisterType((*VPNRestartResponse)(nil), "pb.VPNRestartResponse")
}

func init() { proto.RegisterFile("vpn.proto", fileDescriptor_75c5922f473942e1) }

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

// VPNServiceClient is the client API for VPNService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type VPNServiceClient interface {
	Status(ctx context.Context, in *VPNStatusRequest, opts ...grpc.CallOption) (*VPNStatusResponse, error)
	Init(ctx context.Context, in *VPNInitRequest, opts ...grpc.CallOption) (*VPNInitResponse, error)
	Update(ctx context.Context, in *VPNUpdateRequest, opts ...grpc.CallOption) (*VPNUpdateResponse, error)
	Restart(ctx context.Context, in *VPNRestartRequest, opts ...grpc.CallOption) (*VPNRestartResponse, error)
}

type vPNServiceClient struct {
	cc *grpc.ClientConn
}

func NewVPNServiceClient(cc *grpc.ClientConn) VPNServiceClient {
	return &vPNServiceClient{cc}
}

func (c *vPNServiceClient) Status(ctx context.Context, in *VPNStatusRequest, opts ...grpc.CallOption) (*VPNStatusResponse, error) {
	out := new(VPNStatusResponse)
	err := c.cc.Invoke(ctx, "/pb.VPNService/Status", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vPNServiceClient) Init(ctx context.Context, in *VPNInitRequest, opts ...grpc.CallOption) (*VPNInitResponse, error) {
	out := new(VPNInitResponse)
	err := c.cc.Invoke(ctx, "/pb.VPNService/Init", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vPNServiceClient) Update(ctx context.Context, in *VPNUpdateRequest, opts ...grpc.CallOption) (*VPNUpdateResponse, error) {
	out := new(VPNUpdateResponse)
	err := c.cc.Invoke(ctx, "/pb.VPNService/Update", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vPNServiceClient) Restart(ctx context.Context, in *VPNRestartRequest, opts ...grpc.CallOption) (*VPNRestartResponse, error) {
	out := new(VPNRestartResponse)
	err := c.cc.Invoke(ctx, "/pb.VPNService/Restart", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// VPNServiceServer is the server API for VPNService service.
type VPNServiceServer interface {
	Status(context.Context, *VPNStatusRequest) (*VPNStatusResponse, error)
	Init(context.Context, *VPNInitRequest) (*VPNInitResponse, error)
	Update(context.Context, *VPNUpdateRequest) (*VPNUpdateResponse, error)
	Restart(context.Context, *VPNRestartRequest) (*VPNRestartResponse, error)
}

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

func (*UnimplementedVPNServiceServer) Status(ctx context.Context, req *VPNStatusRequest) (*VPNStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Status not implemented")
}
func (*UnimplementedVPNServiceServer) Init(ctx context.Context, req *VPNInitRequest) (*VPNInitResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Init not implemented")
}
func (*UnimplementedVPNServiceServer) Update(ctx context.Context, req *VPNUpdateRequest) (*VPNUpdateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Update not implemented")
}
func (*UnimplementedVPNServiceServer) Restart(ctx context.Context, req *VPNRestartRequest) (*VPNRestartResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Restart not implemented")
}

func RegisterVPNServiceServer(s *grpc.Server, srv VPNServiceServer) {
	s.RegisterService(&_VPNService_serviceDesc, srv)
}

func _VPNService_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VPNStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VPNServiceServer).Status(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.VPNService/Status",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VPNServiceServer).Status(ctx, req.(*VPNStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VPNService_Init_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VPNInitRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VPNServiceServer).Init(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.VPNService/Init",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VPNServiceServer).Init(ctx, req.(*VPNInitRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VPNService_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VPNUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VPNServiceServer).Update(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.VPNService/Update",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VPNServiceServer).Update(ctx, req.(*VPNUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VPNService_Restart_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VPNRestartRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VPNServiceServer).Restart(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.VPNService/Restart",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VPNServiceServer).Restart(ctx, req.(*VPNRestartRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _VPNService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "pb.VPNService",
	HandlerType: (*VPNServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Status",
			Handler:    _VPNService_Status_Handler,
		},
		{
			MethodName: "Init",
			Handler:    _VPNService_Init_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _VPNService_Update_Handler,
		},
		{
			MethodName: "Restart",
			Handler:    _VPNService_Restart_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "vpn.proto",
}