github.com/microsoft/moc@v0.17.1/rpc/cloudagent/storage/moc_cloudagent_virtualharddisk.pb.go

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

package storage

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	wrappers "github.com/golang/protobuf/ptypes/wrappers"
	common "github.com/microsoft/moc/rpc/common"
	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 VirtualHardDiskRequest struct {
	VirtualHardDisks     []*VirtualHardDisk `protobuf:"bytes,1,rep,name=VirtualHardDisks,proto3" json:"VirtualHardDisks,omitempty"`
	OperationType        common.Operation   `protobuf:"varint,2,opt,name=OperationType,proto3,enum=moc.Operation" json:"OperationType,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

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

var xxx_messageInfo_VirtualHardDiskRequest proto.InternalMessageInfo

func (m *VirtualHardDiskRequest) GetVirtualHardDisks() []*VirtualHardDisk {
	if m != nil {
		return m.VirtualHardDisks
	}
	return nil
}

func (m *VirtualHardDiskRequest) GetOperationType() common.Operation {
	if m != nil {
		return m.OperationType
	}
	return common.Operation_GET
}

type VirtualHardDiskResponse struct {
	VirtualHardDisks     []*VirtualHardDisk  `protobuf:"bytes,1,rep,name=VirtualHardDisks,proto3" json:"VirtualHardDisks,omitempty"`
	Result               *wrappers.BoolValue `protobuf:"bytes,2,opt,name=Result,proto3" json:"Result,omitempty"`
	Error                string              `protobuf:"bytes,3,opt,name=Error,proto3" json:"Error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_VirtualHardDiskResponse proto.InternalMessageInfo

func (m *VirtualHardDiskResponse) GetVirtualHardDisks() []*VirtualHardDisk {
	if m != nil {
		return m.VirtualHardDisks
	}
	return nil
}

func (m *VirtualHardDiskResponse) GetResult() *wrappers.BoolValue {
	if m != nil {
		return m.Result
	}
	return nil
}

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

type VirtualHardDisk struct {
	Name                       string                     `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Id                         string                     `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	ContainerName              string                     `protobuf:"bytes,3,opt,name=containerName,proto3" json:"containerName,omitempty"`
	Path                       string                     `protobuf:"bytes,4,opt,name=path,proto3" json:"path,omitempty"`
	Status                     *common.Status             `protobuf:"bytes,5,opt,name=status,proto3" json:"status,omitempty"`
	Size                       int64                      `protobuf:"varint,6,opt,name=size,proto3" json:"size,omitempty"`
	Dynamic                    bool                       `protobuf:"varint,7,opt,name=dynamic,proto3" json:"dynamic,omitempty"`
	Blocksizebytes             int32                      `protobuf:"varint,8,opt,name=blocksizebytes,proto3" json:"blocksizebytes,omitempty"`
	Logicalsectorbytes         int32                      `protobuf:"varint,9,opt,name=logicalsectorbytes,proto3" json:"logicalsectorbytes,omitempty"`
	Physicalsectorbytes        int32                      `protobuf:"varint,10,opt,name=physicalsectorbytes,proto3" json:"physicalsectorbytes,omitempty"`
	Controllernumber           int64                      `protobuf:"varint,11,opt,name=controllernumber,proto3" json:"controllernumber,omitempty"`
	Controllerlocation         int64                      `protobuf:"varint,12,opt,name=controllerlocation,proto3" json:"controllerlocation,omitempty"`
	Disknumber                 int64                      `protobuf:"varint,13,opt,name=disknumber,proto3" json:"disknumber,omitempty"`
	VirtualmachineName         string                     `protobuf:"bytes,14,opt,name=virtualmachineName,proto3" json:"virtualmachineName,omitempty"`
	Scsipath                   string                     `protobuf:"bytes,15,opt,name=scsipath,proto3" json:"scsipath,omitempty"`
	AttachedVirtualmachineName string                     `protobuf:"bytes,16,opt,name=attachedVirtualmachineName,proto3" json:"attachedVirtualmachineName,omitempty"`
	AttachedNodeName           string                     `protobuf:"bytes,17,opt,name=attachedNodeName,proto3" json:"attachedNodeName,omitempty"`
	GroupName                  string                     `protobuf:"bytes,18,opt,name=groupName,proto3" json:"groupName,omitempty"`
	LocationName               string                     `protobuf:"bytes,19,opt,name=locationName,proto3" json:"locationName,omitempty"`
	HyperVGeneration           common.HyperVGeneration    `protobuf:"varint,20,opt,name=hyperVGeneration,proto3,enum=moc.HyperVGeneration" json:"hyperVGeneration,omitempty"`
	DiskFileFormat             common.DiskFileFormat      `protobuf:"varint,21,opt,name=diskFileFormat,proto3,enum=moc.DiskFileFormat" json:"diskFileFormat,omitempty"`
	CloudInitDataSource        common.CloudInitDataSource `protobuf:"varint,22,opt,name=cloudInitDataSource,proto3,enum=moc.CloudInitDataSource" json:"cloudInitDataSource,omitempty"`
	Tags                       *common.Tags               `protobuf:"bytes,23,opt,name=tags,proto3" json:"tags,omitempty"`
	XXX_NoUnkeyedLiteral       struct{}                   `json:"-"`
	XXX_unrecognized           []byte                     `json:"-"`
	XXX_sizecache              int32                      `json:"-"`
}

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

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

var xxx_messageInfo_VirtualHardDisk proto.InternalMessageInfo

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

func (m *VirtualHardDisk) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *VirtualHardDisk) GetContainerName() string {
	if m != nil {
		return m.ContainerName
	}
	return ""
}

func (m *VirtualHardDisk) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *VirtualHardDisk) GetStatus() *common.Status {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *VirtualHardDisk) GetSize() int64 {
	if m != nil {
		return m.Size
	}
	return 0
}

func (m *VirtualHardDisk) GetDynamic() bool {
	if m != nil {
		return m.Dynamic
	}
	return false
}

func (m *VirtualHardDisk) GetBlocksizebytes() int32 {
	if m != nil {
		return m.Blocksizebytes
	}
	return 0
}

func (m *VirtualHardDisk) GetLogicalsectorbytes() int32 {
	if m != nil {
		return m.Logicalsectorbytes
	}
	return 0
}

func (m *VirtualHardDisk) GetPhysicalsectorbytes() int32 {
	if m != nil {
		return m.Physicalsectorbytes
	}
	return 0
}

func (m *VirtualHardDisk) GetControllernumber() int64 {
	if m != nil {
		return m.Controllernumber
	}
	return 0
}

func (m *VirtualHardDisk) GetControllerlocation() int64 {
	if m != nil {
		return m.Controllerlocation
	}
	return 0
}

func (m *VirtualHardDisk) GetDisknumber() int64 {
	if m != nil {
		return m.Disknumber
	}
	return 0
}

func (m *VirtualHardDisk) GetVirtualmachineName() string {
	if m != nil {
		return m.VirtualmachineName
	}
	return ""
}

func (m *VirtualHardDisk) GetScsipath() string {
	if m != nil {
		return m.Scsipath
	}
	return ""
}

func (m *VirtualHardDisk) GetAttachedVirtualmachineName() string {
	if m != nil {
		return m.AttachedVirtualmachineName
	}
	return ""
}

func (m *VirtualHardDisk) GetAttachedNodeName() string {
	if m != nil {
		return m.AttachedNodeName
	}
	return ""
}

func (m *VirtualHardDisk) GetGroupName() string {
	if m != nil {
		return m.GroupName
	}
	return ""
}

func (m *VirtualHardDisk) GetLocationName() string {
	if m != nil {
		return m.LocationName
	}
	return ""
}

func (m *VirtualHardDisk) GetHyperVGeneration() common.HyperVGeneration {
	if m != nil {
		return m.HyperVGeneration
	}
	return common.HyperVGeneration_HyperVGenerationV2
}

func (m *VirtualHardDisk) GetDiskFileFormat() common.DiskFileFormat {
	if m != nil {
		return m.DiskFileFormat
	}
	return common.DiskFileFormat_DiskFileFormatVHDX
}

func (m *VirtualHardDisk) GetCloudInitDataSource() common.CloudInitDataSource {
	if m != nil {
		return m.CloudInitDataSource
	}
	return common.CloudInitDataSource_NoCloud
}

func (m *VirtualHardDisk) GetTags() *common.Tags {
	if m != nil {
		return m.Tags
	}
	return nil
}

func init() {
	proto.RegisterType((*VirtualHardDiskRequest)(nil), "moc.cloudagent.storage.VirtualHardDiskRequest")
	proto.RegisterType((*VirtualHardDiskResponse)(nil), "moc.cloudagent.storage.VirtualHardDiskResponse")
	proto.RegisterType((*VirtualHardDisk)(nil), "moc.cloudagent.storage.VirtualHardDisk")
}

func init() {
	proto.RegisterFile("moc_cloudagent_virtualharddisk.proto", fileDescriptor_e3ff93a45373b349)
}

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

// VirtualHardDiskAgentClient is the client API for VirtualHardDiskAgent service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type VirtualHardDiskAgentClient interface {
	Invoke(ctx context.Context, in *VirtualHardDiskRequest, opts ...grpc.CallOption) (*VirtualHardDiskResponse, error)
}

type virtualHardDiskAgentClient struct {
	cc *grpc.ClientConn
}

func NewVirtualHardDiskAgentClient(cc *grpc.ClientConn) VirtualHardDiskAgentClient {
	return &virtualHardDiskAgentClient{cc}
}

func (c *virtualHardDiskAgentClient) Invoke(ctx context.Context, in *VirtualHardDiskRequest, opts ...grpc.CallOption) (*VirtualHardDiskResponse, error) {
	out := new(VirtualHardDiskResponse)
	err := c.cc.Invoke(ctx, "/moc.cloudagent.storage.VirtualHardDiskAgent/Invoke", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// VirtualHardDiskAgentServer is the server API for VirtualHardDiskAgent service.
type VirtualHardDiskAgentServer interface {
	Invoke(context.Context, *VirtualHardDiskRequest) (*VirtualHardDiskResponse, error)
}

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

func (*UnimplementedVirtualHardDiskAgentServer) Invoke(ctx context.Context, req *VirtualHardDiskRequest) (*VirtualHardDiskResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Invoke not implemented")
}

func RegisterVirtualHardDiskAgentServer(s *grpc.Server, srv VirtualHardDiskAgentServer) {
	s.RegisterService(&_VirtualHardDiskAgent_serviceDesc, srv)
}

func _VirtualHardDiskAgent_Invoke_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VirtualHardDiskRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VirtualHardDiskAgentServer).Invoke(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/moc.cloudagent.storage.VirtualHardDiskAgent/Invoke",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VirtualHardDiskAgentServer).Invoke(ctx, req.(*VirtualHardDiskRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _VirtualHardDiskAgent_serviceDesc = grpc.ServiceDesc{
	ServiceName: "moc.cloudagent.storage.VirtualHardDiskAgent",
	HandlerType: (*VirtualHardDiskAgentServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Invoke",
			Handler:    _VirtualHardDiskAgent_Invoke_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "moc_cloudagent_virtualharddisk.proto",
}