// Code generated by protoc-gen-go. DO NOT EDIT.
// source: test/metadata/v1/metadata.proto

// This package contains the definitions for the test metadata generated as
// build artifacts for all supported tests.
//
// This metadata is used for test execution requests, scheduling decisions and
// results analytics in various Test Lab Environments.
//
// Metadata MUST be generated for all tests in supported Remote Test Drivers and
// MUST be respected in all Test Lab Environments.

package metadata

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	_struct "github.com/golang/protobuf/ptypes/struct"
	api "go.chromium.org/chromiumos/config/go/api"
	lab "go.chromium.org/chromiumos/infra/proto/go/lab"
	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

// The test metadata specification.
//
// Test metadata MUST be generated for each Remote Test Driver as one of the
// test artifacts generated from Chrome OS build system.
type Specification struct {
	// A set of Remote Test Driver packages.
	//
	// In practice, a complete specification of all known Remote Test Drivers may
	// consist of multiple Specification instances. In that case the test names
	// MUST be unique across different Specification instances.
	//
	// Unlike tests, a RemoteTestDriver (identified by its name) may be specified
	// multiple times, in a single Specification or across different Specification
	// instances. In that case, all fields except the list of tests MUST be
	// identical across these RemoteTestDriver instances. The list of tests across
	// these instances will be concatenated together.
	RemoteTestDrivers    []*RemoteTestDriver `protobuf:"bytes,1,rep,name=remote_test_drivers,json=remoteTestDrivers,proto3" json:"remote_test_drivers,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_Specification proto.InternalMessageInfo

func (m *Specification) GetRemoteTestDrivers() []*RemoteTestDriver {
	if m != nil {
		return m.RemoteTestDrivers
	}
	return nil
}

// go/cros-rtd-spec describes the Remote Test Driver bootstrapping flow inside
// the Remote Test Server. Remote Test Driver configures the bootstrapping flow
// for a test invocation.
type RemoteTestDriver struct {
	// Globally unique name for a Remote Test Driver package.
	//
	//
	// MUST be a valid resource per https://aip.dev/122.
	//
	// Pattern: remoteTestDrivers/{remoteTestDriver}
	//
	// The two most commonly used Remote Test Drivers are named
	// - remoteTestDrivers/tauto
	// - remoteTestDrivers/tast
	// and contain the common public tests written in the Tauto and Tast framework
	// respectively.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// A container image containing all the required dependencies and other build
	// artifacts required for test invocations.
	//
	// Test Lab Environments SHOULD fail with an error indicating that the request
	// was invalid if the image fails to be found for a test invocation.
	Image *BuildArtifact `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"`
	// Command to invoke the Remote Test Driver inside `image`.
	//
	// Remote Test Servers MUST run `command` as
	//   $ ${command} -input_json ${input_json}
	// where ${command} and ${input_json} are absolute paths inside the container.
	//
	// Remote Test Servers MUST populate `input_json` with a JSON encoded
	// test.invocation.Request message.
	Command string `protobuf:"bytes,3,opt,name=command,proto3" json:"command,omitempty"`
	// Metadata for the smallest schedulable test units.
	Tests                []*Test  `protobuf:"bytes,4,rep,name=tests,proto3" json:"tests,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_RemoteTestDriver proto.InternalMessageInfo

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

func (m *RemoteTestDriver) GetImage() *BuildArtifact {
	if m != nil {
		return m.Image
	}
	return nil
}

func (m *RemoteTestDriver) GetCommand() string {
	if m != nil {
		return m.Command
	}
	return ""
}

func (m *RemoteTestDriver) GetTests() []*Test {
	if m != nil {
		return m.Tests
	}
	return nil
}

// A Chrome OS build artifact required for test execution.
type BuildArtifact struct {
	// All build artifacts are assumed to be archived in some common directory
	// root. `relative_path` is the relative path inside the root archive
	// directory.
	//
	// Infrastructure Test Lab Environment: Chrome OS Continuous Integration
	// builders archive build artifacts to a path on Google Storage. The Test
	// Platform requests include a reference to the root archival path.
	// e.g.,
	// * The builder archives all build artifacts to
	//   gs://chromeos-image-archive/link-release/R64-0.0.0.0/
	// * Test Platform request includes this archival path.
	// * `relative_path` is set to tast/mighty.bin
	// * Then, the full path to the artifact is
	//   gs://chromeos-image-archive/link-release/R64-0.0.0.0/tast/mighty.bin
	//
	// Developer Test Lab Environment: For developer flow outside of the
	// infrastructure, it is assumed that the build artifacts are available at a
	// local path with the same directory layout as the Google Storage archival.
	// e.g.,
	// * Local build copies all artifacts to /tmp/cbuildbot/archive/
	// * Local tooling includes a reference to this path.
	// * `relative_path` is set to tauto/ssp.bin
	// * Then, the full path to the artifact is
	//   /tmp/cbuildbot/archive/tauto/ssp.bin
	RelativePath         string   `protobuf:"bytes,1,opt,name=relative_path,json=relativePath,proto3" json:"relative_path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_BuildArtifact proto.InternalMessageInfo

func (m *BuildArtifact) GetRelativePath() string {
	if m != nil {
		return m.RelativePath
	}
	return ""
}

// The smallest schedulable test unit.
//
// A Test is an atomic schdulable unit. In particular, it is not possible to
// modify the behaviour of a Remote Test Driver execution for a given Test by
// supplying test arguments. See the documentation of
// test.metadata.v1.Informational on how paramaterized tests may be in light of
// this restriction.
//
// A single test platform request or Remote Test Driver invocation may contain
// multiple instances of multiple Tests, but each instance of a Test MUST
// correspond to exactly one reported result.
//
// See Also:
//    Test Platform request: TODO(pprabhu)
//    Remote Test Driver invocation request: test/rtd/invocation.proto
//    Remote Test Driver progress API: test/rtd/progress.proto
type Test struct {
	// Globally unique name for this test.
	//
	// MUST be a valid resource per https://aip.dev/122.
	//
	// Pattern: remoteTestDrivers/{remoteTestDriver}/tests/{test}
	//   where {remoteTestDriver} is the Remote Test Driver package that contains
	//   this test.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Attributes are used to include tests in test plans.
	//
	// See Also:
	//   Test plans: test/plan/plan.proto
	Attributes []*Attribute `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty"`
	// Required condition to be met for each Device Under Test targeted by this
	// test.
	//
	// Condition enforcement is an optional feature for test scheduling, i.e.,
	// some Test Lab Environments may ignore conditions entirely.
	//
	// May be specified multiple times for tests that target more than one Device
	// Under Test, once per required device.
	Conditions []*DUTCondition `protobuf:"bytes,3,rep,name=conditions,proto3" json:"conditions,omitempty"`
	// Metadata about the test that doesn't affect scheduling or execution.
	Informational        *Informational `protobuf:"bytes,4,opt,name=informational,proto3" json:"informational,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_Test proto.InternalMessageInfo

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

func (m *Test) GetAttributes() []*Attribute {
	if m != nil {
		return m.Attributes
	}
	return nil
}

func (m *Test) GetConditions() []*DUTCondition {
	if m != nil {
		return m.Conditions
	}
	return nil
}

func (m *Test) GetInformational() *Informational {
	if m != nil {
		return m.Informational
	}
	return nil
}

// Attributes used to include tests in test plans.
type Attribute struct {
	// Opaque name for this attribute.
	//
	// Value MUST be valid resource names per https://aip.dev/122.
	//
	// MUST NOT be interpreted by Test Lab Environments.
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Attribute proto.InternalMessageInfo

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

// Condition to be met for each Device Under Test targeted by a test.
type DUTCondition struct {
	// A Common Expression Language (CEL) expression to specify DUT conditions.
	//
	// Test Lab Environments may optionally support targeting test requests to
	// Device Under Test based on DUTConditions. If this feature is supported, the
	// Test Lab Environment MUST interpret `expression` in the scope of the
	// protobuf message DUTCondition.Scope as defined below.
	//
	// The full CEL spec can be found at https://github.com/google/cel-spec.
	// This API only currently only supports a small sub-set of the CEL features,
	// as described here. Test Lab Environments SHOULD validate the expression and
	// reject use of unsupported features.
	//
	// TODO(crbug.com/1051689) Add reference to the metadata validator package.
	//
	// ## Examples
	//
	// Typical instructive examples of expressions are:
	//
	// - A specific characteristic for a hardware feature, e.g.:
	//     scope.hardware_topology.screen.milliinch.value == 14000
	// - A specific topology for a hardware feature, e.g.:
	//     scope.hardware_topology.form_factor.id == "fancy_clamshell"
	// - Existence of a hardware feature, e.g.:
	//     scope.hardware_features.lte == scope.hardware_features.PRESENT
	// - Exclude certain hardware topologies, e.g.:
	//     scope.hardware_topology.stylus.id != "pencil"
	//
	// ## CEL support
	//
	// Current support for `expression` evaluation is very restricted due to
	// limitations in the scheduling platform used by Test Platform. Specifying
	// the conditions in CEL will allow gradual lifting of support restrictions.
	//
	// As this API matures, features will be added to the scheduling
	// infrastructure of Test Platform and restrictions here will be lifted based
	// on requirements collected from test authors. See milestones in
	// go/cros-f20-plan for expected feature iterations.
	//
	// ### Evaluation context
	//
	// In general, a CEL expression must be evaluated in some context that
	// provides the basic bindings for name resolution.
	//
	// In this case, `expression` MUST be evaluated in a context that contains
	//
	// - A variable 'scope' of type DUTCondition.Scope. This variable contains the
	//   information about a particular Device Under Test being tested for
	//   acceptance via `expression`.
	// - Protobuf definitions in this git project (i.e., rooted at infra/proto/).
	//
	// ### Syntax
	//
	// See full syntax definition at
	// https://github.com/google/cel-spec/blob/master/doc/langdef.md#syntax
	//
	// CEL standard syntax allows expressions that evaluate to errors (e.g.,
	// syntax allows negation of lists, which has no semantics in CEL).
	// Thus, this spec does not attempt to restrict the syntax, but specifies what
	// operations are unsupported to aid metadata producers. Ultimately, the
	// reference metadata validator is the authority on what expressions are
	// allowed.
	//
	// Unsupported standard CEL semantics:
	//   - Binary arithmetic operations
	//     e.g.: +, *, /, % ...
	//   - Relational Operators beyond (in)equality are not supported.
	//     e.g.: (>, <, >=, <= ...)
	//   - Logical OR in expressions is not supported.
	//     e.g.: (a || b), !(a && b) ...
	//
	// ### Macros
	//
	// See full macro definition at
	// https://github.com/google/cel-spec/blob/master/doc/langdef.md#macros
	//
	// Supported macros: has(), e.all()
	// Unsupported macros: e.exists(), e.exists_one(), e.map(), e.filter()
	//
	// ### Standard functions
	//
	// See full list of standard definitions at
	// https://github.com/google/cel-spec/blob/master/doc/langdef.md#standard-definitions
	//
	// Most standard functions are not supported.
	//
	// - Supported operators: !_, -_, _!=_, _&&_, _=_, _[_]
	//   - All other operators are not supported.
	// - All other standard functions are not supported. In particular take note:
	//   - size() is not supported.
	//   - string functions like endsWith() and contains() are not supported.
	//   - type conversions like int() and string() are not supported.
	//   - reflection with type(), null_type() and dyn() is not supported.
	Expression           string   `protobuf:"bytes,1,opt,name=expression,proto3" json:"expression,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DUTCondition proto.InternalMessageInfo

func (m *DUTCondition) GetExpression() string {
	if m != nil {
		return m.Expression
	}
	return ""
}

// Protocol buffer scope for interpretation of `expression`.
//
// Scope includes the Device Under Test features that can be targeted for test
// targeting.
type DUTCondition_Scope struct {
	// Peripherals information about the lab deployment of the device.
	Peripherals *lab.Peripherals `protobuf:"bytes,1,opt,name=peripherals,proto3" json:"peripherals,omitempty"`
	// The relationship between topology and features is described at
	// https://chromium.googlesource.com/chromiumos/config/+/master/proto/api/hardware_topology.md
	HardwareTopology     *api.HardwareTopology `protobuf:"bytes,2,opt,name=hardware_topology,json=hardwareTopology,proto3" json:"hardware_topology,omitempty"`
	HardwareFeatures     *api.HardwareFeatures `protobuf:"bytes,3,opt,name=hardware_features,json=hardwareFeatures,proto3" json:"hardware_features,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_DUTCondition_Scope proto.InternalMessageInfo

func (m *DUTCondition_Scope) GetPeripherals() *lab.Peripherals {
	if m != nil {
		return m.Peripherals
	}
	return nil
}

func (m *DUTCondition_Scope) GetHardwareTopology() *api.HardwareTopology {
	if m != nil {
		return m.HardwareTopology
	}
	return nil
}

func (m *DUTCondition_Scope) GetHardwareFeatures() *api.HardwareFeatures {
	if m != nil {
		return m.HardwareFeatures
	}
	return nil
}

// Contains metadata about the test that doesn't affect scheduling or execution.
type Informational struct {
	// Contacts for ownership / flakiness notification etc.
	Authors []*Contact `protobuf:"bytes,1,rep,name=authors,proto3" json:"authors,omitempty"`
	// Machine readable test-specific information.
	//
	// Remote Test Drivers SHOULD include detailed information to aid analytics.
	// For example, test authors may minimize code duplication by writing
	// paramterized tests. Thus, multiple test metadata may refer to the
	// same test implementation with different arguments. It is useful to include
	// this information as details. An example for Tauto:
	//   {
	//      "test_project": "chromiumos/third_party/autotest",
	//      "control_file": "site_tests/dummy_Pass/control.stress",
	//      "args": {
	//        "run_count": 35
	//      }
	//   }
	//
	// This field MUST NOT be interpreted by the Test Lab Environments, but Remote
	// Test Drivers can enrich analytics by using uniform stable schema for
	// details across all their tests.
	Details              *_struct.Struct `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_Informational proto.InternalMessageInfo

func (m *Informational) GetAuthors() []*Contact {
	if m != nil {
		return m.Authors
	}
	return nil
}

func (m *Informational) GetDetails() *_struct.Struct {
	if m != nil {
		return m.Details
	}
	return nil
}

// Contact information of individuals or teams.
type Contact struct {
	// Types that are valid to be assigned to Type:
	//	*Contact_Email
	//	*Contact_MdbGroup
	Type                 isContact_Type `protobuf_oneof:"type"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_Contact proto.InternalMessageInfo

type isContact_Type interface {
	isContact_Type()
}

type Contact_Email struct {
	Email string `protobuf:"bytes,1,opt,name=email,proto3,oneof"`
}

type Contact_MdbGroup struct {
	MdbGroup string `protobuf:"bytes,2,opt,name=mdb_group,json=mdbGroup,proto3,oneof"`
}

func (*Contact_Email) isContact_Type() {}

func (*Contact_MdbGroup) isContact_Type() {}

func (m *Contact) GetType() isContact_Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *Contact) GetEmail() string {
	if x, ok := m.GetType().(*Contact_Email); ok {
		return x.Email
	}
	return ""
}

func (m *Contact) GetMdbGroup() string {
	if x, ok := m.GetType().(*Contact_MdbGroup); ok {
		return x.MdbGroup
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Contact) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Contact_Email)(nil),
		(*Contact_MdbGroup)(nil),
	}
}

func init() {
	proto.RegisterType((*Specification)(nil), "test.metadata.v1.Specification")
	proto.RegisterType((*RemoteTestDriver)(nil), "test.metadata.v1.RemoteTestDriver")
	proto.RegisterType((*BuildArtifact)(nil), "test.metadata.v1.BuildArtifact")
	proto.RegisterType((*Test)(nil), "test.metadata.v1.Test")
	proto.RegisterType((*Attribute)(nil), "test.metadata.v1.Attribute")
	proto.RegisterType((*DUTCondition)(nil), "test.metadata.v1.DUTCondition")
	proto.RegisterType((*DUTCondition_Scope)(nil), "test.metadata.v1.DUTCondition.Scope")
	proto.RegisterType((*Informational)(nil), "test.metadata.v1.Informational")
	proto.RegisterType((*Contact)(nil), "test.metadata.v1.Contact")
}

func init() { proto.RegisterFile("test/metadata/v1/metadata.proto", fileDescriptor_476fe0680946cd89) }

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