//
//Copyright 2025 Google LLC
//
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//
//https://www.apache.org/licenses/LICENSE-2.0
//
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.12
// 	protoc        v3.21.12
// source: isvdiscovery/definition/definition.proto

package proto

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// These will match to a bundled executable within the extension to run to
// gather version information
// DO NOT ADD NEW COMMANDS TO THIS ENUM.  USE EXTENDED_VERSION_COMMAND INSTEAD
// TO AVOID INDEX OUT OF BOUNDS PANICS ON OLDER VERSIONS OF THE EXTENSION.
type VersionCommand int32

const (
	VersionCommand_VERSION_COMMAND_UNSPECIFIED VersionCommand = 0
	VersionCommand_CAT                         VersionCommand = 1
	VersionCommand_APACHE2                     VersionCommand = 2
	VersionCommand_HTTPD                       VersionCommand = 3
	VersionCommand_POSTGRES                    VersionCommand = 4
	VersionCommand_PSQL                        VersionCommand = 5
	VersionCommand_NODETOOL                    VersionCommand = 6
	VersionCommand_MONGOD                      VersionCommand = 7
	VersionCommand_MYSQLD                      VersionCommand = 8
	VersionCommand_SQLPLUS                     VersionCommand = 9
	VersionCommand_REDISSERVER                 VersionCommand = 10
	VersionCommand_MARIADB                     VersionCommand = 11
	VersionCommand_GWRD                        VersionCommand = 12
	VersionCommand_GREP                        VersionCommand = 13
	VersionCommand_GETCOMMAND                  VersionCommand = 14
	VersionCommand_IQ15                        VersionCommand = 15
	VersionCommand_IQ16                        VersionCommand = 16
	VersionCommand_IQ15WINDOWS                 VersionCommand = 17
	VersionCommand_IQ16WINDOWS                 VersionCommand = 18
	// Deprecated: Marked as deprecated in isvdiscovery/definition/definition.proto.
	VersionCommand_FINDSAPWEBAS                VersionCommand = 19 // Deprecated: This command is not in use.
	VersionCommand_PACEMAKERD                  VersionCommand = 20
	VersionCommand_SQLSERVR                    VersionCommand = 21
	VersionCommand_GETITEMPROPERTYVALUE        VersionCommand = 22
	VersionCommand_OPATCH                      VersionCommand = 23
	VersionCommand_DGMGRL                      VersionCommand = 24
	VersionCommand_JAVA                        VersionCommand = 25
	VersionCommand_GGSCI                       VersionCommand = 26
	VersionCommand_PSADMIN                     VersionCommand = 27
	VersionCommand_HDBLCM                      VersionCommand = 28
	VersionCommand_MYSQL                       VersionCommand = 29
	VersionCommand_CASSANDRA_NODETOOL          VersionCommand = 30
	VersionCommand_SBIN_NODETOOL               VersionCommand = 31
	VersionCommand_SQLSERVR_PATH               VersionCommand = 32
	VersionCommand_USE_DISCOVERED_PROCESS_PATH VersionCommand = 33
)

// Enum value maps for VersionCommand.
var (
	VersionCommand_name = map[int32]string{
		0:  "VERSION_COMMAND_UNSPECIFIED",
		1:  "CAT",
		2:  "APACHE2",
		3:  "HTTPD",
		4:  "POSTGRES",
		5:  "PSQL",
		6:  "NODETOOL",
		7:  "MONGOD",
		8:  "MYSQLD",
		9:  "SQLPLUS",
		10: "REDISSERVER",
		11: "MARIADB",
		12: "GWRD",
		13: "GREP",
		14: "GETCOMMAND",
		15: "IQ15",
		16: "IQ16",
		17: "IQ15WINDOWS",
		18: "IQ16WINDOWS",
		19: "FINDSAPWEBAS",
		20: "PACEMAKERD",
		21: "SQLSERVR",
		22: "GETITEMPROPERTYVALUE",
		23: "OPATCH",
		24: "DGMGRL",
		25: "JAVA",
		26: "GGSCI",
		27: "PSADMIN",
		28: "HDBLCM",
		29: "MYSQL",
		30: "CASSANDRA_NODETOOL",
		31: "SBIN_NODETOOL",
		32: "SQLSERVR_PATH",
		33: "USE_DISCOVERED_PROCESS_PATH",
	}
	VersionCommand_value = map[string]int32{
		"VERSION_COMMAND_UNSPECIFIED": 0,
		"CAT":                         1,
		"APACHE2":                     2,
		"HTTPD":                       3,
		"POSTGRES":                    4,
		"PSQL":                        5,
		"NODETOOL":                    6,
		"MONGOD":                      7,
		"MYSQLD":                      8,
		"SQLPLUS":                     9,
		"REDISSERVER":                 10,
		"MARIADB":                     11,
		"GWRD":                        12,
		"GREP":                        13,
		"GETCOMMAND":                  14,
		"IQ15":                        15,
		"IQ16":                        16,
		"IQ15WINDOWS":                 17,
		"IQ16WINDOWS":                 18,
		"FINDSAPWEBAS":                19,
		"PACEMAKERD":                  20,
		"SQLSERVR":                    21,
		"GETITEMPROPERTYVALUE":        22,
		"OPATCH":                      23,
		"DGMGRL":                      24,
		"JAVA":                        25,
		"GGSCI":                       26,
		"PSADMIN":                     27,
		"HDBLCM":                      28,
		"MYSQL":                       29,
		"CASSANDRA_NODETOOL":          30,
		"SBIN_NODETOOL":               31,
		"SQLSERVR_PATH":               32,
		"USE_DISCOVERED_PROCESS_PATH": 33,
	}
)

func (x VersionCommand) Enum() *VersionCommand {
	p := new(VersionCommand)
	*p = x
	return p
}

func (x VersionCommand) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (VersionCommand) Descriptor() protoreflect.EnumDescriptor {
	return file_isvdiscovery_definition_definition_proto_enumTypes[0].Descriptor()
}

func (VersionCommand) Type() protoreflect.EnumType {
	return &file_isvdiscovery_definition_definition_proto_enumTypes[0]
}

func (x VersionCommand) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Extended version commands to be used to gather version information.
// Any new version commands should be added to this enum.
// This avoids index out of bounds panics on older versions of the extension.
type ExtendedVersionCommand int32

const (
	ExtendedVersionCommand_EXTENDED_VERSION_COMMAND_UNSPECIFIED ExtendedVersionCommand = 0
	ExtendedVersionCommand_HDB                                  ExtendedVersionCommand = 1
	ExtendedVersionCommand_DISP_WORK                            ExtendedVersionCommand = 2
	ExtendedVersionCommand_MSG_SERVER                           ExtendedVersionCommand = 3
	ExtendedVersionCommand_EN_SERVER                            ExtendedVersionCommand = 4
	ExtendedVersionCommand_AWK                                  ExtendedVersionCommand = 5
	ExtendedVersionCommand_SAPWEBDISP                           ExtendedVersionCommand = 6
	ExtendedVersionCommand_START_IQ                             ExtendedVersionCommand = 7
	ExtendedVersionCommand_ENREP                                ExtendedVersionCommand = 8
	ExtendedVersionCommand_SPARK_SUBMIT                         ExtendedVersionCommand = 9
	ExtendedVersionCommand_SPARK_SUBMIT_PATH                    ExtendedVersionCommand = 10
	ExtendedVersionCommand_CRICTL                               ExtendedVersionCommand = 11
	ExtendedVersionCommand_HADOOP                               ExtendedVersionCommand = 12
	ExtendedVersionCommand_HADOOP_PATH                          ExtendedVersionCommand = 13
	ExtendedVersionCommand_DPKG                                 ExtendedVersionCommand = 14
	ExtendedVersionCommand_RPM                                  ExtendedVersionCommand = 15
	ExtendedVersionCommand_GETPACKAGE                           ExtendedVersionCommand = 16
)

// Enum value maps for ExtendedVersionCommand.
var (
	ExtendedVersionCommand_name = map[int32]string{
		0:  "EXTENDED_VERSION_COMMAND_UNSPECIFIED",
		1:  "HDB",
		2:  "DISP_WORK",
		3:  "MSG_SERVER",
		4:  "EN_SERVER",
		5:  "AWK",
		6:  "SAPWEBDISP",
		7:  "START_IQ",
		8:  "ENREP",
		9:  "SPARK_SUBMIT",
		10: "SPARK_SUBMIT_PATH",
		11: "CRICTL",
		12: "HADOOP",
		13: "HADOOP_PATH",
		14: "DPKG",
		15: "RPM",
		16: "GETPACKAGE",
	}
	ExtendedVersionCommand_value = map[string]int32{
		"EXTENDED_VERSION_COMMAND_UNSPECIFIED": 0,
		"HDB":                                  1,
		"DISP_WORK":                            2,
		"MSG_SERVER":                           3,
		"EN_SERVER":                            4,
		"AWK":                                  5,
		"SAPWEBDISP":                           6,
		"START_IQ":                             7,
		"ENREP":                                8,
		"SPARK_SUBMIT":                         9,
		"SPARK_SUBMIT_PATH":                    10,
		"CRICTL":                               11,
		"HADOOP":                               12,
		"HADOOP_PATH":                          13,
		"DPKG":                                 14,
		"RPM":                                  15,
		"GETPACKAGE":                           16,
	}
)

func (x ExtendedVersionCommand) Enum() *ExtendedVersionCommand {
	p := new(ExtendedVersionCommand)
	*p = x
	return p
}

func (x ExtendedVersionCommand) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (ExtendedVersionCommand) Descriptor() protoreflect.EnumDescriptor {
	return file_isvdiscovery_definition_definition_proto_enumTypes[1].Descriptor()
}

func (ExtendedVersionCommand) Type() protoreflect.EnumType {
	return &file_isvdiscovery_definition_definition_proto_enumTypes[1]
}

func (x ExtendedVersionCommand) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Which of the fields should be matched.
type StringMatchCondition_VmField int32

const (
	StringMatchCondition_VM_FIELD_UNSPECIFIED StringMatchCondition_VmField = 0
	StringMatchCondition_VM_PROCESS_NAME      StringMatchCondition_VmField = 1
	StringMatchCondition_VM_PROCESS_PATH      StringMatchCondition_VmField = 2
	StringMatchCondition_VM_OS_NAME           StringMatchCondition_VmField = 3
	StringMatchCondition_VM_CLI_ARGS          StringMatchCondition_VmField = 4
	StringMatchCondition_VM_ENV_VARS          StringMatchCondition_VmField = 5
)

// Enum value maps for StringMatchCondition_VmField.
var (
	StringMatchCondition_VmField_name = map[int32]string{
		0: "VM_FIELD_UNSPECIFIED",
		1: "VM_PROCESS_NAME",
		2: "VM_PROCESS_PATH",
		3: "VM_OS_NAME",
		4: "VM_CLI_ARGS",
		5: "VM_ENV_VARS",
	}
	StringMatchCondition_VmField_value = map[string]int32{
		"VM_FIELD_UNSPECIFIED": 0,
		"VM_PROCESS_NAME":      1,
		"VM_PROCESS_PATH":      2,
		"VM_OS_NAME":           3,
		"VM_CLI_ARGS":          4,
		"VM_ENV_VARS":          5,
	}
)

func (x StringMatchCondition_VmField) Enum() *StringMatchCondition_VmField {
	p := new(StringMatchCondition_VmField)
	*p = x
	return p
}

func (x StringMatchCondition_VmField) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (StringMatchCondition_VmField) Descriptor() protoreflect.EnumDescriptor {
	return file_isvdiscovery_definition_definition_proto_enumTypes[2].Descriptor()
}

func (StringMatchCondition_VmField) Type() protoreflect.EnumType {
	return &file_isvdiscovery_definition_definition_proto_enumTypes[2]
}

func (x StringMatchCondition_VmField) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Request to get the discovery rules for the agent.
type GetDiscoveryRulesRequest struct {
	state         protoimpl.MessageState `protogen:"opaque.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetDiscoveryRulesRequest) Reset() {
	*x = GetDiscoveryRulesRequest{}
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetDiscoveryRulesRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetDiscoveryRulesRequest) ProtoMessage() {}

func (x *GetDiscoveryRulesRequest) ProtoReflect() protoreflect.Message {
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

type GetDiscoveryRulesRequest_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

}

func (b0 GetDiscoveryRulesRequest_builder) Build() *GetDiscoveryRulesRequest {
	m0 := &GetDiscoveryRulesRequest{}
	b, x := &b0, m0
	_, _ = b, x
	return m0
}

type DiscoveryConfiguration struct {
	state                                      protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_ScanIntervalSeconds             int32                  `protobuf:"varint,1,opt,name=scan_interval_seconds,json=scanIntervalSeconds,proto3"`
	xxx_hidden_MinimumReportingIntervalSeconds int32                  `protobuf:"varint,2,opt,name=minimum_reporting_interval_seconds,json=minimumReportingIntervalSeconds,proto3"`
	unknownFields                              protoimpl.UnknownFields
	sizeCache                                  protoimpl.SizeCache
}

func (x *DiscoveryConfiguration) Reset() {
	*x = DiscoveryConfiguration{}
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DiscoveryConfiguration) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DiscoveryConfiguration) ProtoMessage() {}

func (x *DiscoveryConfiguration) ProtoReflect() protoreflect.Message {
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *DiscoveryConfiguration) GetScanIntervalSeconds() int32 {
	if x != nil {
		return x.xxx_hidden_ScanIntervalSeconds
	}
	return 0
}

func (x *DiscoveryConfiguration) GetMinimumReportingIntervalSeconds() int32 {
	if x != nil {
		return x.xxx_hidden_MinimumReportingIntervalSeconds
	}
	return 0
}

func (x *DiscoveryConfiguration) SetScanIntervalSeconds(v int32) {
	x.xxx_hidden_ScanIntervalSeconds = v
}

func (x *DiscoveryConfiguration) SetMinimumReportingIntervalSeconds(v int32) {
	x.xxx_hidden_MinimumReportingIntervalSeconds = v
}

type DiscoveryConfiguration_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	// Interval between agent scans in seconds.
	// Default: 15 minutes = 15 * 60.
	ScanIntervalSeconds int32
	// Minimum reporting interval between agent scans in seconds.
	// This is also the frequency of fetching the discovery rules from the
	// backend. Default: 24 hours = 24 * 60 * 60.
	MinimumReportingIntervalSeconds int32
}

func (b0 DiscoveryConfiguration_builder) Build() *DiscoveryConfiguration {
	m0 := &DiscoveryConfiguration{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_ScanIntervalSeconds = b.ScanIntervalSeconds
	x.xxx_hidden_MinimumReportingIntervalSeconds = b.MinimumReportingIntervalSeconds
	return m0
}

// Request containing the rules to be used for discovery.
type DiscoveryRules struct {
	state             protoimpl.MessageState  `protogen:"opaque.v1"`
	xxx_hidden_Rules  *[]*DiscoveryRule       `protobuf:"bytes,1,rep,name=rules,proto3"`
	xxx_hidden_Config *DiscoveryConfiguration `protobuf:"bytes,2,opt,name=config,proto3"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

func (x *DiscoveryRules) Reset() {
	*x = DiscoveryRules{}
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DiscoveryRules) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DiscoveryRules) ProtoMessage() {}

func (x *DiscoveryRules) ProtoReflect() protoreflect.Message {
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *DiscoveryRules) GetRules() []*DiscoveryRule {
	if x != nil {
		if x.xxx_hidden_Rules != nil {
			return *x.xxx_hidden_Rules
		}
	}
	return nil
}

func (x *DiscoveryRules) GetConfig() *DiscoveryConfiguration {
	if x != nil {
		return x.xxx_hidden_Config
	}
	return nil
}

func (x *DiscoveryRules) SetRules(v []*DiscoveryRule) {
	x.xxx_hidden_Rules = &v
}

func (x *DiscoveryRules) SetConfig(v *DiscoveryConfiguration) {
	x.xxx_hidden_Config = v
}

func (x *DiscoveryRules) HasConfig() bool {
	if x == nil {
		return false
	}
	return x.xxx_hidden_Config != nil
}

func (x *DiscoveryRules) ClearConfig() {
	x.xxx_hidden_Config = nil
}

type DiscoveryRules_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Rules  []*DiscoveryRule
	Config *DiscoveryConfiguration
}

func (b0 DiscoveryRules_builder) Build() *DiscoveryRules {
	m0 := &DiscoveryRules{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Rules = &b.Rules
	x.xxx_hidden_Config = b.Config
	return m0
}

// Rule used for classification.
//
// Multiple different conditions can be nested using any and all, e.g.:
//
//	all: {
//	  any: {
//	    all: {
//	      conditions: {}
//	      conditions: {}
//	    }
//	    conditions: {}
//	  }
//	  conditions: {}
//	}
type DiscoveryRule struct {
	state                             protoimpl.MessageState   `protogen:"opaque.v1"`
	xxx_hidden_Id                     string                   `protobuf:"bytes,1,opt,name=id,proto3"`
	xxx_hidden_Rule                   isDiscoveryRule_Rule     `protobuf_oneof:"rule"`
	xxx_hidden_VersionRules           *[]*DiscoveryVersionRule `protobuf:"bytes,6,rep,name=version_rules,json=versionRules,proto3"`
	xxx_hidden_DiscoveredWorkloadName string                   `protobuf:"bytes,7,opt,name=discovered_workload_name,json=discoveredWorkloadName,proto3"`
	xxx_hidden_DisplayName            string                   `protobuf:"bytes,8,opt,name=display_name,json=displayName,proto3"`
	unknownFields                     protoimpl.UnknownFields
	sizeCache                         protoimpl.SizeCache
}

func (x *DiscoveryRule) Reset() {
	*x = DiscoveryRule{}
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DiscoveryRule) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DiscoveryRule) ProtoMessage() {}

func (x *DiscoveryRule) ProtoReflect() protoreflect.Message {
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *DiscoveryRule) GetId() string {
	if x != nil {
		return x.xxx_hidden_Id
	}
	return ""
}

func (x *DiscoveryRule) GetCondition() *Condition {
	if x != nil {
		if x, ok := x.xxx_hidden_Rule.(*discoveryRule_Condition); ok {
			return x.Condition
		}
	}
	return nil
}

func (x *DiscoveryRule) GetAll() *AllCondition {
	if x != nil {
		if x, ok := x.xxx_hidden_Rule.(*discoveryRule_All); ok {
			return x.All
		}
	}
	return nil
}

func (x *DiscoveryRule) GetAny() *AnyCondition {
	if x != nil {
		if x, ok := x.xxx_hidden_Rule.(*discoveryRule_Any); ok {
			return x.Any
		}
	}
	return nil
}

func (x *DiscoveryRule) GetVersionRules() []*DiscoveryVersionRule {
	if x != nil {
		if x.xxx_hidden_VersionRules != nil {
			return *x.xxx_hidden_VersionRules
		}
	}
	return nil
}

func (x *DiscoveryRule) GetDiscoveredWorkloadName() string {
	if x != nil {
		return x.xxx_hidden_DiscoveredWorkloadName
	}
	return ""
}

func (x *DiscoveryRule) GetDisplayName() string {
	if x != nil {
		return x.xxx_hidden_DisplayName
	}
	return ""
}

func (x *DiscoveryRule) SetId(v string) {
	x.xxx_hidden_Id = v
}

func (x *DiscoveryRule) SetCondition(v *Condition) {
	if v == nil {
		x.xxx_hidden_Rule = nil
		return
	}
	x.xxx_hidden_Rule = &discoveryRule_Condition{v}
}

func (x *DiscoveryRule) SetAll(v *AllCondition) {
	if v == nil {
		x.xxx_hidden_Rule = nil
		return
	}
	x.xxx_hidden_Rule = &discoveryRule_All{v}
}

func (x *DiscoveryRule) SetAny(v *AnyCondition) {
	if v == nil {
		x.xxx_hidden_Rule = nil
		return
	}
	x.xxx_hidden_Rule = &discoveryRule_Any{v}
}

func (x *DiscoveryRule) SetVersionRules(v []*DiscoveryVersionRule) {
	x.xxx_hidden_VersionRules = &v
}

func (x *DiscoveryRule) SetDiscoveredWorkloadName(v string) {
	x.xxx_hidden_DiscoveredWorkloadName = v
}

func (x *DiscoveryRule) SetDisplayName(v string) {
	x.xxx_hidden_DisplayName = v
}

func (x *DiscoveryRule) HasRule() bool {
	if x == nil {
		return false
	}
	return x.xxx_hidden_Rule != nil
}

func (x *DiscoveryRule) HasCondition() bool {
	if x == nil {
		return false
	}
	_, ok := x.xxx_hidden_Rule.(*discoveryRule_Condition)
	return ok
}

func (x *DiscoveryRule) HasAll() bool {
	if x == nil {
		return false
	}
	_, ok := x.xxx_hidden_Rule.(*discoveryRule_All)
	return ok
}

func (x *DiscoveryRule) HasAny() bool {
	if x == nil {
		return false
	}
	_, ok := x.xxx_hidden_Rule.(*discoveryRule_Any)
	return ok
}

func (x *DiscoveryRule) ClearRule() {
	x.xxx_hidden_Rule = nil
}

func (x *DiscoveryRule) ClearCondition() {
	if _, ok := x.xxx_hidden_Rule.(*discoveryRule_Condition); ok {
		x.xxx_hidden_Rule = nil
	}
}

func (x *DiscoveryRule) ClearAll() {
	if _, ok := x.xxx_hidden_Rule.(*discoveryRule_All); ok {
		x.xxx_hidden_Rule = nil
	}
}

func (x *DiscoveryRule) ClearAny() {
	if _, ok := x.xxx_hidden_Rule.(*discoveryRule_Any); ok {
		x.xxx_hidden_Rule = nil
	}
}

const DiscoveryRule_Rule_not_set_case case_DiscoveryRule_Rule = 0
const DiscoveryRule_Condition_case case_DiscoveryRule_Rule = 3
const DiscoveryRule_All_case case_DiscoveryRule_Rule = 4
const DiscoveryRule_Any_case case_DiscoveryRule_Rule = 5

func (x *DiscoveryRule) WhichRule() case_DiscoveryRule_Rule {
	if x == nil {
		return DiscoveryRule_Rule_not_set_case
	}
	switch x.xxx_hidden_Rule.(type) {
	case *discoveryRule_Condition:
		return DiscoveryRule_Condition_case
	case *discoveryRule_All:
		return DiscoveryRule_All_case
	case *discoveryRule_Any:
		return DiscoveryRule_Any_case
	default:
		return DiscoveryRule_Rule_not_set_case
	}
}

type DiscoveryRule_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	// Unique rule identifier.
	Id string
	// Rule is a simple condition or .

	// Fields of oneof xxx_hidden_Rule:
	// Single simple condition.
	Condition *Condition
	// All of the nested conditions must be satisfied.
	All *AllCondition
	// Any of the nested conditions must be satisfied.
	Any *AnyCondition
	// -- end of xxx_hidden_Rule
	// Use the result from the first version rule that successfully retrieves a
	// version.
	VersionRules []*DiscoveryVersionRule
	// Internal name used to reference the workload.
	DiscoveredWorkloadName string
	// User-friendly name of the workload.
	DisplayName string
}

func (b0 DiscoveryRule_builder) Build() *DiscoveryRule {
	m0 := &DiscoveryRule{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Id = b.Id
	if b.Condition != nil {
		x.xxx_hidden_Rule = &discoveryRule_Condition{b.Condition}
	}
	if b.All != nil {
		x.xxx_hidden_Rule = &discoveryRule_All{b.All}
	}
	if b.Any != nil {
		x.xxx_hidden_Rule = &discoveryRule_Any{b.Any}
	}
	x.xxx_hidden_VersionRules = &b.VersionRules
	x.xxx_hidden_DiscoveredWorkloadName = b.DiscoveredWorkloadName
	x.xxx_hidden_DisplayName = b.DisplayName
	return m0
}

type case_DiscoveryRule_Rule protoreflect.FieldNumber

func (x case_DiscoveryRule_Rule) String() string {
	md := file_isvdiscovery_definition_definition_proto_msgTypes[3].Descriptor()
	if x == 0 {
		return "not set"
	}
	return protoimpl.X.MessageFieldStringOf(md, protoreflect.FieldNumber(x))
}

type isDiscoveryRule_Rule interface {
	isDiscoveryRule_Rule()
}

type discoveryRule_Condition struct {
	// Single simple condition.
	Condition *Condition `protobuf:"bytes,3,opt,name=condition,proto3,oneof"`
}

type discoveryRule_All struct {
	// All of the nested conditions must be satisfied.
	All *AllCondition `protobuf:"bytes,4,opt,name=all,proto3,oneof"`
}

type discoveryRule_Any struct {
	// Any of the nested conditions must be satisfied.
	Any *AnyCondition `protobuf:"bytes,5,opt,name=any,proto3,oneof"`
}

func (*discoveryRule_Condition) isDiscoveryRule_Rule() {}

func (*discoveryRule_All) isDiscoveryRule_Rule() {}

func (*discoveryRule_Any) isDiscoveryRule_Rule() {}

// One of the composed conditions which requires that all of the subconditions
// must be satisfied.
type AllCondition struct {
	state                 protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Any        *AnyCondition          `protobuf:"bytes,1,opt,name=any,proto3,oneof"`
	xxx_hidden_Conditions *[]*Condition          `protobuf:"bytes,2,rep,name=conditions,proto3"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

func (x *AllCondition) Reset() {
	*x = AllCondition{}
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AllCondition) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AllCondition) ProtoMessage() {}

func (x *AllCondition) ProtoReflect() protoreflect.Message {
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *AllCondition) GetAny() *AnyCondition {
	if x != nil {
		return x.xxx_hidden_Any
	}
	return nil
}

func (x *AllCondition) GetConditions() []*Condition {
	if x != nil {
		if x.xxx_hidden_Conditions != nil {
			return *x.xxx_hidden_Conditions
		}
	}
	return nil
}

func (x *AllCondition) SetAny(v *AnyCondition) {
	x.xxx_hidden_Any = v
}

func (x *AllCondition) SetConditions(v []*Condition) {
	x.xxx_hidden_Conditions = &v
}

func (x *AllCondition) HasAny() bool {
	if x == nil {
		return false
	}
	return x.xxx_hidden_Any != nil
}

func (x *AllCondition) ClearAny() {
	x.xxx_hidden_Any = nil
}

type AllCondition_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	// Allows further nesting of conditions.
	Any *AnyCondition
	// All of these subconditions must be satisfied.
	Conditions []*Condition
}

func (b0 AllCondition_builder) Build() *AllCondition {
	m0 := &AllCondition{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Any = b.Any
	x.xxx_hidden_Conditions = &b.Conditions
	return m0
}

// One of the composed conditions which requires that any of the subconditions
// must be satisfied.
type AnyCondition struct {
	state                 protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_All        *AllCondition          `protobuf:"bytes,1,opt,name=all,proto3,oneof"`
	xxx_hidden_Conditions *[]*Condition          `protobuf:"bytes,2,rep,name=conditions,proto3"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

func (x *AnyCondition) Reset() {
	*x = AnyCondition{}
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AnyCondition) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AnyCondition) ProtoMessage() {}

func (x *AnyCondition) ProtoReflect() protoreflect.Message {
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *AnyCondition) GetAll() *AllCondition {
	if x != nil {
		return x.xxx_hidden_All
	}
	return nil
}

func (x *AnyCondition) GetConditions() []*Condition {
	if x != nil {
		if x.xxx_hidden_Conditions != nil {
			return *x.xxx_hidden_Conditions
		}
	}
	return nil
}

func (x *AnyCondition) SetAll(v *AllCondition) {
	x.xxx_hidden_All = v
}

func (x *AnyCondition) SetConditions(v []*Condition) {
	x.xxx_hidden_Conditions = &v
}

func (x *AnyCondition) HasAll() bool {
	if x == nil {
		return false
	}
	return x.xxx_hidden_All != nil
}

func (x *AnyCondition) ClearAll() {
	x.xxx_hidden_All = nil
}

type AnyCondition_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	// Allows further nesting of conditions.
	All *AllCondition
	// Any of these subconditions must be satisfied.
	Conditions []*Condition
}

func (b0 AnyCondition_builder) Build() *AnyCondition {
	m0 := &AnyCondition{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_All = b.All
	x.xxx_hidden_Conditions = &b.Conditions
	return m0
}

// One of the rule's conditions.
type Condition struct {
	state                protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Condition isCondition_Condition  `protobuf_oneof:"condition"`
	xxx_hidden_Negated   bool                   `protobuf:"varint,3,opt,name=negated,proto3"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

func (x *Condition) Reset() {
	*x = Condition{}
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Condition) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Condition) ProtoMessage() {}

func (x *Condition) ProtoReflect() protoreflect.Message {
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *Condition) GetStringMatch() *StringMatchCondition {
	if x != nil {
		if x, ok := x.xxx_hidden_Condition.(*condition_StringMatch); ok {
			return x.StringMatch
		}
	}
	return nil
}

func (x *Condition) GetNegated() bool {
	if x != nil {
		return x.xxx_hidden_Negated
	}
	return false
}

func (x *Condition) SetStringMatch(v *StringMatchCondition) {
	if v == nil {
		x.xxx_hidden_Condition = nil
		return
	}
	x.xxx_hidden_Condition = &condition_StringMatch{v}
}

func (x *Condition) SetNegated(v bool) {
	x.xxx_hidden_Negated = v
}

func (x *Condition) HasCondition() bool {
	if x == nil {
		return false
	}
	return x.xxx_hidden_Condition != nil
}

func (x *Condition) HasStringMatch() bool {
	if x == nil {
		return false
	}
	_, ok := x.xxx_hidden_Condition.(*condition_StringMatch)
	return ok
}

func (x *Condition) ClearCondition() {
	x.xxx_hidden_Condition = nil
}

func (x *Condition) ClearStringMatch() {
	if _, ok := x.xxx_hidden_Condition.(*condition_StringMatch); ok {
		x.xxx_hidden_Condition = nil
	}
}

const Condition_Condition_not_set_case case_Condition_Condition = 0
const Condition_StringMatch_case case_Condition_Condition = 1

func (x *Condition) WhichCondition() case_Condition_Condition {
	if x == nil {
		return Condition_Condition_not_set_case
	}
	switch x.xxx_hidden_Condition.(type) {
	case *condition_StringMatch:
		return Condition_StringMatch_case
	default:
		return Condition_Condition_not_set_case
	}
}

type Condition_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	// Fields of oneof xxx_hidden_Condition:
	StringMatch *StringMatchCondition
	// -- end of xxx_hidden_Condition
	// Negates the result of the condition.
	Negated bool
}

func (b0 Condition_builder) Build() *Condition {
	m0 := &Condition{}
	b, x := &b0, m0
	_, _ = b, x
	if b.StringMatch != nil {
		x.xxx_hidden_Condition = &condition_StringMatch{b.StringMatch}
	}
	x.xxx_hidden_Negated = b.Negated
	return m0
}

type case_Condition_Condition protoreflect.FieldNumber

func (x case_Condition_Condition) String() string {
	md := file_isvdiscovery_definition_definition_proto_msgTypes[6].Descriptor()
	if x == 0 {
		return "not set"
	}
	return protoimpl.X.MessageFieldStringOf(md, protoreflect.FieldNumber(x))
}

type isCondition_Condition interface {
	isCondition_Condition()
}

type condition_StringMatch struct {
	StringMatch *StringMatchCondition `protobuf:"bytes,1,opt,name=string_match,json=stringMatch,proto3,oneof"`
}

func (*condition_StringMatch) isCondition_Condition() {}

// Generic string matching condition.
type StringMatchCondition struct {
	state                 protoimpl.MessageState        `protogen:"opaque.v1"`
	xxx_hidden_Fields     isStringMatchCondition_Fields `protobuf_oneof:"fields"`
	xxx_hidden_RegexMatch string                        `protobuf:"bytes,2,opt,name=regex_match,json=regexMatch,proto3"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

func (x *StringMatchCondition) Reset() {
	*x = StringMatchCondition{}
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *StringMatchCondition) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*StringMatchCondition) ProtoMessage() {}

func (x *StringMatchCondition) ProtoReflect() protoreflect.Message {
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *StringMatchCondition) GetVmField() StringMatchCondition_VmField {
	if x != nil {
		if x, ok := x.xxx_hidden_Fields.(*stringMatchCondition_VmField_); ok {
			return x.VmField
		}
	}
	return StringMatchCondition_VM_FIELD_UNSPECIFIED
}

func (x *StringMatchCondition) GetRegexMatch() string {
	if x != nil {
		return x.xxx_hidden_RegexMatch
	}
	return ""
}

func (x *StringMatchCondition) SetVmField(v StringMatchCondition_VmField) {
	x.xxx_hidden_Fields = &stringMatchCondition_VmField_{v}
}

func (x *StringMatchCondition) SetRegexMatch(v string) {
	x.xxx_hidden_RegexMatch = v
}

func (x *StringMatchCondition) HasFields() bool {
	if x == nil {
		return false
	}
	return x.xxx_hidden_Fields != nil
}

func (x *StringMatchCondition) HasVmField() bool {
	if x == nil {
		return false
	}
	_, ok := x.xxx_hidden_Fields.(*stringMatchCondition_VmField_)
	return ok
}

func (x *StringMatchCondition) ClearFields() {
	x.xxx_hidden_Fields = nil
}

func (x *StringMatchCondition) ClearVmField() {
	if _, ok := x.xxx_hidden_Fields.(*stringMatchCondition_VmField_); ok {
		x.xxx_hidden_Fields = nil
	}
}

const StringMatchCondition_Fields_not_set_case case_StringMatchCondition_Fields = 0
const StringMatchCondition_VmField_case case_StringMatchCondition_Fields = 1

func (x *StringMatchCondition) WhichFields() case_StringMatchCondition_Fields {
	if x == nil {
		return StringMatchCondition_Fields_not_set_case
	}
	switch x.xxx_hidden_Fields.(type) {
	case *stringMatchCondition_VmField_:
		return StringMatchCondition_VmField_case
	default:
		return StringMatchCondition_Fields_not_set_case
	}
}

type StringMatchCondition_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	// Fields of oneof xxx_hidden_Fields:
	VmField *StringMatchCondition_VmField
	// -- end of xxx_hidden_Fields
	// Regex that will be run to match the field.
	RegexMatch string
}

func (b0 StringMatchCondition_builder) Build() *StringMatchCondition {
	m0 := &StringMatchCondition{}
	b, x := &b0, m0
	_, _ = b, x
	if b.VmField != nil {
		x.xxx_hidden_Fields = &stringMatchCondition_VmField_{*b.VmField}
	}
	x.xxx_hidden_RegexMatch = b.RegexMatch
	return m0
}

type case_StringMatchCondition_Fields protoreflect.FieldNumber

func (x case_StringMatchCondition_Fields) String() string {
	md := file_isvdiscovery_definition_definition_proto_msgTypes[7].Descriptor()
	if x == 0 {
		return "not set"
	}
	return protoimpl.X.MessageFieldStringOf(md, protoreflect.FieldNumber(x))
}

type isStringMatchCondition_Fields interface {
	isStringMatchCondition_Fields()
}

type stringMatchCondition_VmField_ struct {
	VmField StringMatchCondition_VmField `protobuf:"varint,1,opt,name=vm_field,json=vmField,proto3,enum=guesttelemetryextension.isvdiscovery.StringMatchCondition_VmField,oneof"`
}

func (*stringMatchCondition_VmField_) isStringMatchCondition_Fields() {}

// Defines a single step in a sequential version command pipeline.
type VersionCommandStep struct {
	state                                 protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Command                    VersionCommand         `protobuf:"varint,1,opt,name=command,proto3,enum=guesttelemetryextension.isvdiscovery.VersionCommand"`
	xxx_hidden_CommandArgs                []string               `protobuf:"bytes,2,rep,name=command_args,json=commandArgs,proto3"`
	xxx_hidden_RegexMatch                 string                 `protobuf:"bytes,3,opt,name=regex_match,json=regexMatch,proto3"`
	xxx_hidden_RunAsDiscoveredProcessUser bool                   `protobuf:"varint,4,opt,name=run_as_discovered_process_user,json=runAsDiscoveredProcessUser,proto3"`
	xxx_hidden_ExtendedCommand            ExtendedVersionCommand `protobuf:"varint,5,opt,name=extended_command,json=extendedCommand,proto3,enum=guesttelemetryextension.isvdiscovery.ExtendedVersionCommand"`
	xxx_hidden_UsePreviousOutputAsStdin   bool                   `protobuf:"varint,6,opt,name=use_previous_output_as_stdin,json=usePreviousOutputAsStdin,proto3"`
	unknownFields                         protoimpl.UnknownFields
	sizeCache                             protoimpl.SizeCache
}

func (x *VersionCommandStep) Reset() {
	*x = VersionCommandStep{}
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *VersionCommandStep) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*VersionCommandStep) ProtoMessage() {}

func (x *VersionCommandStep) ProtoReflect() protoreflect.Message {
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *VersionCommandStep) GetCommand() VersionCommand {
	if x != nil {
		return x.xxx_hidden_Command
	}
	return VersionCommand_VERSION_COMMAND_UNSPECIFIED
}

func (x *VersionCommandStep) GetCommandArgs() []string {
	if x != nil {
		return x.xxx_hidden_CommandArgs
	}
	return nil
}

func (x *VersionCommandStep) GetRegexMatch() string {
	if x != nil {
		return x.xxx_hidden_RegexMatch
	}
	return ""
}

func (x *VersionCommandStep) GetRunAsDiscoveredProcessUser() bool {
	if x != nil {
		return x.xxx_hidden_RunAsDiscoveredProcessUser
	}
	return false
}

func (x *VersionCommandStep) GetExtendedCommand() ExtendedVersionCommand {
	if x != nil {
		return x.xxx_hidden_ExtendedCommand
	}
	return ExtendedVersionCommand_EXTENDED_VERSION_COMMAND_UNSPECIFIED
}

func (x *VersionCommandStep) GetUsePreviousOutputAsStdin() bool {
	if x != nil {
		return x.xxx_hidden_UsePreviousOutputAsStdin
	}
	return false
}

func (x *VersionCommandStep) SetCommand(v VersionCommand) {
	x.xxx_hidden_Command = v
}

func (x *VersionCommandStep) SetCommandArgs(v []string) {
	x.xxx_hidden_CommandArgs = v
}

func (x *VersionCommandStep) SetRegexMatch(v string) {
	x.xxx_hidden_RegexMatch = v
}

func (x *VersionCommandStep) SetRunAsDiscoveredProcessUser(v bool) {
	x.xxx_hidden_RunAsDiscoveredProcessUser = v
}

func (x *VersionCommandStep) SetExtendedCommand(v ExtendedVersionCommand) {
	x.xxx_hidden_ExtendedCommand = v
}

func (x *VersionCommandStep) SetUsePreviousOutputAsStdin(v bool) {
	x.xxx_hidden_UsePreviousOutputAsStdin = v
}

type VersionCommandStep_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Command                    VersionCommand
	CommandArgs                []string
	RegexMatch                 string
	RunAsDiscoveredProcessUser bool
	ExtendedCommand            ExtendedVersionCommand
	UsePreviousOutputAsStdin   bool
}

func (b0 VersionCommandStep_builder) Build() *VersionCommandStep {
	m0 := &VersionCommandStep{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Command = b.Command
	x.xxx_hidden_CommandArgs = b.CommandArgs
	x.xxx_hidden_RegexMatch = b.RegexMatch
	x.xxx_hidden_RunAsDiscoveredProcessUser = b.RunAsDiscoveredProcessUser
	x.xxx_hidden_ExtendedCommand = b.ExtendedCommand
	x.xxx_hidden_UsePreviousOutputAsStdin = b.UsePreviousOutputAsStdin
	return m0
}

// Defines the commands that will be used to gather the version information.
// Each version rule command will be run in order until one of them gives back a
// string that contains a regex match defined by the rule.
type DiscoveryVersionRule struct {
	state                                 protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Command                    VersionCommand         `protobuf:"varint,1,opt,name=command,proto3,enum=guesttelemetryextension.isvdiscovery.VersionCommand"`
	xxx_hidden_CommandArgs                []string               `protobuf:"bytes,2,rep,name=command_args,json=commandArgs,proto3"`
	xxx_hidden_RegexMatch                 string                 `protobuf:"bytes,3,opt,name=regex_match,json=regexMatch,proto3"`
	xxx_hidden_RunAsDiscoveredProcessUser bool                   `protobuf:"varint,4,opt,name=run_as_discovered_process_user,json=runAsDiscoveredProcessUser,proto3"`
	xxx_hidden_ExtendedCommand            ExtendedVersionCommand `protobuf:"varint,5,opt,name=extended_command,json=extendedCommand,proto3,enum=guesttelemetryextension.isvdiscovery.ExtendedVersionCommand"`
	xxx_hidden_Steps                      *[]*VersionCommandStep `protobuf:"bytes,6,rep,name=steps,proto3"`
	xxx_hidden_VersionExtractPattern      string                 `protobuf:"bytes,7,opt,name=version_extract_pattern,json=versionExtractPattern,proto3"`
	unknownFields                         protoimpl.UnknownFields
	sizeCache                             protoimpl.SizeCache
}

func (x *DiscoveryVersionRule) Reset() {
	*x = DiscoveryVersionRule{}
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DiscoveryVersionRule) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DiscoveryVersionRule) ProtoMessage() {}

func (x *DiscoveryVersionRule) ProtoReflect() protoreflect.Message {
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *DiscoveryVersionRule) GetCommand() VersionCommand {
	if x != nil {
		return x.xxx_hidden_Command
	}
	return VersionCommand_VERSION_COMMAND_UNSPECIFIED
}

func (x *DiscoveryVersionRule) GetCommandArgs() []string {
	if x != nil {
		return x.xxx_hidden_CommandArgs
	}
	return nil
}

func (x *DiscoveryVersionRule) GetRegexMatch() string {
	if x != nil {
		return x.xxx_hidden_RegexMatch
	}
	return ""
}

func (x *DiscoveryVersionRule) GetRunAsDiscoveredProcessUser() bool {
	if x != nil {
		return x.xxx_hidden_RunAsDiscoveredProcessUser
	}
	return false
}

func (x *DiscoveryVersionRule) GetExtendedCommand() ExtendedVersionCommand {
	if x != nil {
		return x.xxx_hidden_ExtendedCommand
	}
	return ExtendedVersionCommand_EXTENDED_VERSION_COMMAND_UNSPECIFIED
}

func (x *DiscoveryVersionRule) GetSteps() []*VersionCommandStep {
	if x != nil {
		if x.xxx_hidden_Steps != nil {
			return *x.xxx_hidden_Steps
		}
	}
	return nil
}

func (x *DiscoveryVersionRule) GetVersionExtractPattern() string {
	if x != nil {
		return x.xxx_hidden_VersionExtractPattern
	}
	return ""
}

func (x *DiscoveryVersionRule) SetCommand(v VersionCommand) {
	x.xxx_hidden_Command = v
}

func (x *DiscoveryVersionRule) SetCommandArgs(v []string) {
	x.xxx_hidden_CommandArgs = v
}

func (x *DiscoveryVersionRule) SetRegexMatch(v string) {
	x.xxx_hidden_RegexMatch = v
}

func (x *DiscoveryVersionRule) SetRunAsDiscoveredProcessUser(v bool) {
	x.xxx_hidden_RunAsDiscoveredProcessUser = v
}

func (x *DiscoveryVersionRule) SetExtendedCommand(v ExtendedVersionCommand) {
	x.xxx_hidden_ExtendedCommand = v
}

func (x *DiscoveryVersionRule) SetSteps(v []*VersionCommandStep) {
	x.xxx_hidden_Steps = &v
}

func (x *DiscoveryVersionRule) SetVersionExtractPattern(v string) {
	x.xxx_hidden_VersionExtractPattern = v
}

type DiscoveryVersionRule_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	// The bundled version command in the extension to execute
	Command VersionCommand
	// arguments to pass to the
	CommandArgs []string
	// Regex that will be run on the output of the command to match a section of
	// the string that contains the version.  This will be further parsed to only
	// get numerical values.
	RegexMatch string
	// If true, use su to run the command as the discovered process user.
	RunAsDiscoveredProcessUser bool
	// Extended version command to execute if command is unspecified.
	ExtendedCommand ExtendedVersionCommand
	// A sequence of commands executed in order. The output of a previous step
	// can be passed as standard input (stdin) to the next step by setting
	// use_previous_output_as_stdin to true.
	// Takes precedence over command and extended_command.
	Steps []*VersionCommandStep
	// A regular expression with exactly one capturing group used to extract the
	// version. If provided, this overrides the default extracting logic.
	VersionExtractPattern string
}

func (b0 DiscoveryVersionRule_builder) Build() *DiscoveryVersionRule {
	m0 := &DiscoveryVersionRule{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Command = b.Command
	x.xxx_hidden_CommandArgs = b.CommandArgs
	x.xxx_hidden_RegexMatch = b.RegexMatch
	x.xxx_hidden_RunAsDiscoveredProcessUser = b.RunAsDiscoveredProcessUser
	x.xxx_hidden_ExtendedCommand = b.ExtendedCommand
	x.xxx_hidden_Steps = &b.Steps
	x.xxx_hidden_VersionExtractPattern = b.VersionExtractPattern
	return m0
}

// Discovered results from the rules that were matched.
type DiscoveryResult struct {
	state                   protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_DetectedData *[]*DetectedData       `protobuf:"bytes,1,rep,name=detected_data,json=detectedData,proto3"`
	unknownFields           protoimpl.UnknownFields
	sizeCache               protoimpl.SizeCache
}

func (x *DiscoveryResult) Reset() {
	*x = DiscoveryResult{}
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DiscoveryResult) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DiscoveryResult) ProtoMessage() {}

func (x *DiscoveryResult) ProtoReflect() protoreflect.Message {
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *DiscoveryResult) GetDetectedData() []*DetectedData {
	if x != nil {
		if x.xxx_hidden_DetectedData != nil {
			return *x.xxx_hidden_DetectedData
		}
	}
	return nil
}

func (x *DiscoveryResult) SetDetectedData(v []*DetectedData) {
	x.xxx_hidden_DetectedData = &v
}

type DiscoveryResult_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	DetectedData []*DetectedData
}

func (b0 DiscoveryResult_builder) Build() *DiscoveryResult {
	m0 := &DiscoveryResult{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_DetectedData = &b.DetectedData
	return m0
}

type DetectedData struct {
	state              protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Name    string                 `protobuf:"bytes,1,opt,name=name,proto3"`
	xxx_hidden_Version string                 `protobuf:"bytes,2,opt,name=version,proto3"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *DetectedData) Reset() {
	*x = DetectedData{}
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DetectedData) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DetectedData) ProtoMessage() {}

func (x *DetectedData) ProtoReflect() protoreflect.Message {
	mi := &file_isvdiscovery_definition_definition_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *DetectedData) GetName() string {
	if x != nil {
		return x.xxx_hidden_Name
	}
	return ""
}

func (x *DetectedData) GetVersion() string {
	if x != nil {
		return x.xxx_hidden_Version
	}
	return ""
}

func (x *DetectedData) SetName(v string) {
	x.xxx_hidden_Name = v
}

func (x *DetectedData) SetVersion(v string) {
	x.xxx_hidden_Version = v
}

type DetectedData_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	// The workload name that has been discovered
	Name string
	// The workload version that has been discovered
	Version string
}

func (b0 DetectedData_builder) Build() *DetectedData {
	m0 := &DetectedData{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Name = b.Name
	x.xxx_hidden_Version = b.Version
	return m0
}

var File_isvdiscovery_definition_definition_proto protoreflect.FileDescriptor

const file_isvdiscovery_definition_definition_proto_rawDesc = "" +
	"\n" +
	"(isvdiscovery/definition/definition.proto\x12$guesttelemetryextension.isvdiscovery\"\x1a\n" +
	"\x18GetDiscoveryRulesRequest\"\x99\x01\n" +
	"\x16DiscoveryConfiguration\x122\n" +
	"\x15scan_interval_seconds\x18\x01 \x01(\x05R\x13scanIntervalSeconds\x12K\n" +
	"\"minimum_reporting_interval_seconds\x18\x02 \x01(\x05R\x1fminimumReportingIntervalSeconds\"\xb1\x01\n" +
	"\x0eDiscoveryRules\x12I\n" +
	"\x05rules\x18\x01 \x03(\v23.guesttelemetryextension.isvdiscovery.DiscoveryRuleR\x05rules\x12T\n" +
	"\x06config\x18\x02 \x01(\v2<.guesttelemetryextension.isvdiscovery.DiscoveryConfigurationR\x06config\"\xc6\x03\n" +
	"\rDiscoveryRule\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12O\n" +
	"\tcondition\x18\x03 \x01(\v2/.guesttelemetryextension.isvdiscovery.ConditionH\x00R\tcondition\x12F\n" +
	"\x03all\x18\x04 \x01(\v22.guesttelemetryextension.isvdiscovery.AllConditionH\x00R\x03all\x12F\n" +
	"\x03any\x18\x05 \x01(\v22.guesttelemetryextension.isvdiscovery.AnyConditionH\x00R\x03any\x12_\n" +
	"\rversion_rules\x18\x06 \x03(\v2:.guesttelemetryextension.isvdiscovery.DiscoveryVersionRuleR\fversionRules\x128\n" +
	"\x18discovered_workload_name\x18\a \x01(\tR\x16discoveredWorkloadName\x12!\n" +
	"\fdisplay_name\x18\b \x01(\tR\vdisplayNameB\x06\n" +
	"\x04rule\"\xb2\x01\n" +
	"\fAllCondition\x12I\n" +
	"\x03any\x18\x01 \x01(\v22.guesttelemetryextension.isvdiscovery.AnyConditionH\x00R\x03any\x88\x01\x01\x12O\n" +
	"\n" +
	"conditions\x18\x02 \x03(\v2/.guesttelemetryextension.isvdiscovery.ConditionR\n" +
	"conditionsB\x06\n" +
	"\x04_any\"\xb2\x01\n" +
	"\fAnyCondition\x12I\n" +
	"\x03all\x18\x01 \x01(\v22.guesttelemetryextension.isvdiscovery.AllConditionH\x00R\x03all\x88\x01\x01\x12O\n" +
	"\n" +
	"conditions\x18\x02 \x03(\v2/.guesttelemetryextension.isvdiscovery.ConditionR\n" +
	"conditionsB\x06\n" +
	"\x04_all\"\x93\x01\n" +
	"\tCondition\x12_\n" +
	"\fstring_match\x18\x01 \x01(\v2:.guesttelemetryextension.isvdiscovery.StringMatchConditionH\x00R\vstringMatch\x12\x18\n" +
	"\anegated\x18\x03 \x01(\bR\anegatedB\v\n" +
	"\tcondition\"\xa3\x02\n" +
	"\x14StringMatchCondition\x12_\n" +
	"\bvm_field\x18\x01 \x01(\x0e2B.guesttelemetryextension.isvdiscovery.StringMatchCondition.VmFieldH\x00R\avmField\x12\x1f\n" +
	"\vregex_match\x18\x02 \x01(\tR\n" +
	"regexMatch\"\x7f\n" +
	"\aVmField\x12\x18\n" +
	"\x14VM_FIELD_UNSPECIFIED\x10\x00\x12\x13\n" +
	"\x0fVM_PROCESS_NAME\x10\x01\x12\x13\n" +
	"\x0fVM_PROCESS_PATH\x10\x02\x12\x0e\n" +
	"\n" +
	"VM_OS_NAME\x10\x03\x12\x0f\n" +
	"\vVM_CLI_ARGS\x10\x04\x12\x0f\n" +
	"\vVM_ENV_VARS\x10\x05B\b\n" +
	"\x06fields\"\x95\x03\n" +
	"\x12VersionCommandStep\x12N\n" +
	"\acommand\x18\x01 \x01(\x0e24.guesttelemetryextension.isvdiscovery.VersionCommandR\acommand\x12!\n" +
	"\fcommand_args\x18\x02 \x03(\tR\vcommandArgs\x12\x1f\n" +
	"\vregex_match\x18\x03 \x01(\tR\n" +
	"regexMatch\x12B\n" +
	"\x1erun_as_discovered_process_user\x18\x04 \x01(\bR\x1arunAsDiscoveredProcessUser\x12g\n" +
	"\x10extended_command\x18\x05 \x01(\x0e2<.guesttelemetryextension.isvdiscovery.ExtendedVersionCommandR\x0fextendedCommand\x12>\n" +
	"\x1cuse_previous_output_as_stdin\x18\x06 \x01(\bR\x18usePreviousOutputAsStdin\"\xdf\x03\n" +
	"\x14DiscoveryVersionRule\x12N\n" +
	"\acommand\x18\x01 \x01(\x0e24.guesttelemetryextension.isvdiscovery.VersionCommandR\acommand\x12!\n" +
	"\fcommand_args\x18\x02 \x03(\tR\vcommandArgs\x12\x1f\n" +
	"\vregex_match\x18\x03 \x01(\tR\n" +
	"regexMatch\x12B\n" +
	"\x1erun_as_discovered_process_user\x18\x04 \x01(\bR\x1arunAsDiscoveredProcessUser\x12g\n" +
	"\x10extended_command\x18\x05 \x01(\x0e2<.guesttelemetryextension.isvdiscovery.ExtendedVersionCommandR\x0fextendedCommand\x12N\n" +
	"\x05steps\x18\x06 \x03(\v28.guesttelemetryextension.isvdiscovery.VersionCommandStepR\x05steps\x126\n" +
	"\x17version_extract_pattern\x18\a \x01(\tR\x15versionExtractPattern\"j\n" +
	"\x0fDiscoveryResult\x12W\n" +
	"\rdetected_data\x18\x01 \x03(\v22.guesttelemetryextension.isvdiscovery.DetectedDataR\fdetectedData\"<\n" +
	"\fDetectedData\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x18\n" +
	"\aversion\x18\x02 \x01(\tR\aversion*\x93\x04\n" +
	"\x0eVersionCommand\x12\x1f\n" +
	"\x1bVERSION_COMMAND_UNSPECIFIED\x10\x00\x12\a\n" +
	"\x03CAT\x10\x01\x12\v\n" +
	"\aAPACHE2\x10\x02\x12\t\n" +
	"\x05HTTPD\x10\x03\x12\f\n" +
	"\bPOSTGRES\x10\x04\x12\b\n" +
	"\x04PSQL\x10\x05\x12\f\n" +
	"\bNODETOOL\x10\x06\x12\n" +
	"\n" +
	"\x06MONGOD\x10\a\x12\n" +
	"\n" +
	"\x06MYSQLD\x10\b\x12\v\n" +
	"\aSQLPLUS\x10\t\x12\x0f\n" +
	"\vREDISSERVER\x10\n" +
	"\x12\v\n" +
	"\aMARIADB\x10\v\x12\b\n" +
	"\x04GWRD\x10\f\x12\b\n" +
	"\x04GREP\x10\r\x12\x0e\n" +
	"\n" +
	"GETCOMMAND\x10\x0e\x12\b\n" +
	"\x04IQ15\x10\x0f\x12\b\n" +
	"\x04IQ16\x10\x10\x12\x0f\n" +
	"\vIQ15WINDOWS\x10\x11\x12\x0f\n" +
	"\vIQ16WINDOWS\x10\x12\x12\x14\n" +
	"\fFINDSAPWEBAS\x10\x13\x1a\x02\b\x01\x12\x0e\n" +
	"\n" +
	"PACEMAKERD\x10\x14\x12\f\n" +
	"\bSQLSERVR\x10\x15\x12\x18\n" +
	"\x14GETITEMPROPERTYVALUE\x10\x16\x12\n" +
	"\n" +
	"\x06OPATCH\x10\x17\x12\n" +
	"\n" +
	"\x06DGMGRL\x10\x18\x12\b\n" +
	"\x04JAVA\x10\x19\x12\t\n" +
	"\x05GGSCI\x10\x1a\x12\v\n" +
	"\aPSADMIN\x10\x1b\x12\n" +
	"\n" +
	"\x06HDBLCM\x10\x1c\x12\t\n" +
	"\x05MYSQL\x10\x1d\x12\x16\n" +
	"\x12CASSANDRA_NODETOOL\x10\x1e\x12\x11\n" +
	"\rSBIN_NODETOOL\x10\x1f\x12\x11\n" +
	"\rSQLSERVR_PATH\x10 \x12\x1f\n" +
	"\x1bUSE_DISCOVERED_PROCESS_PATH\x10!*\xa0\x02\n" +
	"\x16ExtendedVersionCommand\x12(\n" +
	"$EXTENDED_VERSION_COMMAND_UNSPECIFIED\x10\x00\x12\a\n" +
	"\x03HDB\x10\x01\x12\r\n" +
	"\tDISP_WORK\x10\x02\x12\x0e\n" +
	"\n" +
	"MSG_SERVER\x10\x03\x12\r\n" +
	"\tEN_SERVER\x10\x04\x12\a\n" +
	"\x03AWK\x10\x05\x12\x0e\n" +
	"\n" +
	"SAPWEBDISP\x10\x06\x12\f\n" +
	"\bSTART_IQ\x10\a\x12\t\n" +
	"\x05ENREP\x10\b\x12\x10\n" +
	"\fSPARK_SUBMIT\x10\t\x12\x15\n" +
	"\x11SPARK_SUBMIT_PATH\x10\n" +
	"\x12\n" +
	"\n" +
	"\x06CRICTL\x10\v\x12\n" +
	"\n" +
	"\x06HADOOP\x10\f\x12\x0f\n" +
	"\vHADOOP_PATH\x10\r\x12\b\n" +
	"\x04DPKG\x10\x0e\x12\a\n" +
	"\x03RPM\x10\x0f\x12\x0e\n" +
	"\n" +
	"GETPACKAGE\x10\x10B\x18B\fISVDiscoveryP\x01Z\x06/protob\x06proto3"

var file_isvdiscovery_definition_definition_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_isvdiscovery_definition_definition_proto_msgTypes = make([]protoimpl.MessageInfo, 12)
var file_isvdiscovery_definition_definition_proto_goTypes = []any{
	(VersionCommand)(0),               // 0: guesttelemetryextension.isvdiscovery.VersionCommand
	(ExtendedVersionCommand)(0),       // 1: guesttelemetryextension.isvdiscovery.ExtendedVersionCommand
	(StringMatchCondition_VmField)(0), // 2: guesttelemetryextension.isvdiscovery.StringMatchCondition.VmField
	(*GetDiscoveryRulesRequest)(nil),  // 3: guesttelemetryextension.isvdiscovery.GetDiscoveryRulesRequest
	(*DiscoveryConfiguration)(nil),    // 4: guesttelemetryextension.isvdiscovery.DiscoveryConfiguration
	(*DiscoveryRules)(nil),            // 5: guesttelemetryextension.isvdiscovery.DiscoveryRules
	(*DiscoveryRule)(nil),             // 6: guesttelemetryextension.isvdiscovery.DiscoveryRule
	(*AllCondition)(nil),              // 7: guesttelemetryextension.isvdiscovery.AllCondition
	(*AnyCondition)(nil),              // 8: guesttelemetryextension.isvdiscovery.AnyCondition
	(*Condition)(nil),                 // 9: guesttelemetryextension.isvdiscovery.Condition
	(*StringMatchCondition)(nil),      // 10: guesttelemetryextension.isvdiscovery.StringMatchCondition
	(*VersionCommandStep)(nil),        // 11: guesttelemetryextension.isvdiscovery.VersionCommandStep
	(*DiscoveryVersionRule)(nil),      // 12: guesttelemetryextension.isvdiscovery.DiscoveryVersionRule
	(*DiscoveryResult)(nil),           // 13: guesttelemetryextension.isvdiscovery.DiscoveryResult
	(*DetectedData)(nil),              // 14: guesttelemetryextension.isvdiscovery.DetectedData
}
var file_isvdiscovery_definition_definition_proto_depIdxs = []int32{
	6,  // 0: guesttelemetryextension.isvdiscovery.DiscoveryRules.rules:type_name -> guesttelemetryextension.isvdiscovery.DiscoveryRule
	4,  // 1: guesttelemetryextension.isvdiscovery.DiscoveryRules.config:type_name -> guesttelemetryextension.isvdiscovery.DiscoveryConfiguration
	9,  // 2: guesttelemetryextension.isvdiscovery.DiscoveryRule.condition:type_name -> guesttelemetryextension.isvdiscovery.Condition
	7,  // 3: guesttelemetryextension.isvdiscovery.DiscoveryRule.all:type_name -> guesttelemetryextension.isvdiscovery.AllCondition
	8,  // 4: guesttelemetryextension.isvdiscovery.DiscoveryRule.any:type_name -> guesttelemetryextension.isvdiscovery.AnyCondition
	12, // 5: guesttelemetryextension.isvdiscovery.DiscoveryRule.version_rules:type_name -> guesttelemetryextension.isvdiscovery.DiscoveryVersionRule
	8,  // 6: guesttelemetryextension.isvdiscovery.AllCondition.any:type_name -> guesttelemetryextension.isvdiscovery.AnyCondition
	9,  // 7: guesttelemetryextension.isvdiscovery.AllCondition.conditions:type_name -> guesttelemetryextension.isvdiscovery.Condition
	7,  // 8: guesttelemetryextension.isvdiscovery.AnyCondition.all:type_name -> guesttelemetryextension.isvdiscovery.AllCondition
	9,  // 9: guesttelemetryextension.isvdiscovery.AnyCondition.conditions:type_name -> guesttelemetryextension.isvdiscovery.Condition
	10, // 10: guesttelemetryextension.isvdiscovery.Condition.string_match:type_name -> guesttelemetryextension.isvdiscovery.StringMatchCondition
	2,  // 11: guesttelemetryextension.isvdiscovery.StringMatchCondition.vm_field:type_name -> guesttelemetryextension.isvdiscovery.StringMatchCondition.VmField
	0,  // 12: guesttelemetryextension.isvdiscovery.VersionCommandStep.command:type_name -> guesttelemetryextension.isvdiscovery.VersionCommand
	1,  // 13: guesttelemetryextension.isvdiscovery.VersionCommandStep.extended_command:type_name -> guesttelemetryextension.isvdiscovery.ExtendedVersionCommand
	0,  // 14: guesttelemetryextension.isvdiscovery.DiscoveryVersionRule.command:type_name -> guesttelemetryextension.isvdiscovery.VersionCommand
	1,  // 15: guesttelemetryextension.isvdiscovery.DiscoveryVersionRule.extended_command:type_name -> guesttelemetryextension.isvdiscovery.ExtendedVersionCommand
	11, // 16: guesttelemetryextension.isvdiscovery.DiscoveryVersionRule.steps:type_name -> guesttelemetryextension.isvdiscovery.VersionCommandStep
	14, // 17: guesttelemetryextension.isvdiscovery.DiscoveryResult.detected_data:type_name -> guesttelemetryextension.isvdiscovery.DetectedData
	18, // [18:18] is the sub-list for method output_type
	18, // [18:18] is the sub-list for method input_type
	18, // [18:18] is the sub-list for extension type_name
	18, // [18:18] is the sub-list for extension extendee
	0,  // [0:18] is the sub-list for field type_name
}

func init() { file_isvdiscovery_definition_definition_proto_init() }
func file_isvdiscovery_definition_definition_proto_init() {
	if File_isvdiscovery_definition_definition_proto != nil {
		return
	}
	file_isvdiscovery_definition_definition_proto_msgTypes[3].OneofWrappers = []any{
		(*discoveryRule_Condition)(nil),
		(*discoveryRule_All)(nil),
		(*discoveryRule_Any)(nil),
	}
	file_isvdiscovery_definition_definition_proto_msgTypes[4].OneofWrappers = []any{}
	file_isvdiscovery_definition_definition_proto_msgTypes[5].OneofWrappers = []any{}
	file_isvdiscovery_definition_definition_proto_msgTypes[6].OneofWrappers = []any{
		(*condition_StringMatch)(nil),
	}
	file_isvdiscovery_definition_definition_proto_msgTypes[7].OneofWrappers = []any{
		(*stringMatchCondition_VmField_)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_isvdiscovery_definition_definition_proto_rawDesc), len(file_isvdiscovery_definition_definition_proto_rawDesc)),
			NumEnums:      3,
			NumMessages:   12,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_isvdiscovery_definition_definition_proto_goTypes,
		DependencyIndexes: file_isvdiscovery_definition_definition_proto_depIdxs,
		EnumInfos:         file_isvdiscovery_definition_definition_proto_enumTypes,
		MessageInfos:      file_isvdiscovery_definition_definition_proto_msgTypes,
	}.Build()
	File_isvdiscovery_definition_definition_proto = out.File
	file_isvdiscovery_definition_definition_proto_goTypes = nil
	file_isvdiscovery_definition_definition_proto_depIdxs = nil
}
