github.com/microsoft/moc@v0.17.1/rpc/nodeagent/compute/moc_nodeagent_virtualmachine.pb.go

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

package compute

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	empty "github.com/golang/protobuf/ptypes/empty"
	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 VirtualMachineRequest struct {
	VirtualMachineSystems []*VirtualMachine `protobuf:"bytes,1,rep,name=VirtualMachineSystems,proto3" json:"VirtualMachineSystems,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 *VirtualMachineRequest) Reset()         { *m = VirtualMachineRequest{} }
func (m *VirtualMachineRequest) String() string { return proto.CompactTextString(m) }
func (*VirtualMachineRequest) ProtoMessage()    {}
func (*VirtualMachineRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9f3eecb05bcac3b7, []int{0}
}

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

var xxx_messageInfo_VirtualMachineRequest proto.InternalMessageInfo

func (m *VirtualMachineRequest) GetVirtualMachineSystems() []*VirtualMachine {
	if m != nil {
		return m.VirtualMachineSystems
	}
	return nil
}

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

type VirtualMachineResponse struct {
	VirtualMachineSystems []*VirtualMachine   `protobuf:"bytes,1,rep,name=VirtualMachineSystems,proto3" json:"VirtualMachineSystems,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 *VirtualMachineResponse) Reset()         { *m = VirtualMachineResponse{} }
func (m *VirtualMachineResponse) String() string { return proto.CompactTextString(m) }
func (*VirtualMachineResponse) ProtoMessage()    {}
func (*VirtualMachineResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9f3eecb05bcac3b7, []int{1}
}

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

var xxx_messageInfo_VirtualMachineResponse proto.InternalMessageInfo

func (m *VirtualMachineResponse) GetVirtualMachineSystems() []*VirtualMachine {
	if m != nil {
		return m.VirtualMachineSystems
	}
	return nil
}

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

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

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

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

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

var xxx_messageInfo_SSHPublicKey proto.InternalMessageInfo

func (m *SSHPublicKey) GetKeydata() string {
	if m != nil {
		return m.Keydata
	}
	return ""
}

type Disk struct {
	// reference to the virtual hard disk managed by storage
	Diskname             string   `protobuf:"bytes,1,opt,name=diskname,proto3" json:"diskname,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Disk proto.InternalMessageInfo

func (m *Disk) GetDiskname() string {
	if m != nil {
		return m.Diskname
	}
	return ""
}

type SharedFolder struct {
	// reference to the shared folder managed by storage
	Sharedfolderreference string   `protobuf:"bytes,1,opt,name=sharedfolderreference,proto3" json:"sharedfolderreference,omitempty"`
	Guestmountpath        string   `protobuf:"bytes,2,opt,name=guestmountpath,proto3" json:"guestmountpath,omitempty"`
	XXX_NoUnkeyedLiteral  struct{} `json:"-"`
	XXX_unrecognized      []byte   `json:"-"`
	XXX_sizecache         int32    `json:"-"`
}

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

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

var xxx_messageInfo_SharedFolder proto.InternalMessageInfo

func (m *SharedFolder) GetSharedfolderreference() string {
	if m != nil {
		return m.Sharedfolderreference
	}
	return ""
}

func (m *SharedFolder) GetGuestmountpath() string {
	if m != nil {
		return m.Guestmountpath
	}
	return ""
}

type StorageConfiguration struct {
	Osdisk                *Disk           `protobuf:"bytes,1,opt,name=osdisk,proto3" json:"osdisk,omitempty"`
	Datadisks             []*Disk         `protobuf:"bytes,2,rep,name=datadisks,proto3" json:"datadisks,omitempty"`
	VmConfigContainerName string          `protobuf:"bytes,3,opt,name=vmConfigContainerName,proto3" json:"vmConfigContainerName,omitempty"`
	SharedFolders         []*SharedFolder `protobuf:"bytes,4,rep,name=sharedFolders,proto3" json:"sharedFolders,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}        `json:"-"`
	XXX_unrecognized      []byte          `json:"-"`
	XXX_sizecache         int32           `json:"-"`
}

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

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

var xxx_messageInfo_StorageConfiguration proto.InternalMessageInfo

func (m *StorageConfiguration) GetOsdisk() *Disk {
	if m != nil {
		return m.Osdisk
	}
	return nil
}

func (m *StorageConfiguration) GetDatadisks() []*Disk {
	if m != nil {
		return m.Datadisks
	}
	return nil
}

func (m *StorageConfiguration) GetVmConfigContainerName() string {
	if m != nil {
		return m.VmConfigContainerName
	}
	return ""
}

func (m *StorageConfiguration) GetSharedFolders() []*SharedFolder {
	if m != nil {
		return m.SharedFolders
	}
	return nil
}

type NetworkInterface struct {
	// reference to network interface managed by network
	NetworkInterfaceName string   `protobuf:"bytes,1,opt,name=networkInterfaceName,proto3" json:"networkInterfaceName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_NetworkInterface proto.InternalMessageInfo

func (m *NetworkInterface) GetNetworkInterfaceName() string {
	if m != nil {
		return m.NetworkInterfaceName
	}
	return ""
}

type NetworkConfiguration struct {
	Interfaces           []*NetworkInterface `protobuf:"bytes,1,rep,name=interfaces,proto3" json:"interfaces,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_NetworkConfiguration proto.InternalMessageInfo

func (m *NetworkConfiguration) GetInterfaces() []*NetworkInterface {
	if m != nil {
		return m.Interfaces
	}
	return nil
}

type UserConfiguration struct {
	Username             string          `protobuf:"bytes,1,opt,name=username,proto3" json:"username,omitempty"`
	Password             string          `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
	Usertype             common.UserType `protobuf:"varint,3,opt,name=usertype,proto3,enum=moc.UserType" json:"usertype,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_UserConfiguration proto.InternalMessageInfo

func (m *UserConfiguration) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

func (m *UserConfiguration) GetPassword() string {
	if m != nil {
		return m.Password
	}
	return ""
}

func (m *UserConfiguration) GetUsertype() common.UserType {
	if m != nil {
		return m.Usertype
	}
	return common.UserType_ROOT
}

type RDPConfiguration struct {
	DisableRDP           bool     `protobuf:"varint,1,opt,name=disableRDP,proto3" json:"disableRDP,omitempty"`
	Port                 uint32   `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_RDPConfiguration proto.InternalMessageInfo

func (m *RDPConfiguration) GetDisableRDP() bool {
	if m != nil {
		return m.DisableRDP
	}
	return false
}

func (m *RDPConfiguration) GetPort() uint32 {
	if m != nil {
		return m.Port
	}
	return 0
}

type LinuxConfiguration struct {
	DisablePasswordAuthentication bool                       `protobuf:"varint,1,opt,name=disablePasswordAuthentication,proto3" json:"disablePasswordAuthentication,omitempty"`
	CloudInitDataSource           common.CloudInitDataSource `protobuf:"varint,2,opt,name=cloudInitDataSource,proto3,enum=moc.CloudInitDataSource" json:"cloudInitDataSource,omitempty"`
	XXX_NoUnkeyedLiteral          struct{}                   `json:"-"`
	XXX_unrecognized              []byte                     `json:"-"`
	XXX_sizecache                 int32                      `json:"-"`
}

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

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

var xxx_messageInfo_LinuxConfiguration proto.InternalMessageInfo

func (m *LinuxConfiguration) GetDisablePasswordAuthentication() bool {
	if m != nil {
		return m.DisablePasswordAuthentication
	}
	return false
}

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

type WindowsConfiguration struct {
	EnableAutomaticUpdates bool                       `protobuf:"varint,1,opt,name=enableAutomaticUpdates,proto3" json:"enableAutomaticUpdates,omitempty"`
	TimeZone               string                     `protobuf:"bytes,2,opt,name=timeZone,proto3" json:"timeZone,omitempty"`
	RDPConfiguration       *RDPConfiguration          `protobuf:"bytes,3,opt,name=RDPConfiguration,proto3" json:"RDPConfiguration,omitempty"`
	WinRMConfiguration     *common.WinRMConfiguration `protobuf:"bytes,4,opt,name=WinRMConfiguration,proto3" json:"WinRMConfiguration,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}                   `json:"-"`
	XXX_unrecognized       []byte                     `json:"-"`
	XXX_sizecache          int32                      `json:"-"`
}

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

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

var xxx_messageInfo_WindowsConfiguration proto.InternalMessageInfo

func (m *WindowsConfiguration) GetEnableAutomaticUpdates() bool {
	if m != nil {
		return m.EnableAutomaticUpdates
	}
	return false
}

func (m *WindowsConfiguration) GetTimeZone() string {
	if m != nil {
		return m.TimeZone
	}
	return ""
}

func (m *WindowsConfiguration) GetRDPConfiguration() *RDPConfiguration {
	if m != nil {
		return m.RDPConfiguration
	}
	return nil
}

func (m *WindowsConfiguration) GetWinRMConfiguration() *common.WinRMConfiguration {
	if m != nil {
		return m.WinRMConfiguration
	}
	return nil
}

type OperatingSystemConfiguration struct {
	ComputerName  string                     `protobuf:"bytes,1,opt,name=computerName,proto3" json:"computerName,omitempty"`
	Administrator *UserConfiguration         `protobuf:"bytes,2,opt,name=administrator,proto3" json:"administrator,omitempty"`
	Users         []*UserConfiguration       `protobuf:"bytes,3,rep,name=users,proto3" json:"users,omitempty"`
	CustomData    string                     `protobuf:"bytes,4,opt,name=customData,proto3" json:"customData,omitempty"`
	Publickeys    []*SSHPublicKey            `protobuf:"bytes,5,rep,name=publickeys,proto3" json:"publickeys,omitempty"`
	Ostype        common.OperatingSystemType `protobuf:"varint,6,opt,name=ostype,proto3,enum=moc.OperatingSystemType" json:"ostype,omitempty"`
	// bootstrap engine can be cloud-init, Windows answer files, ...
	OsBootstrapEngine    common.OperatingSystemBootstrapEngine `protobuf:"varint,7,opt,name=osBootstrapEngine,proto3,enum=moc.OperatingSystemBootstrapEngine" json:"osBootstrapEngine,omitempty"`
	LinuxConfiguration   *LinuxConfiguration                   `protobuf:"bytes,8,opt,name=linuxConfiguration,proto3" json:"linuxConfiguration,omitempty"`
	WindowsConfiguration *WindowsConfiguration                 `protobuf:"bytes,9,opt,name=windowsConfiguration,proto3" json:"windowsConfiguration,omitempty"`
	ProxyConfiguration   *common.ProxyConfiguration            `protobuf:"bytes,10,opt,name=proxyConfiguration,proto3" json:"proxyConfiguration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
	XXX_unrecognized     []byte                                `json:"-"`
	XXX_sizecache        int32                                 `json:"-"`
}

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

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

var xxx_messageInfo_OperatingSystemConfiguration proto.InternalMessageInfo

func (m *OperatingSystemConfiguration) GetComputerName() string {
	if m != nil {
		return m.ComputerName
	}
	return ""
}

func (m *OperatingSystemConfiguration) GetAdministrator() *UserConfiguration {
	if m != nil {
		return m.Administrator
	}
	return nil
}

func (m *OperatingSystemConfiguration) GetUsers() []*UserConfiguration {
	if m != nil {
		return m.Users
	}
	return nil
}

func (m *OperatingSystemConfiguration) GetCustomData() string {
	if m != nil {
		return m.CustomData
	}
	return ""
}

func (m *OperatingSystemConfiguration) GetPublickeys() []*SSHPublicKey {
	if m != nil {
		return m.Publickeys
	}
	return nil
}

func (m *OperatingSystemConfiguration) GetOstype() common.OperatingSystemType {
	if m != nil {
		return m.Ostype
	}
	return common.OperatingSystemType_WINDOWS
}

func (m *OperatingSystemConfiguration) GetOsBootstrapEngine() common.OperatingSystemBootstrapEngine {
	if m != nil {
		return m.OsBootstrapEngine
	}
	return common.OperatingSystemBootstrapEngine_CLOUD_INIT
}

func (m *OperatingSystemConfiguration) GetLinuxConfiguration() *LinuxConfiguration {
	if m != nil {
		return m.LinuxConfiguration
	}
	return nil
}

func (m *OperatingSystemConfiguration) GetWindowsConfiguration() *WindowsConfiguration {
	if m != nil {
		return m.WindowsConfiguration
	}
	return nil
}

func (m *OperatingSystemConfiguration) GetProxyConfiguration() *common.ProxyConfiguration {
	if m != nil {
		return m.ProxyConfiguration
	}
	return nil
}

type HardwareConfiguration struct {
	VMSize                     common.VirtualMachineSizeType      `protobuf:"varint,1,opt,name=VMSize,proto3,enum=moc.VirtualMachineSizeType" json:"VMSize,omitempty"`
	CustomSize                 *common.VirtualMachineCustomSize   `protobuf:"bytes,2,opt,name=customSize,proto3" json:"customSize,omitempty"`
	DynamicMemoryConfiguration *common.DynamicMemoryConfiguration `protobuf:"bytes,3,opt,name=dynamicMemoryConfiguration,proto3" json:"dynamicMemoryConfiguration,omitempty"`
	XXX_NoUnkeyedLiteral       struct{}                           `json:"-"`
	XXX_unrecognized           []byte                             `json:"-"`
	XXX_sizecache              int32                              `json:"-"`
}

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

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

var xxx_messageInfo_HardwareConfiguration proto.InternalMessageInfo

func (m *HardwareConfiguration) GetVMSize() common.VirtualMachineSizeType {
	if m != nil {
		return m.VMSize
	}
	return common.VirtualMachineSizeType_Default
}

func (m *HardwareConfiguration) GetCustomSize() *common.VirtualMachineCustomSize {
	if m != nil {
		return m.CustomSize
	}
	return nil
}

func (m *HardwareConfiguration) GetDynamicMemoryConfiguration() *common.DynamicMemoryConfiguration {
	if m != nil {
		return m.DynamicMemoryConfiguration
	}
	return nil
}

type UefiSettings struct {
	SecureBootEnabled    bool     `protobuf:"varint,1,opt,name=secureBootEnabled,proto3" json:"secureBootEnabled,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_UefiSettings proto.InternalMessageInfo

func (m *UefiSettings) GetSecureBootEnabled() bool {
	if m != nil {
		return m.SecureBootEnabled
	}
	return false
}

type SecurityConfiguration struct {
	EnableTPM            bool                `protobuf:"varint,1,opt,name=enableTPM,proto3" json:"enableTPM,omitempty"`
	UefiSettings         *UefiSettings       `protobuf:"bytes,2,opt,name=uefiSettings,proto3" json:"uefiSettings,omitempty"`
	SecurityType         common.SecurityType `protobuf:"varint,3,opt,name=securityType,proto3,enum=moc.SecurityType" json:"securityType,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_SecurityConfiguration proto.InternalMessageInfo

func (m *SecurityConfiguration) GetEnableTPM() bool {
	if m != nil {
		return m.EnableTPM
	}
	return false
}

func (m *SecurityConfiguration) GetUefiSettings() *UefiSettings {
	if m != nil {
		return m.UefiSettings
	}
	return nil
}

func (m *SecurityConfiguration) GetSecurityType() common.SecurityType {
	if m != nil {
		return m.SecurityType
	}
	return common.SecurityType_NOTCONFIGURED
}

type VirtualMachine 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"`
	Storage                 *StorageConfiguration                   `protobuf:"bytes,3,opt,name=storage,proto3" json:"storage,omitempty"`
	Os                      *OperatingSystemConfiguration           `protobuf:"bytes,4,opt,name=os,proto3" json:"os,omitempty"`
	Network                 *NetworkConfiguration                   `protobuf:"bytes,5,opt,name=network,proto3" json:"network,omitempty"`
	Hardware                *HardwareConfiguration                  `protobuf:"bytes,6,opt,name=hardware,proto3" json:"hardware,omitempty"`
	Status                  *common.Status                          `protobuf:"bytes,7,opt,name=status,proto3" json:"status,omitempty"`
	DisableHighAvailability bool                                    `protobuf:"varint,8,opt,name=disableHighAvailability,proto3" json:"disableHighAvailability,omitempty"`
	AllowedOwnerNodes       []string                                `protobuf:"bytes,9,rep,name=allowedOwnerNodes,proto3" json:"allowedOwnerNodes,omitempty"`
	PowerState              common.PowerState                       `protobuf:"varint,10,opt,name=powerState,proto3,enum=moc.PowerState" json:"powerState,omitempty"`
	Security                *SecurityConfiguration                  `protobuf:"bytes,11,opt,name=security,proto3" json:"security,omitempty"`
	Entity                  *common.Entity                          `protobuf:"bytes,12,opt,name=entity,proto3" json:"entity,omitempty"`
	HighAvailabilityState   common.HighAvailabilityState            `protobuf:"varint,13,opt,name=highAvailabilityState,proto3,enum=moc.HighAvailabilityState" json:"highAvailabilityState,omitempty"`
	Tags                    *common.Tags                            `protobuf:"bytes,14,opt,name=tags,proto3" json:"tags,omitempty"`
	GuestAgent              *common.GuestAgentConfiguration         `protobuf:"bytes,15,opt,name=guestAgent,proto3" json:"guestAgent,omitempty"`
	GuestAgentInstanceView  *common.VirtualMachineAgentInstanceView `protobuf:"bytes,16,opt,name=guestAgentInstanceView,proto3" json:"guestAgentInstanceView,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}                                `json:"-"`
	XXX_unrecognized        []byte                                  `json:"-"`
	XXX_sizecache           int32                                   `json:"-"`
}

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

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

var xxx_messageInfo_VirtualMachine proto.InternalMessageInfo

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

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

func (m *VirtualMachine) GetStorage() *StorageConfiguration {
	if m != nil {
		return m.Storage
	}
	return nil
}

func (m *VirtualMachine) GetOs() *OperatingSystemConfiguration {
	if m != nil {
		return m.Os
	}
	return nil
}

func (m *VirtualMachine) GetNetwork() *NetworkConfiguration {
	if m != nil {
		return m.Network
	}
	return nil
}

func (m *VirtualMachine) GetHardware() *HardwareConfiguration {
	if m != nil {
		return m.Hardware
	}
	return nil
}

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

func (m *VirtualMachine) GetDisableHighAvailability() bool {
	if m != nil {
		return m.DisableHighAvailability
	}
	return false
}

func (m *VirtualMachine) GetAllowedOwnerNodes() []string {
	if m != nil {
		return m.AllowedOwnerNodes
	}
	return nil
}

func (m *VirtualMachine) GetPowerState() common.PowerState {
	if m != nil {
		return m.PowerState
	}
	return common.PowerState_Unknown
}

func (m *VirtualMachine) GetSecurity() *SecurityConfiguration {
	if m != nil {
		return m.Security
	}
	return nil
}

func (m *VirtualMachine) GetEntity() *common.Entity {
	if m != nil {
		return m.Entity
	}
	return nil
}

func (m *VirtualMachine) GetHighAvailabilityState() common.HighAvailabilityState {
	if m != nil {
		return m.HighAvailabilityState
	}
	return common.HighAvailabilityState_UNKNOWN_HA_STATE
}

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

func (m *VirtualMachine) GetGuestAgent() *common.GuestAgentConfiguration {
	if m != nil {
		return m.GuestAgent
	}
	return nil
}

func (m *VirtualMachine) GetGuestAgentInstanceView() *common.VirtualMachineAgentInstanceView {
	if m != nil {
		return m.GuestAgentInstanceView
	}
	return nil
}

type VirtualMachineOperationRequest struct {
	VirtualMachines      []*VirtualMachine              `protobuf:"bytes,1,rep,name=VirtualMachines,proto3" json:"VirtualMachines,omitempty"`
	OperationType        common.VirtualMachineOperation `protobuf:"varint,2,opt,name=OperationType,proto3,enum=moc.VirtualMachineOperation" json:"OperationType,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
	XXX_unrecognized     []byte                         `json:"-"`
	XXX_sizecache        int32                          `json:"-"`
}

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

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

var xxx_messageInfo_VirtualMachineOperationRequest proto.InternalMessageInfo

func (m *VirtualMachineOperationRequest) GetVirtualMachines() []*VirtualMachine {
	if m != nil {
		return m.VirtualMachines
	}
	return nil
}

func (m *VirtualMachineOperationRequest) GetOperationType() common.VirtualMachineOperation {
	if m != nil {
		return m.OperationType
	}
	return common.VirtualMachineOperation_START
}

type VirtualMachineOperationResponse struct {
	VirtualMachines      []*VirtualMachine   `protobuf:"bytes,1,rep,name=VirtualMachines,proto3" json:"VirtualMachines,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 *VirtualMachineOperationResponse) Reset()         { *m = VirtualMachineOperationResponse{} }
func (m *VirtualMachineOperationResponse) String() string { return proto.CompactTextString(m) }
func (*VirtualMachineOperationResponse) ProtoMessage()    {}
func (*VirtualMachineOperationResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9f3eecb05bcac3b7, []int{18}
}

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

var xxx_messageInfo_VirtualMachineOperationResponse proto.InternalMessageInfo

func (m *VirtualMachineOperationResponse) GetVirtualMachines() []*VirtualMachine {
	if m != nil {
		return m.VirtualMachines
	}
	return nil
}

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

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

type VirtualMachineRunCommandRequest struct {
	VirtualMachine            *VirtualMachine                                  `protobuf:"bytes,1,opt,name=VirtualMachine,proto3" json:"VirtualMachine,omitempty"`
	Source                    *common.VirtualMachineRunCommandScriptSource     `protobuf:"bytes,2,opt,name=Source,proto3" json:"Source,omitempty"`
	RunCommandInputParameters []*common.VirtualMachineRunCommandInputParameter `protobuf:"bytes,3,rep,name=RunCommandInputParameters,proto3" json:"RunCommandInputParameters,omitempty"`
	RunAsUser                 string                                           `protobuf:"bytes,4,opt,name=RunAsUser,proto3" json:"RunAsUser,omitempty"`
	RunAsPassword             string                                           `protobuf:"bytes,5,opt,name=RunAsPassword,proto3" json:"RunAsPassword,omitempty"`
	XXX_NoUnkeyedLiteral      struct{}                                         `json:"-"`
	XXX_unrecognized          []byte                                           `json:"-"`
	XXX_sizecache             int32                                            `json:"-"`
}

func (m *VirtualMachineRunCommandRequest) Reset()         { *m = VirtualMachineRunCommandRequest{} }
func (m *VirtualMachineRunCommandRequest) String() string { return proto.CompactTextString(m) }
func (*VirtualMachineRunCommandRequest) ProtoMessage()    {}
func (*VirtualMachineRunCommandRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9f3eecb05bcac3b7, []int{19}
}

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

var xxx_messageInfo_VirtualMachineRunCommandRequest proto.InternalMessageInfo

func (m *VirtualMachineRunCommandRequest) GetVirtualMachine() *VirtualMachine {
	if m != nil {
		return m.VirtualMachine
	}
	return nil
}

func (m *VirtualMachineRunCommandRequest) GetSource() *common.VirtualMachineRunCommandScriptSource {
	if m != nil {
		return m.Source
	}
	return nil
}

func (m *VirtualMachineRunCommandRequest) GetRunCommandInputParameters() []*common.VirtualMachineRunCommandInputParameter {
	if m != nil {
		return m.RunCommandInputParameters
	}
	return nil
}

func (m *VirtualMachineRunCommandRequest) GetRunAsUser() string {
	if m != nil {
		return m.RunAsUser
	}
	return ""
}

func (m *VirtualMachineRunCommandRequest) GetRunAsPassword() string {
	if m != nil {
		return m.RunAsPassword
	}
	return ""
}

type VirtualMachineRunCommandResponse struct {
	VirtualMachine       *VirtualMachine                              `protobuf:"bytes,1,opt,name=VirtualMachine,proto3" json:"VirtualMachine,omitempty"`
	InstanceView         *common.VirtualMachineRunCommandInstanceView `protobuf:"bytes,2,opt,name=InstanceView,proto3" json:"InstanceView,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                     `json:"-"`
	XXX_unrecognized     []byte                                       `json:"-"`
	XXX_sizecache        int32                                        `json:"-"`
}

func (m *VirtualMachineRunCommandResponse) Reset()         { *m = VirtualMachineRunCommandResponse{} }
func (m *VirtualMachineRunCommandResponse) String() string { return proto.CompactTextString(m) }
func (*VirtualMachineRunCommandResponse) ProtoMessage()    {}
func (*VirtualMachineRunCommandResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9f3eecb05bcac3b7, []int{20}
}

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

var xxx_messageInfo_VirtualMachineRunCommandResponse proto.InternalMessageInfo

func (m *VirtualMachineRunCommandResponse) GetVirtualMachine() *VirtualMachine {
	if m != nil {
		return m.VirtualMachine
	}
	return nil
}

func (m *VirtualMachineRunCommandResponse) GetInstanceView() *common.VirtualMachineRunCommandInstanceView {
	if m != nil {
		return m.InstanceView
	}
	return nil
}

func init() {
	proto.RegisterType((*VirtualMachineRequest)(nil), "moc.nodeagent.compute.VirtualMachineRequest")
	proto.RegisterType((*VirtualMachineResponse)(nil), "moc.nodeagent.compute.VirtualMachineResponse")
	proto.RegisterType((*SSHPublicKey)(nil), "moc.nodeagent.compute.SSHPublicKey")
	proto.RegisterType((*Disk)(nil), "moc.nodeagent.compute.Disk")
	proto.RegisterType((*SharedFolder)(nil), "moc.nodeagent.compute.SharedFolder")
	proto.RegisterType((*StorageConfiguration)(nil), "moc.nodeagent.compute.StorageConfiguration")
	proto.RegisterType((*NetworkInterface)(nil), "moc.nodeagent.compute.NetworkInterface")
	proto.RegisterType((*NetworkConfiguration)(nil), "moc.nodeagent.compute.NetworkConfiguration")
	proto.RegisterType((*UserConfiguration)(nil), "moc.nodeagent.compute.UserConfiguration")
	proto.RegisterType((*RDPConfiguration)(nil), "moc.nodeagent.compute.RDPConfiguration")
	proto.RegisterType((*LinuxConfiguration)(nil), "moc.nodeagent.compute.LinuxConfiguration")
	proto.RegisterType((*WindowsConfiguration)(nil), "moc.nodeagent.compute.WindowsConfiguration")
	proto.RegisterType((*OperatingSystemConfiguration)(nil), "moc.nodeagent.compute.OperatingSystemConfiguration")
	proto.RegisterType((*HardwareConfiguration)(nil), "moc.nodeagent.compute.HardwareConfiguration")
	proto.RegisterType((*UefiSettings)(nil), "moc.nodeagent.compute.UefiSettings")
	proto.RegisterType((*SecurityConfiguration)(nil), "moc.nodeagent.compute.SecurityConfiguration")
	proto.RegisterType((*VirtualMachine)(nil), "moc.nodeagent.compute.VirtualMachine")
	proto.RegisterType((*VirtualMachineOperationRequest)(nil), "moc.nodeagent.compute.VirtualMachineOperationRequest")
	proto.RegisterType((*VirtualMachineOperationResponse)(nil), "moc.nodeagent.compute.VirtualMachineOperationResponse")
	proto.RegisterType((*VirtualMachineRunCommandRequest)(nil), "moc.nodeagent.compute.VirtualMachineRunCommandRequest")
	proto.RegisterType((*VirtualMachineRunCommandResponse)(nil), "moc.nodeagent.compute.VirtualMachineRunCommandResponse")
}

func init() {
	proto.RegisterFile("moc_nodeagent_virtualmachine.proto", fileDescriptor_9f3eecb05bcac3b7)
}

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

// VirtualMachineAgentClient is the client API for VirtualMachineAgent service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type VirtualMachineAgentClient interface {
	Invoke(ctx context.Context, in *VirtualMachineRequest, opts ...grpc.CallOption) (*VirtualMachineResponse, error)
	Operate(ctx context.Context, in *VirtualMachineOperationRequest, opts ...grpc.CallOption) (*VirtualMachineOperationResponse, error)
	CheckNotification(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*common.NotificationResponse, error)
	RunCommand(ctx context.Context, in *VirtualMachineRunCommandRequest, opts ...grpc.CallOption) (*VirtualMachineRunCommandResponse, error)
}

type virtualMachineAgentClient struct {
	cc *grpc.ClientConn
}

func NewVirtualMachineAgentClient(cc *grpc.ClientConn) VirtualMachineAgentClient {
	return &virtualMachineAgentClient{cc}
}

func (c *virtualMachineAgentClient) Invoke(ctx context.Context, in *VirtualMachineRequest, opts ...grpc.CallOption) (*VirtualMachineResponse, error) {
	out := new(VirtualMachineResponse)
	err := c.cc.Invoke(ctx, "/moc.nodeagent.compute.VirtualMachineAgent/Invoke", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *virtualMachineAgentClient) Operate(ctx context.Context, in *VirtualMachineOperationRequest, opts ...grpc.CallOption) (*VirtualMachineOperationResponse, error) {
	out := new(VirtualMachineOperationResponse)
	err := c.cc.Invoke(ctx, "/moc.nodeagent.compute.VirtualMachineAgent/Operate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *virtualMachineAgentClient) CheckNotification(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*common.NotificationResponse, error) {
	out := new(common.NotificationResponse)
	err := c.cc.Invoke(ctx, "/moc.nodeagent.compute.VirtualMachineAgent/CheckNotification", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *virtualMachineAgentClient) RunCommand(ctx context.Context, in *VirtualMachineRunCommandRequest, opts ...grpc.CallOption) (*VirtualMachineRunCommandResponse, error) {
	out := new(VirtualMachineRunCommandResponse)
	err := c.cc.Invoke(ctx, "/moc.nodeagent.compute.VirtualMachineAgent/RunCommand", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// VirtualMachineAgentServer is the server API for VirtualMachineAgent service.
type VirtualMachineAgentServer interface {
	Invoke(context.Context, *VirtualMachineRequest) (*VirtualMachineResponse, error)
	Operate(context.Context, *VirtualMachineOperationRequest) (*VirtualMachineOperationResponse, error)
	CheckNotification(context.Context, *empty.Empty) (*common.NotificationResponse, error)
	RunCommand(context.Context, *VirtualMachineRunCommandRequest) (*VirtualMachineRunCommandResponse, error)
}

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

func (*UnimplementedVirtualMachineAgentServer) Invoke(ctx context.Context, req *VirtualMachineRequest) (*VirtualMachineResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Invoke not implemented")
}
func (*UnimplementedVirtualMachineAgentServer) Operate(ctx context.Context, req *VirtualMachineOperationRequest) (*VirtualMachineOperationResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Operate not implemented")
}
func (*UnimplementedVirtualMachineAgentServer) CheckNotification(ctx context.Context, req *empty.Empty) (*common.NotificationResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheckNotification not implemented")
}
func (*UnimplementedVirtualMachineAgentServer) RunCommand(ctx context.Context, req *VirtualMachineRunCommandRequest) (*VirtualMachineRunCommandResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCommand not implemented")
}

func RegisterVirtualMachineAgentServer(s *grpc.Server, srv VirtualMachineAgentServer) {
	s.RegisterService(&_VirtualMachineAgent_serviceDesc, srv)
}

func _VirtualMachineAgent_Invoke_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VirtualMachineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VirtualMachineAgentServer).Invoke(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/moc.nodeagent.compute.VirtualMachineAgent/Invoke",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VirtualMachineAgentServer).Invoke(ctx, req.(*VirtualMachineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VirtualMachineAgent_Operate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VirtualMachineOperationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VirtualMachineAgentServer).Operate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/moc.nodeagent.compute.VirtualMachineAgent/Operate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VirtualMachineAgentServer).Operate(ctx, req.(*VirtualMachineOperationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VirtualMachineAgent_CheckNotification_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VirtualMachineAgentServer).CheckNotification(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/moc.nodeagent.compute.VirtualMachineAgent/CheckNotification",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VirtualMachineAgentServer).CheckNotification(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _VirtualMachineAgent_RunCommand_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VirtualMachineRunCommandRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VirtualMachineAgentServer).RunCommand(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/moc.nodeagent.compute.VirtualMachineAgent/RunCommand",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VirtualMachineAgentServer).RunCommand(ctx, req.(*VirtualMachineRunCommandRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _VirtualMachineAgent_serviceDesc = grpc.ServiceDesc{
	ServiceName: "moc.nodeagent.compute.VirtualMachineAgent",
	HandlerType: (*VirtualMachineAgentServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Invoke",
			Handler:    _VirtualMachineAgent_Invoke_Handler,
		},
		{
			MethodName: "Operate",
			Handler:    _VirtualMachineAgent_Operate_Handler,
		},
		{
			MethodName: "CheckNotification",
			Handler:    _VirtualMachineAgent_CheckNotification_Handler,
		},
		{
			MethodName: "RunCommand",
			Handler:    _VirtualMachineAgent_RunCommand_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "moc_nodeagent_virtualmachine.proto",
}