github.com/microsoft/moc@v0.17.1/rpc/common/moc_common_computecommon.pb.go

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

package common

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
	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 UserType int32

const (
	UserType_ROOT UserType = 0
	UserType_USER UserType = 1
)

var UserType_name = map[int32]string{
	0: "ROOT",
	1: "USER",
}

var UserType_value = map[string]int32{
	"ROOT": 0,
	"USER": 1,
}

func (x UserType) String() string {
	return proto.EnumName(UserType_name, int32(x))
}

func (UserType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7d1a061f6c82445b, []int{0}
}

type ProcessorType int32

const (
	ProcessorType_None    ProcessorType = 0
	ProcessorType_Intel   ProcessorType = 1
	ProcessorType_Intel64 ProcessorType = 2
	ProcessorType_AMD     ProcessorType = 3
	ProcessorType_AMD64   ProcessorType = 4
	ProcessorType_ARM     ProcessorType = 5
	ProcessorType_ARM64   ProcessorType = 6
)

var ProcessorType_name = map[int32]string{
	0: "None",
	1: "Intel",
	2: "Intel64",
	3: "AMD",
	4: "AMD64",
	5: "ARM",
	6: "ARM64",
}

var ProcessorType_value = map[string]int32{
	"None":    0,
	"Intel":   1,
	"Intel64": 2,
	"AMD":     3,
	"AMD64":   4,
	"ARM":     5,
	"ARM64":   6,
}

func (x ProcessorType) String() string {
	return proto.EnumName(ProcessorType_name, int32(x))
}

func (ProcessorType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7d1a061f6c82445b, []int{1}
}

type OperatingSystemBootstrapEngine int32

const (
	OperatingSystemBootstrapEngine_CLOUD_INIT           OperatingSystemBootstrapEngine = 0
	OperatingSystemBootstrapEngine_WINDOWS_ANSWER_FILES OperatingSystemBootstrapEngine = 1
)

var OperatingSystemBootstrapEngine_name = map[int32]string{
	0: "CLOUD_INIT",
	1: "WINDOWS_ANSWER_FILES",
}

var OperatingSystemBootstrapEngine_value = map[string]int32{
	"CLOUD_INIT":           0,
	"WINDOWS_ANSWER_FILES": 1,
}

func (x OperatingSystemBootstrapEngine) String() string {
	return proto.EnumName(OperatingSystemBootstrapEngine_name, int32(x))
}

func (OperatingSystemBootstrapEngine) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7d1a061f6c82445b, []int{2}
}

type OperatingSystemType int32

const (
	OperatingSystemType_WINDOWS OperatingSystemType = 0
	OperatingSystemType_LINUX   OperatingSystemType = 1
)

var OperatingSystemType_name = map[int32]string{
	0: "WINDOWS",
	1: "LINUX",
}

var OperatingSystemType_value = map[string]int32{
	"WINDOWS": 0,
	"LINUX":   1,
}

func (x OperatingSystemType) String() string {
	return proto.EnumName(OperatingSystemType_name, int32(x))
}

func (OperatingSystemType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7d1a061f6c82445b, []int{3}
}

type VirtualMachineSizeType int32

const (
	VirtualMachineSizeType_Default               VirtualMachineSizeType = 0
	VirtualMachineSizeType_Standard_A2_v2        VirtualMachineSizeType = 2
	VirtualMachineSizeType_Standard_A4_v2        VirtualMachineSizeType = 3
	VirtualMachineSizeType_Standard_D2s_v3       VirtualMachineSizeType = 4
	VirtualMachineSizeType_Standard_D4s_v3       VirtualMachineSizeType = 5
	VirtualMachineSizeType_Standard_D8s_v3       VirtualMachineSizeType = 6
	VirtualMachineSizeType_Standard_D16s_v3      VirtualMachineSizeType = 7
	VirtualMachineSizeType_Standard_D32s_v3      VirtualMachineSizeType = 8
	VirtualMachineSizeType_Standard_DS2_v2       VirtualMachineSizeType = 9
	VirtualMachineSizeType_Standard_DS3_v2       VirtualMachineSizeType = 10
	VirtualMachineSizeType_Standard_DS4_v2       VirtualMachineSizeType = 11
	VirtualMachineSizeType_Standard_DS5_v2       VirtualMachineSizeType = 12
	VirtualMachineSizeType_Standard_DS13_v2      VirtualMachineSizeType = 13
	VirtualMachineSizeType_Standard_K8S_v1       VirtualMachineSizeType = 14
	VirtualMachineSizeType_Standard_K8S2_v1      VirtualMachineSizeType = 15
	VirtualMachineSizeType_Standard_K8S3_v1      VirtualMachineSizeType = 16
	VirtualMachineSizeType_Standard_K8S4_v1      VirtualMachineSizeType = 17
	VirtualMachineSizeType_Standard_NK6          VirtualMachineSizeType = 18
	VirtualMachineSizeType_Standard_NK12         VirtualMachineSizeType = 19
	VirtualMachineSizeType_Standard_NV6          VirtualMachineSizeType = 20
	VirtualMachineSizeType_Standard_NV12         VirtualMachineSizeType = 21
	VirtualMachineSizeType_Standard_K8S5_v1      VirtualMachineSizeType = 22
	VirtualMachineSizeType_Standard_DS2_v2_HPN   VirtualMachineSizeType = 23
	VirtualMachineSizeType_Standard_DS3_v2_HPN   VirtualMachineSizeType = 24
	VirtualMachineSizeType_Standard_DS4_v2_HPN   VirtualMachineSizeType = 25
	VirtualMachineSizeType_Standard_F2s_HPN      VirtualMachineSizeType = 26
	VirtualMachineSizeType_Standard_F4s_HPN      VirtualMachineSizeType = 27
	VirtualMachineSizeType_Standard_F8s_HPN      VirtualMachineSizeType = 28
	VirtualMachineSizeType_Standard_F16s_HPN     VirtualMachineSizeType = 29
	VirtualMachineSizeType_Standard_NC4_A2       VirtualMachineSizeType = 30
	VirtualMachineSizeType_Standard_NC8_A2       VirtualMachineSizeType = 31
	VirtualMachineSizeType_Standard_NC16_A2      VirtualMachineSizeType = 32
	VirtualMachineSizeType_Standard_NC32_A2      VirtualMachineSizeType = 33
	VirtualMachineSizeType_Standard_NC4_A30      VirtualMachineSizeType = 34
	VirtualMachineSizeType_Standard_NC8_A30      VirtualMachineSizeType = 35
	VirtualMachineSizeType_Standard_NC16_A30     VirtualMachineSizeType = 36
	VirtualMachineSizeType_Standard_NC32_A30     VirtualMachineSizeType = 37
	VirtualMachineSizeType_Standard_NC4_A100_40  VirtualMachineSizeType = 38
	VirtualMachineSizeType_Standard_NC8_A100_40  VirtualMachineSizeType = 39
	VirtualMachineSizeType_Standard_NC16_A100_40 VirtualMachineSizeType = 40
	VirtualMachineSizeType_Standard_NC32_A100_40 VirtualMachineSizeType = 41
	VirtualMachineSizeType_Standard_NC4_A100_80  VirtualMachineSizeType = 42
	VirtualMachineSizeType_Standard_NC8_A100_80  VirtualMachineSizeType = 43
	VirtualMachineSizeType_Standard_NC16_A100_80 VirtualMachineSizeType = 44
	VirtualMachineSizeType_Standard_NC32_A100_80 VirtualMachineSizeType = 45
	VirtualMachineSizeType_Standard_NC4_A16      VirtualMachineSizeType = 46
	VirtualMachineSizeType_Standard_NC8_A16      VirtualMachineSizeType = 47
	VirtualMachineSizeType_Standard_NC16_A16     VirtualMachineSizeType = 48
	VirtualMachineSizeType_Standard_NC32_A16     VirtualMachineSizeType = 49
	VirtualMachineSizeType_Custom_A2             VirtualMachineSizeType = 95
	VirtualMachineSizeType_Custom_NK             VirtualMachineSizeType = 96
	VirtualMachineSizeType_Custom_Gpupv          VirtualMachineSizeType = 97
	VirtualMachineSizeType_Custom                VirtualMachineSizeType = 98
	VirtualMachineSizeType_Unsupported           VirtualMachineSizeType = 99
)

var VirtualMachineSizeType_name = map[int32]string{
	0:  "Default",
	2:  "Standard_A2_v2",
	3:  "Standard_A4_v2",
	4:  "Standard_D2s_v3",
	5:  "Standard_D4s_v3",
	6:  "Standard_D8s_v3",
	7:  "Standard_D16s_v3",
	8:  "Standard_D32s_v3",
	9:  "Standard_DS2_v2",
	10: "Standard_DS3_v2",
	11: "Standard_DS4_v2",
	12: "Standard_DS5_v2",
	13: "Standard_DS13_v2",
	14: "Standard_K8S_v1",
	15: "Standard_K8S2_v1",
	16: "Standard_K8S3_v1",
	17: "Standard_K8S4_v1",
	18: "Standard_NK6",
	19: "Standard_NK12",
	20: "Standard_NV6",
	21: "Standard_NV12",
	22: "Standard_K8S5_v1",
	23: "Standard_DS2_v2_HPN",
	24: "Standard_DS3_v2_HPN",
	25: "Standard_DS4_v2_HPN",
	26: "Standard_F2s_HPN",
	27: "Standard_F4s_HPN",
	28: "Standard_F8s_HPN",
	29: "Standard_F16s_HPN",
	30: "Standard_NC4_A2",
	31: "Standard_NC8_A2",
	32: "Standard_NC16_A2",
	33: "Standard_NC32_A2",
	34: "Standard_NC4_A30",
	35: "Standard_NC8_A30",
	36: "Standard_NC16_A30",
	37: "Standard_NC32_A30",
	38: "Standard_NC4_A100_40",
	39: "Standard_NC8_A100_40",
	40: "Standard_NC16_A100_40",
	41: "Standard_NC32_A100_40",
	42: "Standard_NC4_A100_80",
	43: "Standard_NC8_A100_80",
	44: "Standard_NC16_A100_80",
	45: "Standard_NC32_A100_80",
	46: "Standard_NC4_A16",
	47: "Standard_NC8_A16",
	48: "Standard_NC16_A16",
	49: "Standard_NC32_A16",
	95: "Custom_A2",
	96: "Custom_NK",
	97: "Custom_Gpupv",
	98: "Custom",
	99: "Unsupported",
}

var VirtualMachineSizeType_value = map[string]int32{
	"Default":               0,
	"Standard_A2_v2":        2,
	"Standard_A4_v2":        3,
	"Standard_D2s_v3":       4,
	"Standard_D4s_v3":       5,
	"Standard_D8s_v3":       6,
	"Standard_D16s_v3":      7,
	"Standard_D32s_v3":      8,
	"Standard_DS2_v2":       9,
	"Standard_DS3_v2":       10,
	"Standard_DS4_v2":       11,
	"Standard_DS5_v2":       12,
	"Standard_DS13_v2":      13,
	"Standard_K8S_v1":       14,
	"Standard_K8S2_v1":      15,
	"Standard_K8S3_v1":      16,
	"Standard_K8S4_v1":      17,
	"Standard_NK6":          18,
	"Standard_NK12":         19,
	"Standard_NV6":          20,
	"Standard_NV12":         21,
	"Standard_K8S5_v1":      22,
	"Standard_DS2_v2_HPN":   23,
	"Standard_DS3_v2_HPN":   24,
	"Standard_DS4_v2_HPN":   25,
	"Standard_F2s_HPN":      26,
	"Standard_F4s_HPN":      27,
	"Standard_F8s_HPN":      28,
	"Standard_F16s_HPN":     29,
	"Standard_NC4_A2":       30,
	"Standard_NC8_A2":       31,
	"Standard_NC16_A2":      32,
	"Standard_NC32_A2":      33,
	"Standard_NC4_A30":      34,
	"Standard_NC8_A30":      35,
	"Standard_NC16_A30":     36,
	"Standard_NC32_A30":     37,
	"Standard_NC4_A100_40":  38,
	"Standard_NC8_A100_40":  39,
	"Standard_NC16_A100_40": 40,
	"Standard_NC32_A100_40": 41,
	"Standard_NC4_A100_80":  42,
	"Standard_NC8_A100_80":  43,
	"Standard_NC16_A100_80": 44,
	"Standard_NC32_A100_80": 45,
	"Standard_NC4_A16":      46,
	"Standard_NC8_A16":      47,
	"Standard_NC16_A16":     48,
	"Standard_NC32_A16":     49,
	"Custom_A2":             95,
	"Custom_NK":             96,
	"Custom_Gpupv":          97,
	"Custom":                98,
	"Unsupported":           99,
}

func (x VirtualMachineSizeType) String() string {
	return proto.EnumName(VirtualMachineSizeType_name, int32(x))
}

func (VirtualMachineSizeType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7d1a061f6c82445b, []int{4}
}

type WinRMProtocolType int32

const (
	WinRMProtocolType_HTTP  WinRMProtocolType = 0
	WinRMProtocolType_HTTPS WinRMProtocolType = 1
)

var WinRMProtocolType_name = map[int32]string{
	0: "HTTP",
	1: "HTTPS",
}

var WinRMProtocolType_value = map[string]int32{
	"HTTP":  0,
	"HTTPS": 1,
}

func (x WinRMProtocolType) String() string {
	return proto.EnumName(WinRMProtocolType_name, int32(x))
}

func (WinRMProtocolType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7d1a061f6c82445b, []int{5}
}

type PowerState int32

const (
	PowerState_Unknown  PowerState = 0
	PowerState_Running  PowerState = 1
	PowerState_Off      PowerState = 2
	PowerState_Paused   PowerState = 3
	PowerState_Critical PowerState = 4
	PowerState_Saved    PowerState = 5
)

var PowerState_name = map[int32]string{
	0: "Unknown",
	1: "Running",
	2: "Off",
	3: "Paused",
	4: "Critical",
	5: "Saved",
}

var PowerState_value = map[string]int32{
	"Unknown":  0,
	"Running":  1,
	"Off":      2,
	"Paused":   3,
	"Critical": 4,
	"Saved":    5,
}

func (x PowerState) String() string {
	return proto.EnumName(PowerState_name, int32(x))
}

func (PowerState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7d1a061f6c82445b, []int{6}
}

type VirtualMachineOperation int32

const (
	VirtualMachineOperation_START              VirtualMachineOperation = 0
	VirtualMachineOperation_STOP               VirtualMachineOperation = 1
	VirtualMachineOperation_RESET              VirtualMachineOperation = 2
	VirtualMachineOperation_REPAIR_GUEST_AGENT VirtualMachineOperation = 3
	VirtualMachineOperation_PAUSE              VirtualMachineOperation = 4
	VirtualMachineOperation_SAVE               VirtualMachineOperation = 5
)

var VirtualMachineOperation_name = map[int32]string{
	0: "START",
	1: "STOP",
	2: "RESET",
	3: "REPAIR_GUEST_AGENT",
	4: "PAUSE",
	5: "SAVE",
}

var VirtualMachineOperation_value = map[string]int32{
	"START":              0,
	"STOP":               1,
	"RESET":              2,
	"REPAIR_GUEST_AGENT": 3,
	"PAUSE":              4,
	"SAVE":               5,
}

func (x VirtualMachineOperation) String() string {
	return proto.EnumName(VirtualMachineOperation_name, int32(x))
}

func (VirtualMachineOperation) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7d1a061f6c82445b, []int{7}
}

type VirtualMachineRunCommandExecutionState int32

const (
	VirtualMachineRunCommandExecutionState_ExecutionState_UNKNOWN   VirtualMachineRunCommandExecutionState = 0
	VirtualMachineRunCommandExecutionState_ExecutionState_FAILED    VirtualMachineRunCommandExecutionState = 1
	VirtualMachineRunCommandExecutionState_ExecutionState_SUCCEEDED VirtualMachineRunCommandExecutionState = 2
	VirtualMachineRunCommandExecutionState_ExecutionState_PENDING   VirtualMachineRunCommandExecutionState = 3
	VirtualMachineRunCommandExecutionState_ExecutionState_REBOOTING VirtualMachineRunCommandExecutionState = 4
)

var VirtualMachineRunCommandExecutionState_name = map[int32]string{
	0: "ExecutionState_UNKNOWN",
	1: "ExecutionState_FAILED",
	2: "ExecutionState_SUCCEEDED",
	3: "ExecutionState_PENDING",
	4: "ExecutionState_REBOOTING",
}

var VirtualMachineRunCommandExecutionState_value = map[string]int32{
	"ExecutionState_UNKNOWN":   0,
	"ExecutionState_FAILED":    1,
	"ExecutionState_SUCCEEDED": 2,
	"ExecutionState_PENDING":   3,
	"ExecutionState_REBOOTING": 4,
}

func (x VirtualMachineRunCommandExecutionState) String() string {
	return proto.EnumName(VirtualMachineRunCommandExecutionState_name, int32(x))
}

func (VirtualMachineRunCommandExecutionState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7d1a061f6c82445b, []int{8}
}

type Architecture int32

const (
	Architecture_x86                Architecture = 0
	Architecture_MIPS               Architecture = 1
	Architecture_Alpha              Architecture = 2
	Architecture_PowerPC            Architecture = 3
	Architecture_ARM_Architecture   Architecture = 5
	Architecture_ia64               Architecture = 6
	Architecture_x64                Architecture = 9
	Architecture_ARM64_Architecture Architecture = 12
)

var Architecture_name = map[int32]string{
	0:  "x86",
	1:  "MIPS",
	2:  "Alpha",
	3:  "PowerPC",
	5:  "ARM_Architecture",
	6:  "ia64",
	9:  "x64",
	12: "ARM64_Architecture",
}

var Architecture_value = map[string]int32{
	"x86":                0,
	"MIPS":               1,
	"Alpha":              2,
	"PowerPC":            3,
	"ARM_Architecture":   5,
	"ia64":               6,
	"x64":                9,
	"ARM64_Architecture": 12,
}

func (x Architecture) String() string {
	return proto.EnumName(Architecture_name, int32(x))
}

func (Architecture) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7d1a061f6c82445b, []int{9}
}

type SecurityType int32

const (
	SecurityType_NOTCONFIGURED  SecurityType = 0
	SecurityType_TRUSTEDLAUNCH  SecurityType = 1
	SecurityType_CONFIDENTIALVM SecurityType = 2
)

var SecurityType_name = map[int32]string{
	0: "NOTCONFIGURED",
	1: "TRUSTEDLAUNCH",
	2: "CONFIDENTIALVM",
}

var SecurityType_value = map[string]int32{
	"NOTCONFIGURED":  0,
	"TRUSTEDLAUNCH":  1,
	"CONFIDENTIALVM": 2,
}

func (x SecurityType) String() string {
	return proto.EnumName(SecurityType_name, int32(x))
}

func (SecurityType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7d1a061f6c82445b, []int{10}
}

type Gpu_AssignmentType int32

const (
	Gpu_GpuDDA Gpu_AssignmentType = 0
	Gpu_GpuP   Gpu_AssignmentType = 1
)

var Gpu_AssignmentType_name = map[int32]string{
	0: "GpuDDA",
	1: "GpuP",
}

var Gpu_AssignmentType_value = map[string]int32{
	"GpuDDA": 0,
	"GpuP":   1,
}

func (x Gpu_AssignmentType) String() string {
	return proto.EnumName(Gpu_AssignmentType_name, int32(x))
}

func (Gpu_AssignmentType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7d1a061f6c82445b, []int{2, 0}
}

type InstanceViewStatus_StatusLevelType int32

const (
	InstanceViewStatus_Unknown InstanceViewStatus_StatusLevelType = 0
	InstanceViewStatus_Info    InstanceViewStatus_StatusLevelType = 1
	InstanceViewStatus_Warning InstanceViewStatus_StatusLevelType = 2
	InstanceViewStatus_Error   InstanceViewStatus_StatusLevelType = 3
)

var InstanceViewStatus_StatusLevelType_name = map[int32]string{
	0: "Unknown",
	1: "Info",
	2: "Warning",
	3: "Error",
}

var InstanceViewStatus_StatusLevelType_value = map[string]int32{
	"Unknown": 0,
	"Info":    1,
	"Warning": 2,
	"Error":   3,
}

func (x InstanceViewStatus_StatusLevelType) String() string {
	return proto.EnumName(InstanceViewStatus_StatusLevelType_name, int32(x))
}

func (InstanceViewStatus_StatusLevelType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7d1a061f6c82445b, []int{9, 0}
}

type WinRMListener struct {
	Protocol             WinRMProtocolType `protobuf:"varint,1,opt,name=Protocol,proto3,enum=moc.WinRMProtocolType" json:"Protocol,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_WinRMListener proto.InternalMessageInfo

func (m *WinRMListener) GetProtocol() WinRMProtocolType {
	if m != nil {
		return m.Protocol
	}
	return WinRMProtocolType_HTTP
}

type WinRMConfiguration struct {
	Listeners            []*WinRMListener `protobuf:"bytes,1,rep,name=Listeners,proto3" json:"Listeners,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

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

var xxx_messageInfo_WinRMConfiguration proto.InternalMessageInfo

func (m *WinRMConfiguration) GetListeners() []*WinRMListener {
	if m != nil {
		return m.Listeners
	}
	return nil
}

type Gpu struct {
	Assignment           Gpu_AssignmentType `protobuf:"varint,1,opt,name=assignment,proto3,enum=moc.Gpu_AssignmentType" json:"assignment,omitempty"`
	PartitionSizeGB      int32              `protobuf:"varint,2,opt,name=partitionSizeGB,proto3" json:"partitionSizeGB,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

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

var xxx_messageInfo_Gpu proto.InternalMessageInfo

func (m *Gpu) GetAssignment() Gpu_AssignmentType {
	if m != nil {
		return m.Assignment
	}
	return Gpu_GpuDDA
}

func (m *Gpu) GetPartitionSizeGB() int32 {
	if m != nil {
		return m.PartitionSizeGB
	}
	return 0
}

type VirtualMachineCustomSize struct {
	CpuCount             int32    `protobuf:"varint,1,opt,name=cpuCount,proto3" json:"cpuCount,omitempty"`
	MemoryMB             int32    `protobuf:"varint,2,opt,name=memoryMB,proto3" json:"memoryMB,omitempty"`
	GpuCount             int32    `protobuf:"varint,3,opt,name=gpuCount,proto3" json:"gpuCount,omitempty"`
	GpuList              []*Gpu   `protobuf:"bytes,4,rep,name=gpuList,proto3" json:"gpuList,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_VirtualMachineCustomSize proto.InternalMessageInfo

func (m *VirtualMachineCustomSize) GetCpuCount() int32 {
	if m != nil {
		return m.CpuCount
	}
	return 0
}

func (m *VirtualMachineCustomSize) GetMemoryMB() int32 {
	if m != nil {
		return m.MemoryMB
	}
	return 0
}

func (m *VirtualMachineCustomSize) GetGpuCount() int32 {
	if m != nil {
		return m.GpuCount
	}
	return 0
}

func (m *VirtualMachineCustomSize) GetGpuList() []*Gpu {
	if m != nil {
		return m.GpuList
	}
	return nil
}

type DynamicMemoryConfiguration struct {
	MaximumMemoryMB      uint64   `protobuf:"varint,1,opt,name=maximumMemoryMB,proto3" json:"maximumMemoryMB,omitempty"`
	MinimumMemoryMB      uint64   `protobuf:"varint,2,opt,name=minimumMemoryMB,proto3" json:"minimumMemoryMB,omitempty"`
	TargetMemoryBuffer   uint32   `protobuf:"varint,3,opt,name=targetMemoryBuffer,proto3" json:"targetMemoryBuffer,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DynamicMemoryConfiguration proto.InternalMessageInfo

func (m *DynamicMemoryConfiguration) GetMaximumMemoryMB() uint64 {
	if m != nil {
		return m.MaximumMemoryMB
	}
	return 0
}

func (m *DynamicMemoryConfiguration) GetMinimumMemoryMB() uint64 {
	if m != nil {
		return m.MinimumMemoryMB
	}
	return 0
}

func (m *DynamicMemoryConfiguration) GetTargetMemoryBuffer() uint32 {
	if m != nil {
		return m.TargetMemoryBuffer
	}
	return 0
}

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

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

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

var xxx_messageInfo_VirtualMachineRunCommandInputParameter proto.InternalMessageInfo

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

func (m *VirtualMachineRunCommandInputParameter) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type VirtualMachineRunCommandScriptSource struct {
	Script               string   `protobuf:"bytes,1,opt,name=Script,proto3" json:"Script,omitempty"`
	ScriptURI            string   `protobuf:"bytes,2,opt,name=ScriptURI,proto3" json:"ScriptURI,omitempty"`
	CommandID            string   `protobuf:"bytes,3,opt,name=CommandID,proto3" json:"CommandID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_VirtualMachineRunCommandScriptSource proto.InternalMessageInfo

func (m *VirtualMachineRunCommandScriptSource) GetScript() string {
	if m != nil {
		return m.Script
	}
	return ""
}

func (m *VirtualMachineRunCommandScriptSource) GetScriptURI() string {
	if m != nil {
		return m.ScriptURI
	}
	return ""
}

func (m *VirtualMachineRunCommandScriptSource) GetCommandID() string {
	if m != nil {
		return m.CommandID
	}
	return ""
}

type VirtualMachineRunCommandInstanceView struct {
	ExecutionState       VirtualMachineRunCommandExecutionState `protobuf:"varint,1,opt,name=ExecutionState,proto3,enum=moc.VirtualMachineRunCommandExecutionState" json:"ExecutionState,omitempty"`
	ExitCode             int32                                  `protobuf:"varint,2,opt,name=ExitCode,proto3" json:"ExitCode,omitempty"`
	Output               string                                 `protobuf:"bytes,3,opt,name=Output,proto3" json:"Output,omitempty"`
	Error                string                                 `protobuf:"bytes,4,opt,name=Error,proto3" json:"Error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                               `json:"-"`
	XXX_unrecognized     []byte                                 `json:"-"`
	XXX_sizecache        int32                                  `json:"-"`
}

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

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

var xxx_messageInfo_VirtualMachineRunCommandInstanceView proto.InternalMessageInfo

func (m *VirtualMachineRunCommandInstanceView) GetExecutionState() VirtualMachineRunCommandExecutionState {
	if m != nil {
		return m.ExecutionState
	}
	return VirtualMachineRunCommandExecutionState_ExecutionState_UNKNOWN
}

func (m *VirtualMachineRunCommandInstanceView) GetExitCode() int32 {
	if m != nil {
		return m.ExitCode
	}
	return 0
}

func (m *VirtualMachineRunCommandInstanceView) GetOutput() string {
	if m != nil {
		return m.Output
	}
	return ""
}

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

// describes the the capabilities of this node in terms of what type of VM can be created
// In the future when CVM comes, another bool will be added to check hardware capability.
type VirtualMachineCapabilities struct {
	IsolatedVmCapable    bool     `protobuf:"varint,1,opt,name=IsolatedVmCapable,proto3" json:"IsolatedVmCapable,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_VirtualMachineCapabilities proto.InternalMessageInfo

func (m *VirtualMachineCapabilities) GetIsolatedVmCapable() bool {
	if m != nil {
		return m.IsolatedVmCapable
	}
	return false
}

type InstanceViewStatus struct {
	Code                 string                             `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"`
	Level                InstanceViewStatus_StatusLevelType `protobuf:"varint,2,opt,name=level,proto3,enum=moc.InstanceViewStatus_StatusLevelType" json:"level,omitempty"`
	DisplayStatus        string                             `protobuf:"bytes,3,opt,name=displayStatus,proto3" json:"displayStatus,omitempty"`
	Message              string                             `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"`
	Time                 string                             `protobuf:"bytes,5,opt,name=time,proto3" json:"time,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                           `json:"-"`
	XXX_unrecognized     []byte                             `json:"-"`
	XXX_sizecache        int32                              `json:"-"`
}

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

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

var xxx_messageInfo_InstanceViewStatus proto.InternalMessageInfo

func (m *InstanceViewStatus) GetCode() string {
	if m != nil {
		return m.Code
	}
	return ""
}

func (m *InstanceViewStatus) GetLevel() InstanceViewStatus_StatusLevelType {
	if m != nil {
		return m.Level
	}
	return InstanceViewStatus_Unknown
}

func (m *InstanceViewStatus) GetDisplayStatus() string {
	if m != nil {
		return m.DisplayStatus
	}
	return ""
}

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

func (m *InstanceViewStatus) GetTime() string {
	if m != nil {
		return m.Time
	}
	return ""
}

type VirtualMachineAgentInstanceView struct {
	VmAgentVersion       string                `protobuf:"bytes,1,opt,name=vmAgentVersion,proto3" json:"vmAgentVersion,omitempty"`
	Statuses             []*InstanceViewStatus `protobuf:"bytes,2,rep,name=statuses,proto3" json:"statuses,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_VirtualMachineAgentInstanceView proto.InternalMessageInfo

func (m *VirtualMachineAgentInstanceView) GetVmAgentVersion() string {
	if m != nil {
		return m.VmAgentVersion
	}
	return ""
}

func (m *VirtualMachineAgentInstanceView) GetStatuses() []*InstanceViewStatus {
	if m != nil {
		return m.Statuses
	}
	return nil
}

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

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

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

var xxx_messageInfo_GuestAgentConfiguration proto.InternalMessageInfo

func (m *GuestAgentConfiguration) GetEnabled() bool {
	if m != nil {
		return m.Enabled
	}
	return false
}

type ProxyConfiguration struct {
	HttpProxy            string   `protobuf:"bytes,1,opt,name=httpProxy,proto3" json:"httpProxy,omitempty"`
	HttpsProxy           string   `protobuf:"bytes,2,opt,name=httpsProxy,proto3" json:"httpsProxy,omitempty"`
	NoProxy              []string `protobuf:"bytes,3,rep,name=noProxy,proto3" json:"noProxy,omitempty"`
	TrustedCa            string   `protobuf:"bytes,4,opt,name=trustedCa,proto3" json:"trustedCa,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ProxyConfiguration proto.InternalMessageInfo

func (m *ProxyConfiguration) GetHttpProxy() string {
	if m != nil {
		return m.HttpProxy
	}
	return ""
}

func (m *ProxyConfiguration) GetHttpsProxy() string {
	if m != nil {
		return m.HttpsProxy
	}
	return ""
}

func (m *ProxyConfiguration) GetNoProxy() []string {
	if m != nil {
		return m.NoProxy
	}
	return nil
}

func (m *ProxyConfiguration) GetTrustedCa() string {
	if m != nil {
		return m.TrustedCa
	}
	return ""
}

var E_Sensitivecompute = &proto.ExtensionDesc{
	ExtendedType:  (*descriptor.FieldOptions)(nil),
	ExtensionType: (*bool)(nil),
	Field:         50002,
	Name:          "moc.sensitivecompute",
	Tag:           "varint,50002,opt,name=sensitivecompute",
	Filename:      "moc_common_computecommon.proto",
}

var E_Sensitivejson = &proto.ExtensionDesc{
	ExtendedType:  (*descriptor.FieldOptions)(nil),
	ExtensionType: (*bool)(nil),
	Field:         50003,
	Name:          "moc.sensitivejson",
	Tag:           "varint,50003,opt,name=sensitivejson",
	Filename:      "moc_common_computecommon.proto",
}

func init() {
	proto.RegisterEnum("moc.UserType", UserType_name, UserType_value)
	proto.RegisterEnum("moc.ProcessorType", ProcessorType_name, ProcessorType_value)
	proto.RegisterEnum("moc.OperatingSystemBootstrapEngine", OperatingSystemBootstrapEngine_name, OperatingSystemBootstrapEngine_value)
	proto.RegisterEnum("moc.OperatingSystemType", OperatingSystemType_name, OperatingSystemType_value)
	proto.RegisterEnum("moc.VirtualMachineSizeType", VirtualMachineSizeType_name, VirtualMachineSizeType_value)
	proto.RegisterEnum("moc.WinRMProtocolType", WinRMProtocolType_name, WinRMProtocolType_value)
	proto.RegisterEnum("moc.PowerState", PowerState_name, PowerState_value)
	proto.RegisterEnum("moc.VirtualMachineOperation", VirtualMachineOperation_name, VirtualMachineOperation_value)
	proto.RegisterEnum("moc.VirtualMachineRunCommandExecutionState", VirtualMachineRunCommandExecutionState_name, VirtualMachineRunCommandExecutionState_value)
	proto.RegisterEnum("moc.Architecture", Architecture_name, Architecture_value)
	proto.RegisterEnum("moc.SecurityType", SecurityType_name, SecurityType_value)
	proto.RegisterEnum("moc.Gpu_AssignmentType", Gpu_AssignmentType_name, Gpu_AssignmentType_value)
	proto.RegisterEnum("moc.InstanceViewStatus_StatusLevelType", InstanceViewStatus_StatusLevelType_name, InstanceViewStatus_StatusLevelType_value)
	proto.RegisterType((*WinRMListener)(nil), "moc.WinRMListener")
	proto.RegisterType((*WinRMConfiguration)(nil), "moc.WinRMConfiguration")
	proto.RegisterType((*Gpu)(nil), "moc.Gpu")
	proto.RegisterType((*VirtualMachineCustomSize)(nil), "moc.VirtualMachineCustomSize")
	proto.RegisterType((*DynamicMemoryConfiguration)(nil), "moc.DynamicMemoryConfiguration")
	proto.RegisterType((*VirtualMachineRunCommandInputParameter)(nil), "moc.VirtualMachineRunCommandInputParameter")
	proto.RegisterType((*VirtualMachineRunCommandScriptSource)(nil), "moc.VirtualMachineRunCommandScriptSource")
	proto.RegisterType((*VirtualMachineRunCommandInstanceView)(nil), "moc.VirtualMachineRunCommandInstanceView")
	proto.RegisterType((*VirtualMachineCapabilities)(nil), "moc.VirtualMachineCapabilities")
	proto.RegisterType((*InstanceViewStatus)(nil), "moc.InstanceViewStatus")
	proto.RegisterType((*VirtualMachineAgentInstanceView)(nil), "moc.VirtualMachineAgentInstanceView")
	proto.RegisterType((*GuestAgentConfiguration)(nil), "moc.GuestAgentConfiguration")
	proto.RegisterType((*ProxyConfiguration)(nil), "moc.ProxyConfiguration")
	proto.RegisterExtension(E_Sensitivecompute)
	proto.RegisterExtension(E_Sensitivejson)
}

func init() { proto.RegisterFile("moc_common_computecommon.proto", fileDescriptor_7d1a061f6c82445b) }

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