// Copyright 2018 The Bazel Authors.
//
// 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
//
//     http://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.11
// 	protoc        v6.33.4
// source: build/bazel/remote/execution/v2/remote_execution.proto

package remoteexecution

import (
	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"
	semver "github.com/bazelbuild/remote-apis/build/bazel/semver"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	status "google.golang.org/genproto/googleapis/rpc/status"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	anypb "google.golang.org/protobuf/types/known/anypb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
	reflect "reflect"
	sync "sync"
	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)
)

type Command_OutputDirectoryFormat int32

const (
	// The client is only interested in receiving output directories in
	// the form of a single Tree object, using the `tree_digest` field.
	Command_TREE_ONLY Command_OutputDirectoryFormat = 0
	// The client is only interested in receiving output directories in
	// the form of a hierarchy of separately stored Directory objects,
	// using the `root_directory_digest` field.
	Command_DIRECTORY_ONLY Command_OutputDirectoryFormat = 1
	// The client is interested in receiving output directories both in
	// the form of a single Tree object and a hierarchy of separately
	// stored Directory objects, using both the `tree_digest` and
	// `root_directory_digest` fields.
	Command_TREE_AND_DIRECTORY Command_OutputDirectoryFormat = 2
)

// Enum value maps for Command_OutputDirectoryFormat.
var (
	Command_OutputDirectoryFormat_name = map[int32]string{
		0: "TREE_ONLY",
		1: "DIRECTORY_ONLY",
		2: "TREE_AND_DIRECTORY",
	}
	Command_OutputDirectoryFormat_value = map[string]int32{
		"TREE_ONLY":          0,
		"DIRECTORY_ONLY":     1,
		"TREE_AND_DIRECTORY": 2,
	}
)

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

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

func (Command_OutputDirectoryFormat) Descriptor() protoreflect.EnumDescriptor {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_enumTypes[0].Descriptor()
}

func (Command_OutputDirectoryFormat) Type() protoreflect.EnumType {
	return &file_build_bazel_remote_execution_v2_remote_execution_proto_enumTypes[0]
}

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

// Deprecated: Use Command_OutputDirectoryFormat.Descriptor instead.
func (Command_OutputDirectoryFormat) EnumDescriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{1, 0}
}

type ExecutionStage_Value int32

const (
	// Invalid value.
	ExecutionStage_UNKNOWN ExecutionStage_Value = 0
	// Checking the result against the cache.
	ExecutionStage_CACHE_CHECK ExecutionStage_Value = 1
	// Currently idle, awaiting a free machine to execute.
	ExecutionStage_QUEUED ExecutionStage_Value = 2
	// Currently being executed by a worker.
	ExecutionStage_EXECUTING ExecutionStage_Value = 3
	// Finished execution.
	ExecutionStage_COMPLETED ExecutionStage_Value = 4
)

// Enum value maps for ExecutionStage_Value.
var (
	ExecutionStage_Value_name = map[int32]string{
		0: "UNKNOWN",
		1: "CACHE_CHECK",
		2: "QUEUED",
		3: "EXECUTING",
		4: "COMPLETED",
	}
	ExecutionStage_Value_value = map[string]int32{
		"UNKNOWN":     0,
		"CACHE_CHECK": 1,
		"QUEUED":      2,
		"EXECUTING":   3,
		"COMPLETED":   4,
	}
)

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

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

func (ExecutionStage_Value) Descriptor() protoreflect.EnumDescriptor {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_enumTypes[1].Descriptor()
}

func (ExecutionStage_Value) Type() protoreflect.EnumType {
	return &file_build_bazel_remote_execution_v2_remote_execution_proto_enumTypes[1]
}

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

// Deprecated: Use ExecutionStage_Value.Descriptor instead.
func (ExecutionStage_Value) EnumDescriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{21, 0}
}

type DigestFunction_Value int32

const (
	// It is an error for the server to return this value.
	DigestFunction_UNKNOWN DigestFunction_Value = 0
	// The SHA-256 digest function.
	DigestFunction_SHA256 DigestFunction_Value = 1
	// The SHA-1 digest function.
	DigestFunction_SHA1 DigestFunction_Value = 2
	// The MD5 digest function.
	DigestFunction_MD5 DigestFunction_Value = 3
	// The Microsoft "VSO-Hash" paged SHA256 digest function.
	// See https://github.com/microsoft/BuildXL/blob/master/Documentation/Specs/PagedHash.md .
	DigestFunction_VSO DigestFunction_Value = 4
	// The SHA-384 digest function.
	DigestFunction_SHA384 DigestFunction_Value = 5
	// The SHA-512 digest function.
	DigestFunction_SHA512 DigestFunction_Value = 6
	// Murmur3 128-bit digest function, x64 variant. Note that this is not a
	// cryptographic hash function and its collision properties are not strongly guaranteed.
	// See https://github.com/aappleby/smhasher/wiki/MurmurHash3 .
	DigestFunction_MURMUR3 DigestFunction_Value = 7
	// The SHA-256 digest function, modified to use a Merkle tree for
	// large objects. This permits implementations to store large blobs
	// as a decomposed sequence of 2^j sized chunks, where j >= 10,
	// while being able to validate integrity at the chunk level.
	//
	// Furthermore, on systems that do not offer dedicated instructions
	// for computing SHA-256 hashes (e.g., the Intel SHA and ARMv8
	// cryptographic extensions), SHA256TREE hashes can be computed more
	// efficiently than plain SHA-256 hashes by using generic SIMD
	// extensions, such as Intel AVX2 or ARM NEON.
	//
	// SHA256TREE hashes are computed as follows:
	//
	//   - For blobs that are 1024 bytes or smaller, the hash is computed
	//     using the regular SHA-256 digest function.
	//
	//   - For blobs that are more than 1024 bytes in size, the hash is
	//     computed as follows:
	//
	//     1. The blob is partitioned into a left (leading) and right
	//     (trailing) blob. These blobs have lengths m and n
	//     respectively, where m = 2^k and 0 < n <= m.
	//
	//     2. Hashes of the left and right blob, Hash(left) and
	//     Hash(right) respectively, are computed by recursively
	//     applying the SHA256TREE algorithm.
	//
	//     3. A single invocation is made to the SHA-256 block cipher with
	//     the following parameters:
	//
	//     M = Hash(left) || Hash(right)
	//     H = {
	//     0xcbbb9d5d, 0x629a292a, 0x9159015a, 0x152fecd8,
	//     0x67332667, 0x8eb44a87, 0xdb0c2e0d, 0x47b5481d,
	//     }
	//
	//     The values of H are the leading fractional parts of the
	//     square roots of the 9th to the 16th prime number (23 to 53).
	//     This differs from plain SHA-256, where the first eight prime
	//     numbers (2 to 19) are used, thereby preventing trivial hash
	//     collisions between small and large objects.
	//
	//     4. The hash of the full blob can then be obtained by
	//     concatenating the outputs of the block cipher:
	//
	//     Hash(blob) = a || b || c || d || e || f || g || h
	//
	//     Addition of the original values of H, as normally done
	//     through the use of the Davies-Meyer structure, is not
	//     performed. This isn't necessary, as the block cipher is only
	//     invoked once.
	//
	// Test vectors of this digest function can be found in the
	// accompanying sha256tree_test_vectors.txt file.
	DigestFunction_SHA256TREE DigestFunction_Value = 8
	// The BLAKE3 hash function.
	// See https://github.com/BLAKE3-team/BLAKE3.
	DigestFunction_BLAKE3 DigestFunction_Value = 9
	// Identical to SHA1, except that "blob ${sizeBytes}\0" is prepended to
	// the blob's contents before hashing, where ${sizeBytes} corresponds to
	// the decimal size of the original blob. This allows hashes of files to
	// be converted from and to the ones used by the Git version control
	// system.
	DigestFunction_GITSHA1 DigestFunction_Value = 10
)

// Enum value maps for DigestFunction_Value.
var (
	DigestFunction_Value_name = map[int32]string{
		0:  "UNKNOWN",
		1:  "SHA256",
		2:  "SHA1",
		3:  "MD5",
		4:  "VSO",
		5:  "SHA384",
		6:  "SHA512",
		7:  "MURMUR3",
		8:  "SHA256TREE",
		9:  "BLAKE3",
		10: "GITSHA1",
	}
	DigestFunction_Value_value = map[string]int32{
		"UNKNOWN":    0,
		"SHA256":     1,
		"SHA1":       2,
		"MD5":        3,
		"VSO":        4,
		"SHA384":     5,
		"SHA512":     6,
		"MURMUR3":    7,
		"SHA256TREE": 8,
		"BLAKE3":     9,
		"GITSHA1":    10,
	}
)

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

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

func (DigestFunction_Value) Descriptor() protoreflect.EnumDescriptor {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_enumTypes[2].Descriptor()
}

func (DigestFunction_Value) Type() protoreflect.EnumType {
	return &file_build_bazel_remote_execution_v2_remote_execution_proto_enumTypes[2]
}

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

// Deprecated: Use DigestFunction_Value.Descriptor instead.
func (DigestFunction_Value) EnumDescriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{40, 0}
}

type ChunkingFunction_Value int32

const (
	// No specific algorithm. Servers MUST always accept this value.
	// For SplitBlob, the server chooses the algorithm. For SpliceBlob, the
	// server only verifies that chunks concatenate to form the expected blob.
	ChunkingFunction_UNKNOWN ChunkingFunction_Value = 0
	// The FastCDC chunking algorithm as described in the 2020 paper by
	// Wen Xia, et al. See https://ieeexplore.ieee.org/document/9055082
	// for details.
	ChunkingFunction_FAST_CDC_2020 ChunkingFunction_Value = 1
	// The RepMaxCDC chunking algorithm as implemented by buildbarn/go-cdc.
	// See https://github.com/buildbarn/go-cdc for details.
	ChunkingFunction_REP_MAX_CDC ChunkingFunction_Value = 2
)

// Enum value maps for ChunkingFunction_Value.
var (
	ChunkingFunction_Value_name = map[int32]string{
		0: "UNKNOWN",
		1: "FAST_CDC_2020",
		2: "REP_MAX_CDC",
	}
	ChunkingFunction_Value_value = map[string]int32{
		"UNKNOWN":       0,
		"FAST_CDC_2020": 1,
		"REP_MAX_CDC":   2,
	}
)

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

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

func (ChunkingFunction_Value) Descriptor() protoreflect.EnumDescriptor {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_enumTypes[3].Descriptor()
}

func (ChunkingFunction_Value) Type() protoreflect.EnumType {
	return &file_build_bazel_remote_execution_v2_remote_execution_proto_enumTypes[3]
}

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

// Deprecated: Use ChunkingFunction_Value.Descriptor instead.
func (ChunkingFunction_Value) EnumDescriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{41, 0}
}

type SymlinkAbsolutePathStrategy_Value int32

const (
	// Invalid value.
	SymlinkAbsolutePathStrategy_UNKNOWN SymlinkAbsolutePathStrategy_Value = 0
	// Server will return an `INVALID_ARGUMENT` on input symlinks with absolute
	// targets.
	// If an action tries to create an output symlink with an absolute target, a
	// `FAILED_PRECONDITION` will be returned.
	SymlinkAbsolutePathStrategy_DISALLOWED SymlinkAbsolutePathStrategy_Value = 1
	// Server will allow symlink targets to escape the input root tree, possibly
	// resulting in non-hermetic builds.
	SymlinkAbsolutePathStrategy_ALLOWED SymlinkAbsolutePathStrategy_Value = 2
)

// Enum value maps for SymlinkAbsolutePathStrategy_Value.
var (
	SymlinkAbsolutePathStrategy_Value_name = map[int32]string{
		0: "UNKNOWN",
		1: "DISALLOWED",
		2: "ALLOWED",
	}
	SymlinkAbsolutePathStrategy_Value_value = map[string]int32{
		"UNKNOWN":    0,
		"DISALLOWED": 1,
		"ALLOWED":    2,
	}
)

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

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

func (SymlinkAbsolutePathStrategy_Value) Descriptor() protoreflect.EnumDescriptor {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_enumTypes[4].Descriptor()
}

func (SymlinkAbsolutePathStrategy_Value) Type() protoreflect.EnumType {
	return &file_build_bazel_remote_execution_v2_remote_execution_proto_enumTypes[4]
}

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

// Deprecated: Use SymlinkAbsolutePathStrategy_Value.Descriptor instead.
func (SymlinkAbsolutePathStrategy_Value) EnumDescriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{44, 0}
}

type Compressor_Value int32

const (
	// No compression. Servers and clients MUST always support this, and do
	// not need to advertise it.
	Compressor_IDENTITY Compressor_Value = 0
	// Zstandard compression.
	Compressor_ZSTD Compressor_Value = 1
	// RFC 1951 Deflate. This format is identical to what is used by ZIP
	// files. Headers such as the one generated by gzip are not
	// included.
	//
	// It is advised to use algorithms such as Zstandard instead, as
	// those are faster and/or provide a better compression ratio.
	Compressor_DEFLATE Compressor_Value = 2
	// Brotli compression.
	Compressor_BROTLI Compressor_Value = 3
)

// Enum value maps for Compressor_Value.
var (
	Compressor_Value_name = map[int32]string{
		0: "IDENTITY",
		1: "ZSTD",
		2: "DEFLATE",
		3: "BROTLI",
	}
	Compressor_Value_value = map[string]int32{
		"IDENTITY": 0,
		"ZSTD":     1,
		"DEFLATE":  2,
		"BROTLI":   3,
	}
)

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

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

func (Compressor_Value) Descriptor() protoreflect.EnumDescriptor {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_enumTypes[5].Descriptor()
}

func (Compressor_Value) Type() protoreflect.EnumType {
	return &file_build_bazel_remote_execution_v2_remote_execution_proto_enumTypes[5]
}

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

// Deprecated: Use Compressor_Value.Descriptor instead.
func (Compressor_Value) EnumDescriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{45, 0}
}

// An `Action` captures all the information about an execution which is required
// to reproduce it.
//
// `Action`s are the core component of the [Execution] service. A single
// `Action` represents a repeatable action that can be performed by the
// execution service. `Action`s can be succinctly identified by the digest of
// their wire format encoding and, once an `Action` has been executed, will be
// cached in the action cache. Future requests can then use the cached result
// rather than needing to run afresh.
//
// When a server completes execution of an
// [Action][build.bazel.remote.execution.v2.Action], it MAY choose to
// cache the [result][build.bazel.remote.execution.v2.ActionResult] in
// the [ActionCache][build.bazel.remote.execution.v2.ActionCache] unless
// `do_not_cache` is `true`. Clients SHOULD expect the server to do so. By
// default, future calls to
// [Execute][build.bazel.remote.execution.v2.Execution.Execute] the same
// `Action` will also serve their results from the cache. Clients must take care
// to understand the caching behaviour. Ideally, all `Action`s will be
// reproducible so that serving a result from cache is always desirable and
// correct.
type Action struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The digest of the [Command][build.bazel.remote.execution.v2.Command]
	// to run, which MUST be present in the
	// [ContentAddressableStorage][build.bazel.remote.execution.v2.ContentAddressableStorage].
	CommandDigest *Digest `protobuf:"bytes,1,opt,name=command_digest,json=commandDigest,proto3" json:"command_digest,omitempty"`
	// The digest of the root
	// [Directory][build.bazel.remote.execution.v2.Directory] for the input
	// files. The files in the directory tree are available in the correct
	// location on the build machine before the command is executed. The root
	// directory, as well as every subdirectory and content blob referred to, MUST
	// be in the
	// [ContentAddressableStorage][build.bazel.remote.execution.v2.ContentAddressableStorage].
	InputRootDigest *Digest `protobuf:"bytes,2,opt,name=input_root_digest,json=inputRootDigest,proto3" json:"input_root_digest,omitempty"`
	// A timeout after which the execution should be killed. If the timeout is
	// absent, then the client is specifying that the execution should continue
	// as long as the server will let it. The server SHOULD impose a timeout if
	// the client does not specify one, however, if the client does specify a
	// timeout that is longer than the server's maximum timeout, the server MUST
	// reject the request.
	//
	// The timeout is only intended to cover the "execution" of the specified
	// action and not time in queue nor any overheads before or after execution
	// such as marshalling inputs/outputs. The server SHOULD avoid including time
	// spent the client doesn't have control over, and MAY extend or reduce the
	// timeout to account for delays or speedups that occur during execution
	// itself (e.g., lazily loading data from the Content Addressable Storage,
	// live migration of virtual machines, emulation overhead).
	//
	// The timeout is a part of the
	// [Action][build.bazel.remote.execution.v2.Action] message, and
	// therefore two `Actions` with different timeouts are different, even if they
	// are otherwise identical. This is because, if they were not, running an
	// `Action` with a lower timeout than is required might result in a cache hit
	// from an execution run with a longer timeout, hiding the fact that the
	// timeout is too short. By encoding it directly in the `Action`, a lower
	// timeout will result in a cache miss and the execution timeout will fail
	// immediately, rather than whenever the cache entry gets evicted.
	Timeout *durationpb.Duration `protobuf:"bytes,6,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// If true, then the `Action`'s result cannot be cached, and in-flight
	// requests for the same `Action` may not be merged.
	DoNotCache bool `protobuf:"varint,7,opt,name=do_not_cache,json=doNotCache,proto3" json:"do_not_cache,omitempty"`
	// An optional additional salt value used to place this `Action` into a
	// separate cache namespace from other instances having the same field
	// contents. This salt typically comes from operational configuration
	// specific to sources such as repo and service configuration,
	// and allows disowning an entire set of ActionResults that might have been
	// poisoned by buggy software or tool failures.
	Salt []byte `protobuf:"bytes,9,opt,name=salt,proto3" json:"salt,omitempty"`
	// The optional platform requirements for the execution environment. The
	// server MAY choose to execute the action on any worker satisfying the
	// requirements, so the client SHOULD ensure that running the action on any
	// such worker will have the same result.  A detailed lexicon for this can be
	// found in the accompanying platform.md.
	// New in version 2.2: clients SHOULD set these platform properties as well
	// as those in the [Command][build.bazel.remote.execution.v2.Command]. Servers
	// SHOULD prefer those set here.
	Platform      *Platform `protobuf:"bytes,10,opt,name=platform,proto3" json:"platform,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Action) ProtoMessage() {}

func (x *Action) ProtoReflect() protoreflect.Message {
	mi := &file_build_bazel_remote_execution_v2_remote_execution_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)
}

// Deprecated: Use Action.ProtoReflect.Descriptor instead.
func (*Action) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{0}
}

func (x *Action) GetCommandDigest() *Digest {
	if x != nil {
		return x.CommandDigest
	}
	return nil
}

func (x *Action) GetInputRootDigest() *Digest {
	if x != nil {
		return x.InputRootDigest
	}
	return nil
}

func (x *Action) GetTimeout() *durationpb.Duration {
	if x != nil {
		return x.Timeout
	}
	return nil
}

func (x *Action) GetDoNotCache() bool {
	if x != nil {
		return x.DoNotCache
	}
	return false
}

func (x *Action) GetSalt() []byte {
	if x != nil {
		return x.Salt
	}
	return nil
}

func (x *Action) GetPlatform() *Platform {
	if x != nil {
		return x.Platform
	}
	return nil
}

// A `Command` is the actual command executed by a worker running an
// [Action][build.bazel.remote.execution.v2.Action] and specifications of its
// environment.
//
// Except as otherwise required, the environment (such as which system
// libraries or binaries are available, and what filesystems are mounted where)
// is defined by and specific to the implementation of the remote execution API.
type Command struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The arguments to the command.
	//
	// The first argument specifies the command to run, which may be either an
	// absolute path, a path relative to the working directory, or an unqualified
	// path (without path separators) which will be resolved using the operating
	// system's equivalent of the PATH environment variable. Path separators
	// native to the operating system running on the worker SHOULD be used. If the
	// `environment_variables` list contains an entry for the PATH environment
	// variable, it SHOULD be respected. If not, the resolution process is
	// implementation-defined.
	//
	// Changed in v2.3. v2.2 and older require that no PATH lookups are performed,
	// and that relative paths are resolved relative to the input root. This
	// behavior can, however, not be relied upon, as most implementations already
	// followed the rules described above.
	Arguments []string `protobuf:"bytes,1,rep,name=arguments,proto3" json:"arguments,omitempty"`
	// The environment variables to set when running the program. The worker may
	// provide its own default environment variables; these defaults can be
	// overridden using this field. Additional variables can also be specified.
	//
	// In order to ensure that equivalent
	// [Command][build.bazel.remote.execution.v2.Command]s always hash to the same
	// value, the environment variables MUST be lexicographically sorted by name.
	// Sorting of strings is done by code point, equivalently, by the UTF-8 bytes.
	EnvironmentVariables []*Command_EnvironmentVariable `protobuf:"bytes,2,rep,name=environment_variables,json=environmentVariables,proto3" json:"environment_variables,omitempty"`
	// A list of the output files that the client expects to retrieve from the
	// action. Only the listed files, as well as directories listed in
	// `output_directories`, will be returned to the client as output.
	// Other files or directories that may be created during command execution
	// are discarded.
	//
	// The paths are relative to the working directory of the action execution.
	// The paths are specified using a single forward slash (`/`) as a path
	// separator, even if the execution platform natively uses a different
	// separator. The path MUST NOT include a trailing slash, nor a leading slash,
	// being a relative path.
	//
	// In order to ensure consistent hashing of the same Action, the output paths
	// MUST be sorted lexicographically by code point (or, equivalently, by UTF-8
	// bytes).
	//
	// An output file cannot be duplicated, be a parent of another output file, or
	// have the same path as any of the listed output directories.
	//
	// Directories leading up to the output files are created by the worker prior
	// to execution, even if they are not explicitly part of the input root.
	//
	// DEPRECATED since v2.1: Use `output_paths` instead.
	//
	// Deprecated: Marked as deprecated in build/bazel/remote/execution/v2/remote_execution.proto.
	OutputFiles []string `protobuf:"bytes,3,rep,name=output_files,json=outputFiles,proto3" json:"output_files,omitempty"`
	// A list of the output directories that the client expects to retrieve from
	// the action. Only the listed directories will be returned (an entire
	// directory structure will be returned as a
	// [Tree][build.bazel.remote.execution.v2.Tree] message digest, see
	// [OutputDirectory][build.bazel.remote.execution.v2.OutputDirectory]), as
	// well as files listed in `output_files`. Other files or directories that
	// may be created during command execution are discarded.
	//
	// The paths are relative to the working directory of the action execution.
	// The paths are specified using a single forward slash (`/`) as a path
	// separator, even if the execution platform natively uses a different
	// separator. The path MUST NOT include a trailing slash, nor a leading slash,
	// being a relative path. The special value of empty string is allowed,
	// although not recommended, and can be used to capture the entire working
	// directory tree, including inputs.
	//
	// In order to ensure consistent hashing of the same Action, the output paths
	// MUST be sorted lexicographically by code point (or, equivalently, by UTF-8
	// bytes).
	//
	// An output directory cannot be duplicated or have the same path as any of
	// the listed output files. An output directory is allowed to be a parent of
	// another output directory.
	//
	// Directories leading up to the output directories (but not the output
	// directories themselves) are created by the worker prior to execution, even
	// if they are not explicitly part of the input root.
	//
	// DEPRECATED since 2.1: Use `output_paths` instead.
	//
	// Deprecated: Marked as deprecated in build/bazel/remote/execution/v2/remote_execution.proto.
	OutputDirectories []string `protobuf:"bytes,4,rep,name=output_directories,json=outputDirectories,proto3" json:"output_directories,omitempty"`
	// A list of the output paths that the client expects to retrieve from the
	// action. Only the listed paths will be returned to the client as output.
	// The type of the output (file or directory) is not specified, and will be
	// determined by the server after action execution. If the resulting path is
	// a file, it will be returned in an
	// [OutputFile][build.bazel.remote.execution.v2.OutputFile] typed field.
	// If the path is a directory, the entire directory structure will be returned
	// as a [Tree][build.bazel.remote.execution.v2.Tree] message digest, see
	// [OutputDirectory][build.bazel.remote.execution.v2.OutputDirectory]
	// Other files or directories that may be created during command execution
	// are discarded.
	//
	// The paths are relative to the working directory of the action execution.
	// The paths are specified using a single forward slash (`/`) as a path
	// separator, even if the execution platform natively uses a different
	// separator. The path MUST NOT include a trailing slash, nor a leading slash,
	// being a relative path.
	//
	// In order to ensure consistent hashing of the same Action, the output paths
	// MUST be deduplicated and sorted lexicographically by code point (or,
	// equivalently, by UTF-8 bytes).
	//
	// Directories leading up to the output paths are created by the worker prior
	// to execution, even if they are not explicitly part of the input root.
	//
	// New in v2.1: this field supersedes the DEPRECATED `output_files` and
	// `output_directories` fields. If `output_paths` is used, `output_files` and
	// `output_directories` will be ignored!
	OutputPaths []string `protobuf:"bytes,7,rep,name=output_paths,json=outputPaths,proto3" json:"output_paths,omitempty"`
	// The platform requirements for the execution environment. The server MAY
	// choose to execute the action on any worker satisfying the requirements, so
	// the client SHOULD ensure that running the action on any such worker will
	// have the same result.  A detailed lexicon for this can be found in the
	// accompanying platform.md.
	// DEPRECATED as of v2.2: platform properties are now specified directly in
	// the action. See documentation note in the
	// [Action][build.bazel.remote.execution.v2.Action] for migration.
	//
	// Deprecated: Marked as deprecated in build/bazel/remote/execution/v2/remote_execution.proto.
	Platform *Platform `protobuf:"bytes,5,opt,name=platform,proto3" json:"platform,omitempty"`
	// The working directory, relative to the input root, for the command to run
	// in. It must be a directory which exists in the input tree. If it is left
	// empty, then the action is run in the input root.
	WorkingDirectory string `protobuf:"bytes,6,opt,name=working_directory,json=workingDirectory,proto3" json:"working_directory,omitempty"`
	// A list of keys for node properties the client expects to retrieve for
	// output files and directories. Keys are either names of string-based
	// [NodeProperty][build.bazel.remote.execution.v2.NodeProperty] or
	// names of fields in [NodeProperties][build.bazel.remote.execution.v2.NodeProperties].
	// In order to ensure that equivalent `Action`s always hash to the same
	// value, the node properties MUST be lexicographically sorted by name.
	// Sorting of strings is done by code point, equivalently, by the UTF-8 bytes.
	//
	// The interpretation of string-based properties is server-dependent. If a
	// property is not recognized by the server, the server will return an
	// `INVALID_ARGUMENT`.
	OutputNodeProperties []string `protobuf:"bytes,8,rep,name=output_node_properties,json=outputNodeProperties,proto3" json:"output_node_properties,omitempty"`
	// The format that the worker should use to store the contents of
	// output directories.
	//
	// In case this field is set to a value that is not supported by the
	// worker, the worker SHOULD interpret this field as TREE_ONLY. The
	// worker MAY store output directories in formats that are a superset
	// of what was requested (e.g., interpreting DIRECTORY_ONLY as
	// TREE_AND_DIRECTORY).
	OutputDirectoryFormat Command_OutputDirectoryFormat `protobuf:"varint,9,opt,name=output_directory_format,json=outputDirectoryFormat,proto3,enum=build.bazel.remote.execution.v2.Command_OutputDirectoryFormat" json:"output_directory_format,omitempty"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

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

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

func (*Command) ProtoMessage() {}

func (x *Command) ProtoReflect() protoreflect.Message {
	mi := &file_build_bazel_remote_execution_v2_remote_execution_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)
}

// Deprecated: Use Command.ProtoReflect.Descriptor instead.
func (*Command) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{1}
}

func (x *Command) GetArguments() []string {
	if x != nil {
		return x.Arguments
	}
	return nil
}

func (x *Command) GetEnvironmentVariables() []*Command_EnvironmentVariable {
	if x != nil {
		return x.EnvironmentVariables
	}
	return nil
}

// Deprecated: Marked as deprecated in build/bazel/remote/execution/v2/remote_execution.proto.
func (x *Command) GetOutputFiles() []string {
	if x != nil {
		return x.OutputFiles
	}
	return nil
}

// Deprecated: Marked as deprecated in build/bazel/remote/execution/v2/remote_execution.proto.
func (x *Command) GetOutputDirectories() []string {
	if x != nil {
		return x.OutputDirectories
	}
	return nil
}

func (x *Command) GetOutputPaths() []string {
	if x != nil {
		return x.OutputPaths
	}
	return nil
}

// Deprecated: Marked as deprecated in build/bazel/remote/execution/v2/remote_execution.proto.
func (x *Command) GetPlatform() *Platform {
	if x != nil {
		return x.Platform
	}
	return nil
}

func (x *Command) GetWorkingDirectory() string {
	if x != nil {
		return x.WorkingDirectory
	}
	return ""
}

func (x *Command) GetOutputNodeProperties() []string {
	if x != nil {
		return x.OutputNodeProperties
	}
	return nil
}

func (x *Command) GetOutputDirectoryFormat() Command_OutputDirectoryFormat {
	if x != nil {
		return x.OutputDirectoryFormat
	}
	return Command_TREE_ONLY
}

// A `Platform` is a set of requirements, such as hardware, operating system, or
// compiler toolchain, for an
// [Action][build.bazel.remote.execution.v2.Action]'s execution
// environment. A `Platform` is represented as a series of key-value pairs
// representing the properties that are required of the platform.
type Platform struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The properties that make up this platform. In order to ensure that
	// equivalent `Platform`s always hash to the same value, the properties MUST
	// be lexicographically sorted by name, and then by value. Sorting of strings
	// is done by code point, equivalently, by the UTF-8 bytes.
	Properties    []*Platform_Property `protobuf:"bytes,1,rep,name=properties,proto3" json:"properties,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Platform) ProtoMessage() {}

func (x *Platform) ProtoReflect() protoreflect.Message {
	mi := &file_build_bazel_remote_execution_v2_remote_execution_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)
}

// Deprecated: Use Platform.ProtoReflect.Descriptor instead.
func (*Platform) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{2}
}

func (x *Platform) GetProperties() []*Platform_Property {
	if x != nil {
		return x.Properties
	}
	return nil
}

// A `Directory` represents a directory node in a file tree, containing zero or
// more children [FileNodes][build.bazel.remote.execution.v2.FileNode],
// [DirectoryNodes][build.bazel.remote.execution.v2.DirectoryNode] and
// [SymlinkNodes][build.bazel.remote.execution.v2.SymlinkNode].
// Each `Node` contains its name in the directory, either the digest of its
// content (either a file blob or a `Directory` proto) or a symlink target, as
// well as possibly some metadata about the file or directory.
//
// In order to ensure that two equivalent directory trees hash to the same
// value, the following restrictions MUST be obeyed when constructing
// a `Directory`:
//
//   - Every child in the directory must have a path of exactly one segment.
//     Multiple levels of directory hierarchy may not be collapsed.
//   - Each child in the directory must have a unique path segment (file name).
//     Note that while the API itself is case-sensitive, the environment where
//     the Action is executed may or may not be case-sensitive. That is, it is
//     legal to call the API with a Directory that has both "Foo" and "foo" as
//     children, but the Action may be rejected by the remote system upon
//     execution.
//   - The files, directories and symlinks in the directory must each be sorted
//     in lexicographical order by path. The path strings must be sorted by code
//     point, equivalently, by UTF-8 bytes.
//   - The [NodeProperties][build.bazel.remote.execution.v2.NodeProperty] of files,
//     directories, and symlinks must be sorted in lexicographical order by
//     property name.
//
// A `Directory` that obeys the restrictions is said to be in canonical form.
//
// As an example, the following could be used for a file named `bar` and a
// directory named `foo` with an executable file named `baz` (hashes shortened
// for readability):
//
// ```json
// // (Directory proto)
//
//	{
//	  files: [
//	    {
//	      name: "bar",
//	      digest: {
//	        hash: "4a73bc9d03...",
//	        size: 65534
//	      },
//	      node_properties: [
//	        {
//	          "name": "MTime",
//	          "value": "2017-01-15T01:30:15.01Z"
//	        }
//	      ]
//	    }
//	  ],
//	  directories: [
//	    {
//	      name: "foo",
//	      digest: {
//	        hash: "4cf2eda940...",
//	        size: 43
//	      }
//	    }
//	  ]
//	}
//
// // (Directory proto with hash "4cf2eda940..." and size 43)
//
//	{
//	  files: [
//	    {
//	      name: "baz",
//	      digest: {
//	        hash: "b2c941073e...",
//	        size: 1294,
//	      },
//	      is_executable: true
//	    }
//	  ]
//	}
//
// ```
type Directory struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The files in the directory.
	Files []*FileNode `protobuf:"bytes,1,rep,name=files,proto3" json:"files,omitempty"`
	// The subdirectories in the directory.
	Directories []*DirectoryNode `protobuf:"bytes,2,rep,name=directories,proto3" json:"directories,omitempty"`
	// The symlinks in the directory.
	Symlinks       []*SymlinkNode  `protobuf:"bytes,3,rep,name=symlinks,proto3" json:"symlinks,omitempty"`
	NodeProperties *NodeProperties `protobuf:"bytes,5,opt,name=node_properties,json=nodeProperties,proto3" json:"node_properties,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*Directory) ProtoMessage() {}

func (x *Directory) ProtoReflect() protoreflect.Message {
	mi := &file_build_bazel_remote_execution_v2_remote_execution_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)
}

// Deprecated: Use Directory.ProtoReflect.Descriptor instead.
func (*Directory) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{3}
}

func (x *Directory) GetFiles() []*FileNode {
	if x != nil {
		return x.Files
	}
	return nil
}

func (x *Directory) GetDirectories() []*DirectoryNode {
	if x != nil {
		return x.Directories
	}
	return nil
}

func (x *Directory) GetSymlinks() []*SymlinkNode {
	if x != nil {
		return x.Symlinks
	}
	return nil
}

func (x *Directory) GetNodeProperties() *NodeProperties {
	if x != nil {
		return x.NodeProperties
	}
	return nil
}

// A single property for [FileNodes][build.bazel.remote.execution.v2.FileNode],
// [DirectoryNodes][build.bazel.remote.execution.v2.DirectoryNode], and
// [SymlinkNodes][build.bazel.remote.execution.v2.SymlinkNode]. The server is
// responsible for specifying the property `name`s that it accepts. If
// permitted by the server, the same `name` may occur multiple times.
type NodeProperty struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The property name.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The property value.
	Value         string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*NodeProperty) ProtoMessage() {}

func (x *NodeProperty) ProtoReflect() protoreflect.Message {
	mi := &file_build_bazel_remote_execution_v2_remote_execution_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)
}

// Deprecated: Use NodeProperty.ProtoReflect.Descriptor instead.
func (*NodeProperty) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{4}
}

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

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

// Node properties for [FileNodes][build.bazel.remote.execution.v2.FileNode],
// [DirectoryNodes][build.bazel.remote.execution.v2.DirectoryNode], and
// [SymlinkNodes][build.bazel.remote.execution.v2.SymlinkNode]. The server is
// responsible for specifying the properties that it accepts.
type NodeProperties struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A list of string-based
	// [NodeProperties][build.bazel.remote.execution.v2.NodeProperty].
	Properties []*NodeProperty `protobuf:"bytes,1,rep,name=properties,proto3" json:"properties,omitempty"`
	// The file's last modification timestamp.
	Mtime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=mtime,proto3" json:"mtime,omitempty"`
	// The UNIX file mode, e.g., 0755.
	UnixMode      *wrapperspb.UInt32Value `protobuf:"bytes,3,opt,name=unix_mode,json=unixMode,proto3" json:"unix_mode,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*NodeProperties) ProtoMessage() {}

func (x *NodeProperties) ProtoReflect() protoreflect.Message {
	mi := &file_build_bazel_remote_execution_v2_remote_execution_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)
}

// Deprecated: Use NodeProperties.ProtoReflect.Descriptor instead.
func (*NodeProperties) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{5}
}

func (x *NodeProperties) GetProperties() []*NodeProperty {
	if x != nil {
		return x.Properties
	}
	return nil
}

func (x *NodeProperties) GetMtime() *timestamppb.Timestamp {
	if x != nil {
		return x.Mtime
	}
	return nil
}

func (x *NodeProperties) GetUnixMode() *wrapperspb.UInt32Value {
	if x != nil {
		return x.UnixMode
	}
	return nil
}

// A `FileNode` represents a single file and associated metadata.
type FileNode struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The name of the file.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The digest of the file's content.
	Digest *Digest `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
	// True if file is executable, false otherwise.
	IsExecutable   bool            `protobuf:"varint,4,opt,name=is_executable,json=isExecutable,proto3" json:"is_executable,omitempty"`
	NodeProperties *NodeProperties `protobuf:"bytes,6,opt,name=node_properties,json=nodeProperties,proto3" json:"node_properties,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*FileNode) ProtoMessage() {}

func (x *FileNode) ProtoReflect() protoreflect.Message {
	mi := &file_build_bazel_remote_execution_v2_remote_execution_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)
}

// Deprecated: Use FileNode.ProtoReflect.Descriptor instead.
func (*FileNode) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{6}
}

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

func (x *FileNode) GetDigest() *Digest {
	if x != nil {
		return x.Digest
	}
	return nil
}

func (x *FileNode) GetIsExecutable() bool {
	if x != nil {
		return x.IsExecutable
	}
	return false
}

func (x *FileNode) GetNodeProperties() *NodeProperties {
	if x != nil {
		return x.NodeProperties
	}
	return nil
}

// A `DirectoryNode` represents a child of a
// [Directory][build.bazel.remote.execution.v2.Directory] which is itself
// a `Directory` and its associated metadata.
type DirectoryNode struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The name of the directory.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The digest of the
	// [Directory][build.bazel.remote.execution.v2.Directory] object
	// represented. See [Digest][build.bazel.remote.execution.v2.Digest]
	// for information about how to take the digest of a proto message.
	Digest        *Digest `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DirectoryNode) ProtoMessage() {}

func (x *DirectoryNode) ProtoReflect() protoreflect.Message {
	mi := &file_build_bazel_remote_execution_v2_remote_execution_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)
}

// Deprecated: Use DirectoryNode.ProtoReflect.Descriptor instead.
func (*DirectoryNode) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{7}
}

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

func (x *DirectoryNode) GetDigest() *Digest {
	if x != nil {
		return x.Digest
	}
	return nil
}

// A `SymlinkNode` represents a symbolic link.
type SymlinkNode struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The name of the symlink.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The target path of the symlink. The path separator is a forward slash `/`.
	// The target path can be relative to the parent directory of the symlink or
	// it can be an absolute path starting with `/`. Support for absolute paths
	// can be checked using the [Capabilities][build.bazel.remote.execution.v2.Capabilities]
	// API. `..` components are allowed anywhere in the target path as logical
	// canonicalization may lead to different behavior in the presence of
	// directory symlinks (e.g. `foo/../bar` may not be the same as `bar`).
	// To reduce potential cache misses, canonicalization is still recommended
	// where this is possible without impacting correctness.
	Target         string          `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"`
	NodeProperties *NodeProperties `protobuf:"bytes,4,opt,name=node_properties,json=nodeProperties,proto3" json:"node_properties,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*SymlinkNode) ProtoMessage() {}

func (x *SymlinkNode) ProtoReflect() protoreflect.Message {
	mi := &file_build_bazel_remote_execution_v2_remote_execution_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)
}

// Deprecated: Use SymlinkNode.ProtoReflect.Descriptor instead.
func (*SymlinkNode) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{8}
}

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

func (x *SymlinkNode) GetTarget() string {
	if x != nil {
		return x.Target
	}
	return ""
}

func (x *SymlinkNode) GetNodeProperties() *NodeProperties {
	if x != nil {
		return x.NodeProperties
	}
	return nil
}

// A content digest. A digest for a given blob consists of the size of the blob
// and its hash. The hash algorithm to use is defined by the server.
//
// The size is considered to be an integral part of the digest and cannot be
// separated. That is, even if the `hash` field is correctly specified but
// `size_bytes` is not, the server MUST reject the request.
//
// The reason for including the size in the digest is as follows: in a great
// many cases, the server needs to know the size of the blob it is about to work
// with prior to starting an operation with it, such as flattening Merkle tree
// structures or streaming it to a worker. Technically, the server could
// implement a separate metadata store, but this results in a significantly more
// complicated implementation as opposed to having the client specify the size
// up-front (or storing the size along with the digest in every message where
// digests are embedded). This does mean that the API leaks some implementation
// details of (what we consider to be) a reasonable server implementation, but
// we consider this to be a worthwhile tradeoff.
//
// When a `Digest` is used to refer to a proto message, it always refers to the
// message in binary encoded form. To ensure consistent hashing, clients and
// servers MUST ensure that they serialize messages according to the following
// rules, even if there are alternate valid encodings for the same message:
//
// * Fields are serialized in tag order.
// * There are no unknown fields.
// * There are no duplicate fields.
// * Fields are serialized according to the default semantics for their type.
//
// Most protocol buffer implementations will always follow these rules when
// serializing, but care should be taken to avoid shortcuts. For instance,
// concatenating two messages to merge them may produce duplicate fields.
type Digest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The hash, represented as a lowercase hexadecimal string, padded with
	// leading zeroes up to the hash function length.
	Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	// The size of the blob, in bytes.
	SizeBytes     int64 `protobuf:"varint,2,opt,name=size_bytes,json=sizeBytes,proto3" json:"size_bytes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Digest) ProtoMessage() {}

func (x *Digest) ProtoReflect() protoreflect.Message {
	mi := &file_build_bazel_remote_execution_v2_remote_execution_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)
}

// Deprecated: Use Digest.ProtoReflect.Descriptor instead.
func (*Digest) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{9}
}

func (x *Digest) GetHash() string {
	if x != nil {
		return x.Hash
	}
	return ""
}

func (x *Digest) GetSizeBytes() int64 {
	if x != nil {
		return x.SizeBytes
	}
	return 0
}

// ExecutedActionMetadata contains details about a completed execution.
type ExecutedActionMetadata struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The name of the worker which ran the execution.
	Worker string `protobuf:"bytes,1,opt,name=worker,proto3" json:"worker,omitempty"`
	// When was the action added to the queue.
	QueuedTimestamp *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=queued_timestamp,json=queuedTimestamp,proto3" json:"queued_timestamp,omitempty"`
	// When the worker received the action.
	WorkerStartTimestamp *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=worker_start_timestamp,json=workerStartTimestamp,proto3" json:"worker_start_timestamp,omitempty"`
	// When the worker completed the action, including all stages.
	WorkerCompletedTimestamp *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=worker_completed_timestamp,json=workerCompletedTimestamp,proto3" json:"worker_completed_timestamp,omitempty"`
	// When the worker started fetching action inputs.
	InputFetchStartTimestamp *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=input_fetch_start_timestamp,json=inputFetchStartTimestamp,proto3" json:"input_fetch_start_timestamp,omitempty"`
	// When the worker finished fetching action inputs.
	InputFetchCompletedTimestamp *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=input_fetch_completed_timestamp,json=inputFetchCompletedTimestamp,proto3" json:"input_fetch_completed_timestamp,omitempty"`
	// When the worker started executing the action command.
	ExecutionStartTimestamp *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=execution_start_timestamp,json=executionStartTimestamp,proto3" json:"execution_start_timestamp,omitempty"`
	// When the worker completed executing the action command.
	ExecutionCompletedTimestamp *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=execution_completed_timestamp,json=executionCompletedTimestamp,proto3" json:"execution_completed_timestamp,omitempty"`
	// New in v2.3: the amount of time the worker spent executing the action
	// command, potentially computed using a worker-specific virtual clock.
	//
	// The virtual execution duration is only intended to cover the "execution" of
	// the specified action and not time in queue nor any overheads before or
	// after execution such as marshalling inputs/outputs. The server SHOULD avoid
	// including time spent the client doesn't have control over, and MAY extend
	// or reduce the execution duration to account for delays or speedups that
	// occur during execution itself (e.g., lazily loading data from the Content
	// Addressable Storage, live migration of virtual machines, emulation
	// overhead).
	//
	// The method of timekeeping used to compute the virtual execution duration
	// MUST be consistent with what is used to enforce the
	// [Action][build.bazel.remote.execution.v2.Action]'s `timeout`. There is no
	// relationship between the virtual execution duration and the values of
	// `execution_start_timestamp` and `execution_completed_timestamp`.
	VirtualExecutionDuration *durationpb.Duration `protobuf:"bytes,12,opt,name=virtual_execution_duration,json=virtualExecutionDuration,proto3" json:"virtual_execution_duration,omitempty"`
	// When the worker started uploading action outputs.
	OutputUploadStartTimestamp *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=output_upload_start_timestamp,json=outputUploadStartTimestamp,proto3" json:"output_upload_start_timestamp,omitempty"`
	// When the worker finished uploading action outputs.
	OutputUploadCompletedTimestamp *timestamppb.Timestamp `protobuf:"bytes,10,opt,name=output_upload_completed_timestamp,json=outputUploadCompletedTimestamp,proto3" json:"output_upload_completed_timestamp,omitempty"`
	// Details that are specific to the kind of worker used. For example,
	// on POSIX-like systems this could contain a message with
	// getrusage(2) statistics.
	AuxiliaryMetadata []*anypb.Any `protobuf:"bytes,11,rep,name=auxiliary_metadata,json=auxiliaryMetadata,proto3" json:"auxiliary_metadata,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

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

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

func (*ExecutedActionMetadata) ProtoMessage() {}

func (x *ExecutedActionMetadata) ProtoReflect() protoreflect.Message {
	mi := &file_build_bazel_remote_execution_v2_remote_execution_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)
}

// Deprecated: Use ExecutedActionMetadata.ProtoReflect.Descriptor instead.
func (*ExecutedActionMetadata) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{10}
}

func (x *ExecutedActionMetadata) GetWorker() string {
	if x != nil {
		return x.Worker
	}
	return ""
}

func (x *ExecutedActionMetadata) GetQueuedTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.QueuedTimestamp
	}
	return nil
}

func (x *ExecutedActionMetadata) GetWorkerStartTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.WorkerStartTimestamp
	}
	return nil
}

func (x *ExecutedActionMetadata) GetWorkerCompletedTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.WorkerCompletedTimestamp
	}
	return nil
}

func (x *ExecutedActionMetadata) GetInputFetchStartTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.InputFetchStartTimestamp
	}
	return nil
}

func (x *ExecutedActionMetadata) GetInputFetchCompletedTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.InputFetchCompletedTimestamp
	}
	return nil
}

func (x *ExecutedActionMetadata) GetExecutionStartTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.ExecutionStartTimestamp
	}
	return nil
}

func (x *ExecutedActionMetadata) GetExecutionCompletedTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.ExecutionCompletedTimestamp
	}
	return nil
}

func (x *ExecutedActionMetadata) GetVirtualExecutionDuration() *durationpb.Duration {
	if x != nil {
		return x.VirtualExecutionDuration
	}
	return nil
}

func (x *ExecutedActionMetadata) GetOutputUploadStartTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.OutputUploadStartTimestamp
	}
	return nil
}

func (x *ExecutedActionMetadata) GetOutputUploadCompletedTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.OutputUploadCompletedTimestamp
	}
	return nil
}

func (x *ExecutedActionMetadata) GetAuxiliaryMetadata() []*anypb.Any {
	if x != nil {
		return x.AuxiliaryMetadata
	}
	return nil
}

// An ActionResult represents the result of an
// [Action][build.bazel.remote.execution.v2.Action] being run.
//
// It is advised that at least one field (for example
// `ActionResult.execution_metadata.Worker`) have a non-default value, to
// ensure that the serialized value is non-empty, which can then be used
// as a basic data sanity check.
type ActionResult struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The output files of the action. For each output file requested in the
	// `output_files` or `output_paths` field of the Action, if the corresponding
	// file existed after the action completed, a single entry will be present
	// either in this field, or the `output_file_symlinks` field if the file was
	// a symbolic link to another file (`output_symlinks` field after v2.1).
	//
	// If an output listed in `output_files` was found, but was a directory rather
	// than a regular file, the server will return a FAILED_PRECONDITION.
	// If the action does not produce the requested output, then that output
	// will be omitted from the list. The server is free to arrange the output
	// list as desired; clients MUST NOT assume that the output list is sorted.
	OutputFiles []*OutputFile `protobuf:"bytes,2,rep,name=output_files,json=outputFiles,proto3" json:"output_files,omitempty"`
	// The output files of the action that are symbolic links to other files. Those
	// may be links to other output files, or input files, or even absolute paths
	// outside of the working directory, if the server supports
	// [SymlinkAbsolutePathStrategy.ALLOWED][build.bazel.remote.execution.v2.CacheCapabilities.SymlinkAbsolutePathStrategy].
	// For each output file requested in the `output_files` or `output_paths`
	// field of the Action, if the corresponding file existed after
	// the action completed, a single entry will be present either in this field,
	// or in the `output_files` field, if the file was not a symbolic link.
	//
	// If an output symbolic link of the same name as listed in `output_files` of
	// the Command was found, but its target type was not a regular file, the
	// server will return a FAILED_PRECONDITION.
	// If the action does not produce the requested output, then that output
	// will be omitted from the list. The server is free to arrange the output
	// list as desired; clients MUST NOT assume that the output list is sorted.
	//
	// DEPRECATED as of v2.1. Servers that wish to be compatible with v2.0 API
	// should still populate this field in addition to `output_symlinks`.
	//
	// Deprecated: Marked as deprecated in build/bazel/remote/execution/v2/remote_execution.proto.
	OutputFileSymlinks []*OutputSymlink `protobuf:"bytes,10,rep,name=output_file_symlinks,json=outputFileSymlinks,proto3" json:"output_file_symlinks,omitempty"`
	// New in v2.1: this field will only be populated if the command
	// `output_paths` field was used, and not the pre v2.1 `output_files` or
	// `output_directories` fields.
	// The output paths of the action that are symbolic links to other paths. Those
	// may be links to other outputs, or inputs, or even absolute paths
	// outside of the working directory, if the server supports
	// [SymlinkAbsolutePathStrategy.ALLOWED][build.bazel.remote.execution.v2.CacheCapabilities.SymlinkAbsolutePathStrategy].
	// A single entry for each output requested in `output_paths`
	// field of the Action, if the corresponding path existed after
	// the action completed and was a symbolic link.
	//
	// If the action does not produce a requested output, then that output
	// will be omitted from the list. The server is free to arrange the output
	// list as desired; clients MUST NOT assume that the output list is sorted.
	OutputSymlinks []*OutputSymlink `protobuf:"bytes,12,rep,name=output_symlinks,json=outputSymlinks,proto3" json:"output_symlinks,omitempty"`
	// The output directories of the action. For each output directory requested
	// in the `output_directories` or `output_paths` field of the Action, if the
	// corresponding directory existed after the action completed, a single entry
	// will be present in the output list, which will contain the digest of a
	// [Tree][build.bazel.remote.execution.v2.Tree] message containing the
	// directory tree, and the path equal exactly to the corresponding Action
	// output_directories member.
	//
	// As an example, suppose the Action had an output directory `a/b/dir` and the
	// execution produced the following contents in `a/b/dir`: a file named `bar`
	// and a directory named `foo` with an executable file named `baz`. Then,
	// output_directory will contain (hashes shortened for readability):
	//
	// ```json
	// // OutputDirectory proto:
	//
	//	{
	//	  path: "a/b/dir"
	//	  tree_digest: {
	//	    hash: "4a73bc9d03...",
	//	    size: 55
	//	  }
	//	}
	//
	// // Tree proto with hash "4a73bc9d03..." and size 55:
	//
	//	{
	//	  root: {
	//	    files: [
	//	      {
	//	        name: "bar",
	//	        digest: {
	//	          hash: "4a73bc9d03...",
	//	          size: 65534
	//	        }
	//	      }
	//	    ],
	//	    directories: [
	//	      {
	//	        name: "foo",
	//	        digest: {
	//	          hash: "4cf2eda940...",
	//	          size: 43
	//	        }
	//	      }
	//	    ]
	//	  }
	//	  children : {
	//	    // (Directory proto with hash "4cf2eda940..." and size 43)
	//	    files: [
	//	      {
	//	        name: "baz",
	//	        digest: {
	//	          hash: "b2c941073e...",
	//	          size: 1294,
	//	        },
	//	        is_executable: true
	//	      }
	//	    ]
	//	  }
	//	}
	//
	// ```
	// If an output of the same name as listed in `output_files` of
	// the Command was found in `output_directories`, but was not a directory, the
	// server will return a FAILED_PRECONDITION.
	OutputDirectories []*OutputDirectory `protobuf:"bytes,3,rep,name=output_directories,json=outputDirectories,proto3" json:"output_directories,omitempty"`
	// The output directories of the action that are symbolic links to other
	// directories. Those may be links to other output directories, or input
	// directories, or even absolute paths outside of the working directory,
	// if the server supports
	// [SymlinkAbsolutePathStrategy.ALLOWED][build.bazel.remote.execution.v2.CacheCapabilities.SymlinkAbsolutePathStrategy].
	// For each output directory requested in the `output_directories` field of
	// the Action, if the directory existed after the action completed, a
	// single entry will be present either in this field, or in the
	// `output_directories` field, if the directory was not a symbolic link.
	//
	// If an output of the same name was found, but was a symbolic link to a file
	// instead of a directory, the server will return a FAILED_PRECONDITION.
	// If the action does not produce the requested output, then that output
	// will be omitted from the list. The server is free to arrange the output
	// list as desired; clients MUST NOT assume that the output list is sorted.
	//
	// DEPRECATED as of v2.1. Servers that wish to be compatible with v2.0 API
	// should still populate this field in addition to `output_symlinks`.
	//
	// Deprecated: Marked as deprecated in build/bazel/remote/execution/v2/remote_execution.proto.
	OutputDirectorySymlinks []*OutputSymlink `protobuf:"bytes,11,rep,name=output_directory_symlinks,json=outputDirectorySymlinks,proto3" json:"output_directory_symlinks,omitempty"`
	// The exit code of the command.
	ExitCode int32 `protobuf:"varint,4,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"`
	// The standard output buffer of the action. The server SHOULD NOT inline
	// stdout unless requested by the client in the
	// [GetActionResultRequest][build.bazel.remote.execution.v2.GetActionResultRequest]
	// message. The server MAY omit inlining, even if requested, and MUST do so if inlining
	// would cause the response to exceed message size limits.
	// Clients SHOULD NOT populate this field when uploading to the cache.
	StdoutRaw []byte `protobuf:"bytes,5,opt,name=stdout_raw,json=stdoutRaw,proto3" json:"stdout_raw,omitempty"`
	// The digest for a blob containing the standard output of the action, which
	// can be retrieved from the
	// [ContentAddressableStorage][build.bazel.remote.execution.v2.ContentAddressableStorage].
	StdoutDigest *Digest `protobuf:"bytes,6,opt,name=stdout_digest,json=stdoutDigest,proto3" json:"stdout_digest,omitempty"`
	// The standard error buffer of the action. The server SHOULD NOT inline
	// stderr unless requested by the client in the
	// [GetActionResultRequest][build.bazel.remote.execution.v2.GetActionResultRequest]
	// message. The server MAY omit inlining, even if requested, and MUST do so if inlining
	// would cause the response to exceed message size limits.
	// Clients SHOULD NOT populate this field when uploading to the cache.
	StderrRaw []byte `protobuf:"bytes,7,opt,name=stderr_raw,json=stderrRaw,proto3" json:"stderr_raw,omitempty"`
	// The digest for a blob containing the standard error of the action, which
	// can be retrieved from the
	// [ContentAddressableStorage][build.bazel.remote.execution.v2.ContentAddressableStorage].
	StderrDigest *Digest `protobuf:"bytes,8,opt,name=stderr_digest,json=stderrDigest,proto3" json:"stderr_digest,omitempty"`
	// The details of the execution that originally produced this result.
	ExecutionMetadata *ExecutedActionMetadata `protobuf:"bytes,9,opt,name=execution_metadata,json=executionMetadata,proto3" json:"execution_metadata,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

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

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

func (*ActionResult) ProtoMessage() {}

func (x *ActionResult) ProtoReflect() protoreflect.Message {
	mi := &file_build_bazel_remote_execution_v2_remote_execution_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)
}

// Deprecated: Use ActionResult.ProtoReflect.Descriptor instead.
func (*ActionResult) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{11}
}

func (x *ActionResult) GetOutputFiles() []*OutputFile {
	if x != nil {
		return x.OutputFiles
	}
	return nil
}

// Deprecated: Marked as deprecated in build/bazel/remote/execution/v2/remote_execution.proto.
func (x *ActionResult) GetOutputFileSymlinks() []*OutputSymlink {
	if x != nil {
		return x.OutputFileSymlinks
	}
	return nil
}

func (x *ActionResult) GetOutputSymlinks() []*OutputSymlink {
	if x != nil {
		return x.OutputSymlinks
	}
	return nil
}

func (x *ActionResult) GetOutputDirectories() []*OutputDirectory {
	if x != nil {
		return x.OutputDirectories
	}
	return nil
}

// Deprecated: Marked as deprecated in build/bazel/remote/execution/v2/remote_execution.proto.
func (x *ActionResult) GetOutputDirectorySymlinks() []*OutputSymlink {
	if x != nil {
		return x.OutputDirectorySymlinks
	}
	return nil
}

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

func (x *ActionResult) GetStdoutRaw() []byte {
	if x != nil {
		return x.StdoutRaw
	}
	return nil
}

func (x *ActionResult) GetStdoutDigest() *Digest {
	if x != nil {
		return x.StdoutDigest
	}
	return nil
}

func (x *ActionResult) GetStderrRaw() []byte {
	if x != nil {
		return x.StderrRaw
	}
	return nil
}

func (x *ActionResult) GetStderrDigest() *Digest {
	if x != nil {
		return x.StderrDigest
	}
	return nil
}

func (x *ActionResult) GetExecutionMetadata() *ExecutedActionMetadata {
	if x != nil {
		return x.ExecutionMetadata
	}
	return nil
}

// An `OutputFile` is similar to a
// [FileNode][build.bazel.remote.execution.v2.FileNode], but it is used as an
// output in an `ActionResult`. It allows a full file path rather than
// only a name.
type OutputFile struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The full path of the file relative to the working directory, including the
	// filename. The path separator is a forward slash `/`. Since this is a
	// relative path, it MUST NOT begin with a leading forward slash.
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	// The digest of the file's content.
	Digest *Digest `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
	// True if file is executable, false otherwise.
	IsExecutable bool `protobuf:"varint,4,opt,name=is_executable,json=isExecutable,proto3" json:"is_executable,omitempty"`
	// The contents of the file if inlining was requested. The server SHOULD NOT inline
	// file contents unless requested by the client in the
	// [GetActionResultRequest][build.bazel.remote.execution.v2.GetActionResultRequest]
	// message. The server MAY omit inlining, even if requested, and MUST do so if inlining
	// would cause the response to exceed message size limits.
	// Clients SHOULD NOT populate this field when uploading to the cache.
	Contents       []byte          `protobuf:"bytes,5,opt,name=contents,proto3" json:"contents,omitempty"`
	NodeProperties *NodeProperties `protobuf:"bytes,7,opt,name=node_properties,json=nodeProperties,proto3" json:"node_properties,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *OutputFile) Reset() {
	*x = OutputFile{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*OutputFile) ProtoMessage() {}

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

// Deprecated: Use OutputFile.ProtoReflect.Descriptor instead.
func (*OutputFile) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{12}
}

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

func (x *OutputFile) GetDigest() *Digest {
	if x != nil {
		return x.Digest
	}
	return nil
}

func (x *OutputFile) GetIsExecutable() bool {
	if x != nil {
		return x.IsExecutable
	}
	return false
}

func (x *OutputFile) GetContents() []byte {
	if x != nil {
		return x.Contents
	}
	return nil
}

func (x *OutputFile) GetNodeProperties() *NodeProperties {
	if x != nil {
		return x.NodeProperties
	}
	return nil
}

// A `Tree` contains all the
// [Directory][build.bazel.remote.execution.v2.Directory] protos in a
// single directory Merkle tree, compressed into one message.
type Tree struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The root directory in the tree.
	Root *Directory `protobuf:"bytes,1,opt,name=root,proto3" json:"root,omitempty"`
	// All the child directories: the directories referred to by the root and,
	// recursively, all its children. In order to reconstruct the directory tree,
	// the client must take the digests of each of the child directories and then
	// build up a tree starting from the `root`.
	// Servers SHOULD ensure that these are ordered consistently such that two
	// actions producing equivalent output directories on the same server
	// implementation also produce Tree messages with matching digests.
	Children      []*Directory `protobuf:"bytes,2,rep,name=children,proto3" json:"children,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Tree) Reset() {
	*x = Tree{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Tree) ProtoMessage() {}

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

// Deprecated: Use Tree.ProtoReflect.Descriptor instead.
func (*Tree) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{13}
}

func (x *Tree) GetRoot() *Directory {
	if x != nil {
		return x.Root
	}
	return nil
}

func (x *Tree) GetChildren() []*Directory {
	if x != nil {
		return x.Children
	}
	return nil
}

// An `OutputDirectory` is the output in an `ActionResult` corresponding to a
// directory's full contents rather than a single file.
type OutputDirectory struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The full path of the directory relative to the working directory. The path
	// separator is a forward slash `/`. Since this is a relative path, it MUST
	// NOT begin with a leading forward slash. The empty string value is allowed,
	// and it denotes the entire working directory.
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	// The digest of the encoded
	// [Tree][build.bazel.remote.execution.v2.Tree] proto containing the
	// directory's contents.
	TreeDigest *Digest `protobuf:"bytes,3,opt,name=tree_digest,json=treeDigest,proto3" json:"tree_digest,omitempty"`
	// If set, consumers MAY make the following assumptions about the
	// directories contained in the Tree, so that it may be
	// instantiated on a local file system by scanning through it
	// sequentially:
	//
	//   - All directories with the same binary representation are stored
	//     exactly once.
	//   - All directories, apart from the root directory, are referenced by
	//     at least one parent directory.
	//   - Directories are stored in topological order, with parents being
	//     stored before the child. The root directory is thus the first to
	//     be stored.
	//
	// Additionally, the Tree MUST be encoded as a stream of records,
	// where each record has the following format:
	//
	// - A tag byte, having one of the following two values:
	//   - (1 << 3) | 2 == 0x0a: First record (the root directory).
	//   - (2 << 3) | 2 == 0x12: Any subsequent records (child directories).
	//   - The size of the directory, encoded as a base 128 varint.
	//   - The contents of the directory, encoded as a binary serialized
	//     Protobuf message.
	//
	// This encoding is a subset of the Protobuf wire format of the Tree
	// message. As it is only permitted to store data associated with
	// field numbers 1 and 2, the tag MUST be encoded as a single byte.
	// More details on the Protobuf wire format can be found here:
	// https://developers.google.com/protocol-buffers/docs/encoding
	//
	// It is recommended that implementations using this feature construct
	// Tree objects manually using the specification given above, as
	// opposed to using a Protobuf library to marshal a full Tree message.
	// As individual Directory messages already need to be marshaled to
	// compute their digests, constructing the Tree object manually avoids
	// redundant marshaling.
	IsTopologicallySorted bool `protobuf:"varint,4,opt,name=is_topologically_sorted,json=isTopologicallySorted,proto3" json:"is_topologically_sorted,omitempty"`
	// The digest of the encoded
	// [Directory][build.bazel.remote.execution.v2.Directory] proto
	// containing the contents of the directory's root.
	//
	// If both `tree_digest` and `root_directory_digest` are set, this
	// field MUST match the digest of the root directory contained in the
	// Tree message.
	RootDirectoryDigest *Digest `protobuf:"bytes,5,opt,name=root_directory_digest,json=rootDirectoryDigest,proto3" json:"root_directory_digest,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *OutputDirectory) Reset() {
	*x = OutputDirectory{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*OutputDirectory) ProtoMessage() {}

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

// Deprecated: Use OutputDirectory.ProtoReflect.Descriptor instead.
func (*OutputDirectory) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{14}
}

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

func (x *OutputDirectory) GetTreeDigest() *Digest {
	if x != nil {
		return x.TreeDigest
	}
	return nil
}

func (x *OutputDirectory) GetIsTopologicallySorted() bool {
	if x != nil {
		return x.IsTopologicallySorted
	}
	return false
}

func (x *OutputDirectory) GetRootDirectoryDigest() *Digest {
	if x != nil {
		return x.RootDirectoryDigest
	}
	return nil
}

// An `OutputSymlink` is similar to a
// [Symlink][build.bazel.remote.execution.v2.SymlinkNode], but it is used as an
// output in an `ActionResult`.
//
// `OutputSymlink` is binary-compatible with `SymlinkNode`.
type OutputSymlink struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The full path of the symlink relative to the working directory, including the
	// filename. The path separator is a forward slash `/`. Since this is a
	// relative path, it MUST NOT begin with a leading forward slash.
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	// The target path of the symlink. The path separator is a forward slash `/`.
	// The target path can be relative to the parent directory of the symlink or
	// it can be an absolute path starting with `/`. Support for absolute paths
	// can be checked using the [Capabilities][build.bazel.remote.execution.v2.Capabilities]
	// API. `..` components are allowed anywhere in the target path.
	Target         string          `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"`
	NodeProperties *NodeProperties `protobuf:"bytes,4,opt,name=node_properties,json=nodeProperties,proto3" json:"node_properties,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *OutputSymlink) Reset() {
	*x = OutputSymlink{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*OutputSymlink) ProtoMessage() {}

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

// Deprecated: Use OutputSymlink.ProtoReflect.Descriptor instead.
func (*OutputSymlink) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{15}
}

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

func (x *OutputSymlink) GetTarget() string {
	if x != nil {
		return x.Target
	}
	return ""
}

func (x *OutputSymlink) GetNodeProperties() *NodeProperties {
	if x != nil {
		return x.NodeProperties
	}
	return nil
}

// An `ExecutionPolicy` can be used to control the scheduling of the action.
type ExecutionPolicy struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The priority (relative importance) of this action. Generally, a lower value
	// means that the action should be run sooner than actions having a greater
	// priority value, but the interpretation of a given value is server-
	// dependent. A priority of 0 means the *default* priority. Priorities may be
	// positive or negative, and such actions should run later or sooner than
	// actions having the default priority, respectively. The particular semantics
	// of this field is up to the server. In particular, every server will have
	// their own supported range of priorities, and will decide how these map into
	// scheduling policy.
	Priority      int32 `protobuf:"varint,1,opt,name=priority,proto3" json:"priority,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ExecutionPolicy) Reset() {
	*x = ExecutionPolicy{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ExecutionPolicy) ProtoMessage() {}

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

// Deprecated: Use ExecutionPolicy.ProtoReflect.Descriptor instead.
func (*ExecutionPolicy) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{16}
}

func (x *ExecutionPolicy) GetPriority() int32 {
	if x != nil {
		return x.Priority
	}
	return 0
}

// A `ResultsCachePolicy` is used for fine-grained control over how action
// outputs are stored in the CAS and Action Cache.
type ResultsCachePolicy struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The priority (relative importance) of this content in the overall cache.
	// Generally, a lower value means a longer retention time or other advantage,
	// but the interpretation of a given value is server-dependent. A priority of
	// 0 means a *default* value, decided by the server.
	//
	// The particular semantics of this field is up to the server. In particular,
	// every server will have their own supported range of priorities, and will
	// decide how these map into retention/eviction policy.
	Priority      int32 `protobuf:"varint,1,opt,name=priority,proto3" json:"priority,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ResultsCachePolicy) Reset() {
	*x = ResultsCachePolicy{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ResultsCachePolicy) ProtoMessage() {}

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

// Deprecated: Use ResultsCachePolicy.ProtoReflect.Descriptor instead.
func (*ResultsCachePolicy) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{17}
}

func (x *ResultsCachePolicy) GetPriority() int32 {
	if x != nil {
		return x.Priority
	}
	return 0
}

// A request message for
// [Execution.Execute][build.bazel.remote.execution.v2.Execution.Execute].
type ExecuteRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The instance of the execution system to operate against. A server may
	// support multiple instances of the execution system (with their own workers,
	// storage, caches, etc.). The server MAY require use of this field to select
	// between them in an implementation-defined fashion, otherwise it can be
	// omitted.
	InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
	// If true, the action will be executed even if its result is already
	// present in the [ActionCache][build.bazel.remote.execution.v2.ActionCache].
	// The execution is still allowed to be merged with other in-flight executions
	// of the same action, however - semantically, the service MUST only guarantee
	// that the results of an execution with this field set were not visible
	// before the corresponding execution request was sent.
	// Note that actions from execution requests setting this field set are still
	// eligible to be entered into the action cache upon completion, and services
	// SHOULD overwrite any existing entries that may exist. This allows
	// skip_cache_lookup requests to be used as a mechanism for replacing action
	// cache entries that reference outputs no longer available or that are
	// poisoned in any way.
	// If false, the result may be served from the action cache.
	SkipCacheLookup bool `protobuf:"varint,3,opt,name=skip_cache_lookup,json=skipCacheLookup,proto3" json:"skip_cache_lookup,omitempty"`
	// The digest of the [Action][build.bazel.remote.execution.v2.Action] to
	// execute.
	ActionDigest *Digest `protobuf:"bytes,6,opt,name=action_digest,json=actionDigest,proto3" json:"action_digest,omitempty"`
	// An optional policy for execution of the action.
	// The server will have a default policy if this is not provided.
	ExecutionPolicy *ExecutionPolicy `protobuf:"bytes,7,opt,name=execution_policy,json=executionPolicy,proto3" json:"execution_policy,omitempty"`
	// An optional policy for the results of this execution in the remote cache.
	// The server will have a default policy if this is not provided.
	// This may be applied to both the ActionResult and the associated blobs.
	ResultsCachePolicy *ResultsCachePolicy `protobuf:"bytes,8,opt,name=results_cache_policy,json=resultsCachePolicy,proto3" json:"results_cache_policy,omitempty"`
	// The digest function that was used to compute the action digest.
	//
	// If the digest function used is one of MD5, MURMUR3, SHA1, SHA256,
	// SHA384, SHA512, or VSO, the client MAY leave this field unset. In
	// that case the server SHOULD infer the digest function using the
	// length of the action digest hash and the digest functions announced
	// in the server's capabilities.
	DigestFunction DigestFunction_Value `protobuf:"varint,9,opt,name=digest_function,json=digestFunction,proto3,enum=build.bazel.remote.execution.v2.DigestFunction_Value" json:"digest_function,omitempty"`
	// A hint to the server to request inlining stdout in the
	// [ActionResult][build.bazel.remote.execution.v2.ActionResult] message.
	InlineStdout bool `protobuf:"varint,10,opt,name=inline_stdout,json=inlineStdout,proto3" json:"inline_stdout,omitempty"`
	// A hint to the server to request inlining stderr in the
	// [ActionResult][build.bazel.remote.execution.v2.ActionResult] message.
	InlineStderr bool `protobuf:"varint,11,opt,name=inline_stderr,json=inlineStderr,proto3" json:"inline_stderr,omitempty"`
	// A hint to the server to inline the contents of the listed output files.
	// Each path needs to exactly match one file path in either `output_paths` or
	// `output_files` (DEPRECATED since v2.1) in the
	// [Command][build.bazel.remote.execution.v2.Command] message.
	InlineOutputFiles []string `protobuf:"bytes,12,rep,name=inline_output_files,json=inlineOutputFiles,proto3" json:"inline_output_files,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

func (x *ExecuteRequest) Reset() {
	*x = ExecuteRequest{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ExecuteRequest) ProtoMessage() {}

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

// Deprecated: Use ExecuteRequest.ProtoReflect.Descriptor instead.
func (*ExecuteRequest) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{18}
}

func (x *ExecuteRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *ExecuteRequest) GetSkipCacheLookup() bool {
	if x != nil {
		return x.SkipCacheLookup
	}
	return false
}

func (x *ExecuteRequest) GetActionDigest() *Digest {
	if x != nil {
		return x.ActionDigest
	}
	return nil
}

func (x *ExecuteRequest) GetExecutionPolicy() *ExecutionPolicy {
	if x != nil {
		return x.ExecutionPolicy
	}
	return nil
}

func (x *ExecuteRequest) GetResultsCachePolicy() *ResultsCachePolicy {
	if x != nil {
		return x.ResultsCachePolicy
	}
	return nil
}

func (x *ExecuteRequest) GetDigestFunction() DigestFunction_Value {
	if x != nil {
		return x.DigestFunction
	}
	return DigestFunction_UNKNOWN
}

func (x *ExecuteRequest) GetInlineStdout() bool {
	if x != nil {
		return x.InlineStdout
	}
	return false
}

func (x *ExecuteRequest) GetInlineStderr() bool {
	if x != nil {
		return x.InlineStderr
	}
	return false
}

func (x *ExecuteRequest) GetInlineOutputFiles() []string {
	if x != nil {
		return x.InlineOutputFiles
	}
	return nil
}

// A `LogFile` is a log stored in the CAS.
type LogFile struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The digest of the log contents.
	Digest *Digest `protobuf:"bytes,1,opt,name=digest,proto3" json:"digest,omitempty"`
	// This is a hint as to the purpose of the log, and is set to true if the log
	// is human-readable text that can be usefully displayed to a user, and false
	// otherwise. For instance, if a command-line client wishes to print the
	// server logs to the terminal for a failed action, this allows it to avoid
	// displaying a binary file.
	HumanReadable bool `protobuf:"varint,2,opt,name=human_readable,json=humanReadable,proto3" json:"human_readable,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *LogFile) Reset() {
	*x = LogFile{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*LogFile) ProtoMessage() {}

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

// Deprecated: Use LogFile.ProtoReflect.Descriptor instead.
func (*LogFile) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{19}
}

func (x *LogFile) GetDigest() *Digest {
	if x != nil {
		return x.Digest
	}
	return nil
}

func (x *LogFile) GetHumanReadable() bool {
	if x != nil {
		return x.HumanReadable
	}
	return false
}

// The response message for
// [Execution.Execute][build.bazel.remote.execution.v2.Execution.Execute],
// which will be contained in the [response
// field][google.longrunning.Operation.response] of the
// [Operation][google.longrunning.Operation].
type ExecuteResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The result of the action.
	Result *ActionResult `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"`
	// True if the result was served from cache, false if it was executed.
	CachedResult bool `protobuf:"varint,2,opt,name=cached_result,json=cachedResult,proto3" json:"cached_result,omitempty"`
	// If the status has a code other than `OK`, it indicates that the action did
	// not finish execution. For example, if the operation times out during
	// execution, the status will have a `DEADLINE_EXCEEDED` code. Servers MUST
	// use this field for errors in execution, rather than the error field on the
	// `Operation` object.
	//
	// If the status code is other than `OK`, then the result MUST NOT be cached.
	// For an error status, the `result` field is optional; the server may
	// populate the output-, stdout-, and stderr-related fields if it has any
	// information available, such as the stdout and stderr of a timed-out action.
	Status *status.Status `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	// An optional list of additional log outputs the server wishes to provide. A
	// server can use this to return execution-specific logs however it wishes.
	// This is intended primarily to make it easier for users to debug issues that
	// may be outside of the actual job execution, such as by identifying the
	// worker executing the action or by providing logs from the worker's setup
	// phase. The keys SHOULD be human readable so that a client can display them
	// to a user.
	ServerLogs map[string]*LogFile `protobuf:"bytes,4,rep,name=server_logs,json=serverLogs,proto3" json:"server_logs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Freeform informational message with details on the execution of the action
	// that may be displayed to the user upon failure or when requested explicitly.
	Message       string `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ExecuteResponse) Reset() {
	*x = ExecuteResponse{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ExecuteResponse) ProtoMessage() {}

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

// Deprecated: Use ExecuteResponse.ProtoReflect.Descriptor instead.
func (*ExecuteResponse) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{20}
}

func (x *ExecuteResponse) GetResult() *ActionResult {
	if x != nil {
		return x.Result
	}
	return nil
}

func (x *ExecuteResponse) GetCachedResult() bool {
	if x != nil {
		return x.CachedResult
	}
	return false
}

func (x *ExecuteResponse) GetStatus() *status.Status {
	if x != nil {
		return x.Status
	}
	return nil
}

func (x *ExecuteResponse) GetServerLogs() map[string]*LogFile {
	if x != nil {
		return x.ServerLogs
	}
	return nil
}

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

// The current stage of action execution.
//
// Even though these stages are numbered according to the order in which
// they generally occur, there is no requirement that the remote
// execution system reports events along this order. For example, an
// operation MAY transition from the EXECUTING stage back to QUEUED
// in case the hardware on which the operation executes fails.
//
// If and only if the remote execution system reports that an operation
// has reached the COMPLETED stage, it MUST set the [done
// field][google.longrunning.Operation.done] of the
// [Operation][google.longrunning.Operation] and terminate the stream.
type ExecutionStage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ExecutionStage) Reset() {
	*x = ExecutionStage{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ExecutionStage) ProtoMessage() {}

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

// Deprecated: Use ExecutionStage.ProtoReflect.Descriptor instead.
func (*ExecutionStage) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{21}
}

// Metadata about an ongoing
// [execution][build.bazel.remote.execution.v2.Execution.Execute], which
// will be contained in the [metadata
// field][google.longrunning.Operation.metadata] of the
// [Operation][google.longrunning.Operation].
type ExecuteOperationMetadata struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The current stage of execution.
	Stage ExecutionStage_Value `protobuf:"varint,1,opt,name=stage,proto3,enum=build.bazel.remote.execution.v2.ExecutionStage_Value" json:"stage,omitempty"`
	// The digest of the [Action][build.bazel.remote.execution.v2.Action]
	// being executed.
	ActionDigest *Digest `protobuf:"bytes,2,opt,name=action_digest,json=actionDigest,proto3" json:"action_digest,omitempty"`
	// If set, the client can use this resource name with
	// [ByteStream.Read][google.bytestream.ByteStream.Read] to stream the
	// standard output from the endpoint hosting streamed responses.
	StdoutStreamName string `protobuf:"bytes,3,opt,name=stdout_stream_name,json=stdoutStreamName,proto3" json:"stdout_stream_name,omitempty"`
	// If set, the client can use this resource name with
	// [ByteStream.Read][google.bytestream.ByteStream.Read] to stream the
	// standard error from the endpoint hosting streamed responses.
	StderrStreamName string `protobuf:"bytes,4,opt,name=stderr_stream_name,json=stderrStreamName,proto3" json:"stderr_stream_name,omitempty"`
	// The client can read this field to view details about the ongoing
	// execution.
	PartialExecutionMetadata *ExecutedActionMetadata `protobuf:"bytes,5,opt,name=partial_execution_metadata,json=partialExecutionMetadata,proto3" json:"partial_execution_metadata,omitempty"`
	// The digest function that was used to compute the action digest.
	//
	// If the digest function used is one of BLAKE3, MD5, MURMUR3, SHA1,
	// SHA256, SHA256TREE, SHA384, SHA512, or VSO, the server MAY leave
	// this field unset. In that case the client SHOULD infer the digest
	// function using the length of the action digest hash and the digest
	// functions announced in the server's capabilities.
	DigestFunction DigestFunction_Value `protobuf:"varint,6,opt,name=digest_function,json=digestFunction,proto3,enum=build.bazel.remote.execution.v2.DigestFunction_Value" json:"digest_function,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *ExecuteOperationMetadata) Reset() {
	*x = ExecuteOperationMetadata{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ExecuteOperationMetadata) ProtoMessage() {}

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

// Deprecated: Use ExecuteOperationMetadata.ProtoReflect.Descriptor instead.
func (*ExecuteOperationMetadata) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{22}
}

func (x *ExecuteOperationMetadata) GetStage() ExecutionStage_Value {
	if x != nil {
		return x.Stage
	}
	return ExecutionStage_UNKNOWN
}

func (x *ExecuteOperationMetadata) GetActionDigest() *Digest {
	if x != nil {
		return x.ActionDigest
	}
	return nil
}

func (x *ExecuteOperationMetadata) GetStdoutStreamName() string {
	if x != nil {
		return x.StdoutStreamName
	}
	return ""
}

func (x *ExecuteOperationMetadata) GetStderrStreamName() string {
	if x != nil {
		return x.StderrStreamName
	}
	return ""
}

func (x *ExecuteOperationMetadata) GetPartialExecutionMetadata() *ExecutedActionMetadata {
	if x != nil {
		return x.PartialExecutionMetadata
	}
	return nil
}

func (x *ExecuteOperationMetadata) GetDigestFunction() DigestFunction_Value {
	if x != nil {
		return x.DigestFunction
	}
	return DigestFunction_UNKNOWN
}

// A request message for
// [WaitExecution][build.bazel.remote.execution.v2.Execution.WaitExecution].
type WaitExecutionRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The name of the [Operation][google.longrunning.Operation]
	// returned by [Execute][build.bazel.remote.execution.v2.Execution.Execute].
	Name          string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *WaitExecutionRequest) Reset() {
	*x = WaitExecutionRequest{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*WaitExecutionRequest) ProtoMessage() {}

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

// Deprecated: Use WaitExecutionRequest.ProtoReflect.Descriptor instead.
func (*WaitExecutionRequest) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{23}
}

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

// A request message for
// [ActionCache.GetActionResult][build.bazel.remote.execution.v2.ActionCache.GetActionResult].
type GetActionResultRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The instance of the execution system to operate against. A server may
	// support multiple instances of the execution system (with their own workers,
	// storage, caches, etc.). The server MAY require use of this field to select
	// between them in an implementation-defined fashion, otherwise it can be
	// omitted.
	InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
	// The digest of the [Action][build.bazel.remote.execution.v2.Action]
	// whose result is requested.
	ActionDigest *Digest `protobuf:"bytes,2,opt,name=action_digest,json=actionDigest,proto3" json:"action_digest,omitempty"`
	// A hint to the server to request inlining stdout in the
	// [ActionResult][build.bazel.remote.execution.v2.ActionResult] message.
	InlineStdout bool `protobuf:"varint,3,opt,name=inline_stdout,json=inlineStdout,proto3" json:"inline_stdout,omitempty"`
	// A hint to the server to request inlining stderr in the
	// [ActionResult][build.bazel.remote.execution.v2.ActionResult] message.
	InlineStderr bool `protobuf:"varint,4,opt,name=inline_stderr,json=inlineStderr,proto3" json:"inline_stderr,omitempty"`
	// A hint to the server to inline the contents of the listed output files.
	// Each path needs to exactly match one file path in either `output_paths` or
	// `output_files` (DEPRECATED since v2.1) in the
	// [Command][build.bazel.remote.execution.v2.Command] message.
	InlineOutputFiles []string `protobuf:"bytes,5,rep,name=inline_output_files,json=inlineOutputFiles,proto3" json:"inline_output_files,omitempty"`
	// The digest function that was used to compute the action digest.
	//
	// If the digest function used is one of MD5, MURMUR3, SHA1, SHA256,
	// SHA384, SHA512, or VSO, the client MAY leave this field unset. In
	// that case the server SHOULD infer the digest function using the
	// length of the action digest hash and the digest functions announced
	// in the server's capabilities.
	DigestFunction DigestFunction_Value `protobuf:"varint,6,opt,name=digest_function,json=digestFunction,proto3,enum=build.bazel.remote.execution.v2.DigestFunction_Value" json:"digest_function,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *GetActionResultRequest) Reset() {
	*x = GetActionResultRequest{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[24]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetActionResultRequest) ProtoMessage() {}

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

// Deprecated: Use GetActionResultRequest.ProtoReflect.Descriptor instead.
func (*GetActionResultRequest) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{24}
}

func (x *GetActionResultRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *GetActionResultRequest) GetActionDigest() *Digest {
	if x != nil {
		return x.ActionDigest
	}
	return nil
}

func (x *GetActionResultRequest) GetInlineStdout() bool {
	if x != nil {
		return x.InlineStdout
	}
	return false
}

func (x *GetActionResultRequest) GetInlineStderr() bool {
	if x != nil {
		return x.InlineStderr
	}
	return false
}

func (x *GetActionResultRequest) GetInlineOutputFiles() []string {
	if x != nil {
		return x.InlineOutputFiles
	}
	return nil
}

func (x *GetActionResultRequest) GetDigestFunction() DigestFunction_Value {
	if x != nil {
		return x.DigestFunction
	}
	return DigestFunction_UNKNOWN
}

// A request message for
// [ActionCache.UpdateActionResult][build.bazel.remote.execution.v2.ActionCache.UpdateActionResult].
type UpdateActionResultRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The instance of the execution system to operate against. A server may
	// support multiple instances of the execution system (with their own workers,
	// storage, caches, etc.). The server MAY require use of this field to select
	// between them in an implementation-defined fashion, otherwise it can be
	// omitted.
	InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
	// The digest of the [Action][build.bazel.remote.execution.v2.Action]
	// whose result is being uploaded.
	ActionDigest *Digest `protobuf:"bytes,2,opt,name=action_digest,json=actionDigest,proto3" json:"action_digest,omitempty"`
	// The [ActionResult][build.bazel.remote.execution.v2.ActionResult]
	// to store in the cache.
	ActionResult *ActionResult `protobuf:"bytes,3,opt,name=action_result,json=actionResult,proto3" json:"action_result,omitempty"`
	// An optional policy for the results of this execution in the remote cache.
	// The server will have a default policy if this is not provided.
	// This may be applied to both the ActionResult and the associated blobs.
	ResultsCachePolicy *ResultsCachePolicy `protobuf:"bytes,4,opt,name=results_cache_policy,json=resultsCachePolicy,proto3" json:"results_cache_policy,omitempty"`
	// The digest function that was used to compute the action digest.
	//
	// If the digest function used is one of MD5, MURMUR3, SHA1, SHA256,
	// SHA384, SHA512, or VSO, the client MAY leave this field unset. In
	// that case the server SHOULD infer the digest function using the
	// length of the action digest hash and the digest functions announced
	// in the server's capabilities.
	DigestFunction DigestFunction_Value `protobuf:"varint,5,opt,name=digest_function,json=digestFunction,proto3,enum=build.bazel.remote.execution.v2.DigestFunction_Value" json:"digest_function,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *UpdateActionResultRequest) Reset() {
	*x = UpdateActionResultRequest{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[25]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UpdateActionResultRequest) ProtoMessage() {}

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

// Deprecated: Use UpdateActionResultRequest.ProtoReflect.Descriptor instead.
func (*UpdateActionResultRequest) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{25}
}

func (x *UpdateActionResultRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *UpdateActionResultRequest) GetActionDigest() *Digest {
	if x != nil {
		return x.ActionDigest
	}
	return nil
}

func (x *UpdateActionResultRequest) GetActionResult() *ActionResult {
	if x != nil {
		return x.ActionResult
	}
	return nil
}

func (x *UpdateActionResultRequest) GetResultsCachePolicy() *ResultsCachePolicy {
	if x != nil {
		return x.ResultsCachePolicy
	}
	return nil
}

func (x *UpdateActionResultRequest) GetDigestFunction() DigestFunction_Value {
	if x != nil {
		return x.DigestFunction
	}
	return DigestFunction_UNKNOWN
}

// A request message for
// [ContentAddressableStorage.FindMissingBlobs][build.bazel.remote.execution.v2.ContentAddressableStorage.FindMissingBlobs].
type FindMissingBlobsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The instance of the execution system to operate against. A server may
	// support multiple instances of the execution system (with their own workers,
	// storage, caches, etc.). The server MAY require use of this field to select
	// between them in an implementation-defined fashion, otherwise it can be
	// omitted.
	InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
	// A list of the blobs to check. All digests MUST use the same digest
	// function.
	BlobDigests []*Digest `protobuf:"bytes,2,rep,name=blob_digests,json=blobDigests,proto3" json:"blob_digests,omitempty"`
	// The digest function of the blobs whose existence is checked.
	//
	// If the digest function used is one of MD5, MURMUR3, SHA1, SHA256,
	// SHA384, SHA512, or VSO, the client MAY leave this field unset. In
	// that case the server SHOULD infer the digest function using the
	// length of the blob digest hashes and the digest functions announced
	// in the server's capabilities.
	DigestFunction DigestFunction_Value `protobuf:"varint,3,opt,name=digest_function,json=digestFunction,proto3,enum=build.bazel.remote.execution.v2.DigestFunction_Value" json:"digest_function,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *FindMissingBlobsRequest) Reset() {
	*x = FindMissingBlobsRequest{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[26]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FindMissingBlobsRequest) ProtoMessage() {}

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

// Deprecated: Use FindMissingBlobsRequest.ProtoReflect.Descriptor instead.
func (*FindMissingBlobsRequest) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{26}
}

func (x *FindMissingBlobsRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *FindMissingBlobsRequest) GetBlobDigests() []*Digest {
	if x != nil {
		return x.BlobDigests
	}
	return nil
}

func (x *FindMissingBlobsRequest) GetDigestFunction() DigestFunction_Value {
	if x != nil {
		return x.DigestFunction
	}
	return DigestFunction_UNKNOWN
}

// A response message for
// [ContentAddressableStorage.FindMissingBlobs][build.bazel.remote.execution.v2.ContentAddressableStorage.FindMissingBlobs].
type FindMissingBlobsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A list of the blobs requested *not* present in the storage.
	MissingBlobDigests []*Digest `protobuf:"bytes,2,rep,name=missing_blob_digests,json=missingBlobDigests,proto3" json:"missing_blob_digests,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *FindMissingBlobsResponse) Reset() {
	*x = FindMissingBlobsResponse{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[27]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FindMissingBlobsResponse) ProtoMessage() {}

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

// Deprecated: Use FindMissingBlobsResponse.ProtoReflect.Descriptor instead.
func (*FindMissingBlobsResponse) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{27}
}

func (x *FindMissingBlobsResponse) GetMissingBlobDigests() []*Digest {
	if x != nil {
		return x.MissingBlobDigests
	}
	return nil
}

// A request message for
// [ContentAddressableStorage.BatchUpdateBlobs][build.bazel.remote.execution.v2.ContentAddressableStorage.BatchUpdateBlobs].
type BatchUpdateBlobsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The instance of the execution system to operate against. A server may
	// support multiple instances of the execution system (with their own workers,
	// storage, caches, etc.). The server MAY require use of this field to select
	// between them in an implementation-defined fashion, otherwise it can be
	// omitted.
	InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
	// The individual upload requests.
	Requests []*BatchUpdateBlobsRequest_Request `protobuf:"bytes,2,rep,name=requests,proto3" json:"requests,omitempty"`
	// The digest function that was used to compute the digests of the
	// blobs being uploaded.
	//
	// If the digest function used is one of MD5, MURMUR3, SHA1, SHA256,
	// SHA384, SHA512, or VSO, the client MAY leave this field unset. In
	// that case the server SHOULD infer the digest function using the
	// length of the blob digest hashes and the digest functions announced
	// in the server's capabilities.
	DigestFunction DigestFunction_Value `protobuf:"varint,5,opt,name=digest_function,json=digestFunction,proto3,enum=build.bazel.remote.execution.v2.DigestFunction_Value" json:"digest_function,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *BatchUpdateBlobsRequest) Reset() {
	*x = BatchUpdateBlobsRequest{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[28]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BatchUpdateBlobsRequest) ProtoMessage() {}

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

// Deprecated: Use BatchUpdateBlobsRequest.ProtoReflect.Descriptor instead.
func (*BatchUpdateBlobsRequest) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{28}
}

func (x *BatchUpdateBlobsRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *BatchUpdateBlobsRequest) GetRequests() []*BatchUpdateBlobsRequest_Request {
	if x != nil {
		return x.Requests
	}
	return nil
}

func (x *BatchUpdateBlobsRequest) GetDigestFunction() DigestFunction_Value {
	if x != nil {
		return x.DigestFunction
	}
	return DigestFunction_UNKNOWN
}

// A response message for
// [ContentAddressableStorage.BatchUpdateBlobs][build.bazel.remote.execution.v2.ContentAddressableStorage.BatchUpdateBlobs].
type BatchUpdateBlobsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The responses to the requests.
	Responses     []*BatchUpdateBlobsResponse_Response `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BatchUpdateBlobsResponse) Reset() {
	*x = BatchUpdateBlobsResponse{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[29]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BatchUpdateBlobsResponse) ProtoMessage() {}

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

// Deprecated: Use BatchUpdateBlobsResponse.ProtoReflect.Descriptor instead.
func (*BatchUpdateBlobsResponse) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{29}
}

func (x *BatchUpdateBlobsResponse) GetResponses() []*BatchUpdateBlobsResponse_Response {
	if x != nil {
		return x.Responses
	}
	return nil
}

// A request message for
// [ContentAddressableStorage.BatchReadBlobs][build.bazel.remote.execution.v2.ContentAddressableStorage.BatchReadBlobs].
type BatchReadBlobsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The instance of the execution system to operate against. A server may
	// support multiple instances of the execution system (with their own workers,
	// storage, caches, etc.). The server MAY require use of this field to select
	// between them in an implementation-defined fashion, otherwise it can be
	// omitted.
	InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
	// The individual blob digests. All digests MUST use the same digest
	// function.
	Digests []*Digest `protobuf:"bytes,2,rep,name=digests,proto3" json:"digests,omitempty"`
	// A list of acceptable encodings for the returned inlined data, in no
	// particular order. `IDENTITY` is always allowed even if not specified here.
	AcceptableCompressors []Compressor_Value `protobuf:"varint,3,rep,packed,name=acceptable_compressors,json=acceptableCompressors,proto3,enum=build.bazel.remote.execution.v2.Compressor_Value" json:"acceptable_compressors,omitempty"`
	// The digest function of the blobs being requested.
	//
	// If the digest function used is one of MD5, MURMUR3, SHA1, SHA256,
	// SHA384, SHA512, or VSO, the client MAY leave this field unset. In
	// that case the server SHOULD infer the digest function using the
	// length of the blob digest hashes and the digest functions announced
	// in the server's capabilities.
	DigestFunction DigestFunction_Value `protobuf:"varint,4,opt,name=digest_function,json=digestFunction,proto3,enum=build.bazel.remote.execution.v2.DigestFunction_Value" json:"digest_function,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *BatchReadBlobsRequest) Reset() {
	*x = BatchReadBlobsRequest{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[30]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BatchReadBlobsRequest) ProtoMessage() {}

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

// Deprecated: Use BatchReadBlobsRequest.ProtoReflect.Descriptor instead.
func (*BatchReadBlobsRequest) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{30}
}

func (x *BatchReadBlobsRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *BatchReadBlobsRequest) GetDigests() []*Digest {
	if x != nil {
		return x.Digests
	}
	return nil
}

func (x *BatchReadBlobsRequest) GetAcceptableCompressors() []Compressor_Value {
	if x != nil {
		return x.AcceptableCompressors
	}
	return nil
}

func (x *BatchReadBlobsRequest) GetDigestFunction() DigestFunction_Value {
	if x != nil {
		return x.DigestFunction
	}
	return DigestFunction_UNKNOWN
}

// A response message for
// [ContentAddressableStorage.BatchReadBlobs][build.bazel.remote.execution.v2.ContentAddressableStorage.BatchReadBlobs].
type BatchReadBlobsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The responses to the requests.
	Responses     []*BatchReadBlobsResponse_Response `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BatchReadBlobsResponse) Reset() {
	*x = BatchReadBlobsResponse{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[31]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BatchReadBlobsResponse) ProtoMessage() {}

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

// Deprecated: Use BatchReadBlobsResponse.ProtoReflect.Descriptor instead.
func (*BatchReadBlobsResponse) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{31}
}

func (x *BatchReadBlobsResponse) GetResponses() []*BatchReadBlobsResponse_Response {
	if x != nil {
		return x.Responses
	}
	return nil
}

// A request message for
// [ContentAddressableStorage.GetTree][build.bazel.remote.execution.v2.ContentAddressableStorage.GetTree].
type GetTreeRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The instance of the execution system to operate against. A server may
	// support multiple instances of the execution system (with their own workers,
	// storage, caches, etc.). The server MAY require use of this field to select
	// between them in an implementation-defined fashion, otherwise it can be
	// omitted.
	InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
	// The digest of the root, which must be an encoded
	// [Directory][build.bazel.remote.execution.v2.Directory] message
	// stored in the
	// [ContentAddressableStorage][build.bazel.remote.execution.v2.ContentAddressableStorage].
	RootDigest *Digest `protobuf:"bytes,2,opt,name=root_digest,json=rootDigest,proto3" json:"root_digest,omitempty"`
	// A maximum page size to request. If present, the server will request no more
	// than this many items. Regardless of whether a page size is specified, the
	// server may place its own limit on the number of items to be returned and
	// require the client to retrieve more items using a subsequent request.
	PageSize int32 `protobuf:"varint,3,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// A page token, which must be a value received in a previous
	// [GetTreeResponse][build.bazel.remote.execution.v2.GetTreeResponse].
	// If present, the server will use that token as an offset, returning only
	// that page and the ones that succeed it.
	PageToken string `protobuf:"bytes,4,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// The digest function that was used to compute the digest of the root
	// directory.
	//
	// If the digest function used is one of MD5, MURMUR3, SHA1, SHA256,
	// SHA384, SHA512, or VSO, the client MAY leave this field unset. In
	// that case the server SHOULD infer the digest function using the
	// length of the root digest hash and the digest functions announced
	// in the server's capabilities.
	DigestFunction DigestFunction_Value `protobuf:"varint,5,opt,name=digest_function,json=digestFunction,proto3,enum=build.bazel.remote.execution.v2.DigestFunction_Value" json:"digest_function,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *GetTreeRequest) Reset() {
	*x = GetTreeRequest{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[32]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetTreeRequest) ProtoMessage() {}

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

// Deprecated: Use GetTreeRequest.ProtoReflect.Descriptor instead.
func (*GetTreeRequest) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{32}
}

func (x *GetTreeRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *GetTreeRequest) GetRootDigest() *Digest {
	if x != nil {
		return x.RootDigest
	}
	return nil
}

func (x *GetTreeRequest) GetPageSize() int32 {
	if x != nil {
		return x.PageSize
	}
	return 0
}

func (x *GetTreeRequest) GetPageToken() string {
	if x != nil {
		return x.PageToken
	}
	return ""
}

func (x *GetTreeRequest) GetDigestFunction() DigestFunction_Value {
	if x != nil {
		return x.DigestFunction
	}
	return DigestFunction_UNKNOWN
}

// A response message for
// [ContentAddressableStorage.GetTree][build.bazel.remote.execution.v2.ContentAddressableStorage.GetTree].
type GetTreeResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The directories descended from the requested root.
	Directories []*Directory `protobuf:"bytes,1,rep,name=directories,proto3" json:"directories,omitempty"`
	// If present, signifies that there are more results which the client can
	// retrieve by passing this as the page_token in a subsequent
	// [request][build.bazel.remote.execution.v2.GetTreeRequest].
	// If empty, signifies that this is the last page of results.
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetTreeResponse) Reset() {
	*x = GetTreeResponse{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[33]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetTreeResponse) ProtoMessage() {}

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

// Deprecated: Use GetTreeResponse.ProtoReflect.Descriptor instead.
func (*GetTreeResponse) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{33}
}

func (x *GetTreeResponse) GetDirectories() []*Directory {
	if x != nil {
		return x.Directories
	}
	return nil
}

func (x *GetTreeResponse) GetNextPageToken() string {
	if x != nil {
		return x.NextPageToken
	}
	return ""
}

// A request message for
// [ContentAddressableStorage.SplitBlob][build.bazel.remote.execution.v2.ContentAddressableStorage.SplitBlob].
type SplitBlobRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The instance of the execution system to operate against. A server may
	// support multiple instances of the execution system (with their own workers,
	// storage, caches, etc.). The server MAY require use of this field to select
	// between them in an implementation-defined fashion, otherwise it can be
	// omitted.
	InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
	// The digest of the blob to be split.
	BlobDigest *Digest `protobuf:"bytes,2,opt,name=blob_digest,json=blobDigest,proto3" json:"blob_digest,omitempty"`
	// The digest function of the blob to be split.
	//
	// If the digest function used is one of MD5, MURMUR3, SHA1, SHA256,
	// SHA384, SHA512, or VSO, the client MAY leave this field unset. In
	// that case the server SHOULD infer the digest function using the
	// length of the blob digest hashes and the digest functions announced
	// in the server's capabilities.
	DigestFunction DigestFunction_Value `protobuf:"varint,3,opt,name=digest_function,json=digestFunction,proto3,enum=build.bazel.remote.execution.v2.DigestFunction_Value" json:"digest_function,omitempty"`
	// The chunking function that the client prefers to use.
	//
	// The server MAY use a different chunking function.
	ChunkingFunction ChunkingFunction_Value `protobuf:"varint,4,opt,name=chunking_function,json=chunkingFunction,proto3,enum=build.bazel.remote.execution.v2.ChunkingFunction_Value" json:"chunking_function,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *SplitBlobRequest) Reset() {
	*x = SplitBlobRequest{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[34]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SplitBlobRequest) ProtoMessage() {}

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

// Deprecated: Use SplitBlobRequest.ProtoReflect.Descriptor instead.
func (*SplitBlobRequest) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{34}
}

func (x *SplitBlobRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *SplitBlobRequest) GetBlobDigest() *Digest {
	if x != nil {
		return x.BlobDigest
	}
	return nil
}

func (x *SplitBlobRequest) GetDigestFunction() DigestFunction_Value {
	if x != nil {
		return x.DigestFunction
	}
	return DigestFunction_UNKNOWN
}

func (x *SplitBlobRequest) GetChunkingFunction() ChunkingFunction_Value {
	if x != nil {
		return x.ChunkingFunction
	}
	return ChunkingFunction_UNKNOWN
}

// A response message for
// [ContentAddressableStorage.SplitBlob][build.bazel.remote.execution.v2.ContentAddressableStorage.SplitBlob].
type SplitBlobResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The ordered list of digests of the chunks into which the blob was split.
	// The original blob is assembled by concatenating the chunk data according to
	// the order of the digests given by this list.
	//
	// The server MUST use the same digest function as the one explicitly or
	// implicitly (through hash length) specified in the split request.
	ChunkDigests []*Digest `protobuf:"bytes,1,rep,name=chunk_digests,json=chunkDigests,proto3" json:"chunk_digests,omitempty"`
	// The chunking function used to split the blob.
	ChunkingFunction ChunkingFunction_Value `protobuf:"varint,2,opt,name=chunking_function,json=chunkingFunction,proto3,enum=build.bazel.remote.execution.v2.ChunkingFunction_Value" json:"chunking_function,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *SplitBlobResponse) Reset() {
	*x = SplitBlobResponse{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[35]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SplitBlobResponse) ProtoMessage() {}

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

// Deprecated: Use SplitBlobResponse.ProtoReflect.Descriptor instead.
func (*SplitBlobResponse) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{35}
}

func (x *SplitBlobResponse) GetChunkDigests() []*Digest {
	if x != nil {
		return x.ChunkDigests
	}
	return nil
}

func (x *SplitBlobResponse) GetChunkingFunction() ChunkingFunction_Value {
	if x != nil {
		return x.ChunkingFunction
	}
	return ChunkingFunction_UNKNOWN
}

// A request message for
// [ContentAddressableStorage.SpliceBlob][build.bazel.remote.execution.v2.ContentAddressableStorage.SpliceBlob].
type SpliceBlobRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The instance of the execution system to operate against. A server may
	// support multiple instances of the execution system (with their own workers,
	// storage, caches, etc.). The server MAY require use of this field to select
	// between them in an implementation-defined fashion, otherwise it can be
	// omitted.
	InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
	// Expected digest of the spliced blob. The client MUST set this field due
	// to the following reasons:
	//  1. It allows the server to perform an early existence check of the blob
	//     or existing chunks that assemble the blob before spending the splicing
	//     effort, as described in the [ContentAddressableStorage.SpliceBlob][build.bazel.remote.execution.v2.ContentAddressableStorage.SpliceBlob]
	//     documentation.
	//  2. It allows servers with different storage backends to dispatch the
	//     request to the correct storage backend based on the size and/or the
	//     hash of the blob.
	//  3. If chunking information already exists for the blob, it allows
	//     the server to keep the existing chunking information or replace it with
	//     new chunking information.
	BlobDigest *Digest `protobuf:"bytes,2,opt,name=blob_digest,json=blobDigest,proto3" json:"blob_digest,omitempty"`
	// The ordered list of digests of the chunks which need to be concatenated to
	// assemble the original blob.
	ChunkDigests []*Digest `protobuf:"bytes,3,rep,name=chunk_digests,json=chunkDigests,proto3" json:"chunk_digests,omitempty"`
	// The digest function of all chunks to be concatenated and of the blob to be
	// spliced. The server MUST use the same digest function for both cases.
	//
	// If the digest function used is one of MD5, MURMUR3, SHA1, SHA256, SHA384,
	// SHA512, or VSO, the client MAY leave this field unset. In that case the
	// server SHOULD infer the digest function using the length of the blob digest
	// hashes and the digest functions announced in the server's capabilities.
	DigestFunction DigestFunction_Value `protobuf:"varint,4,opt,name=digest_function,json=digestFunction,proto3,enum=build.bazel.remote.execution.v2.DigestFunction_Value" json:"digest_function,omitempty"`
	// The chunking function that the client used to split the blob.
	ChunkingFunction ChunkingFunction_Value `protobuf:"varint,5,opt,name=chunking_function,json=chunkingFunction,proto3,enum=build.bazel.remote.execution.v2.ChunkingFunction_Value" json:"chunking_function,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *SpliceBlobRequest) Reset() {
	*x = SpliceBlobRequest{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[36]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SpliceBlobRequest) ProtoMessage() {}

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

// Deprecated: Use SpliceBlobRequest.ProtoReflect.Descriptor instead.
func (*SpliceBlobRequest) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{36}
}

func (x *SpliceBlobRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *SpliceBlobRequest) GetBlobDigest() *Digest {
	if x != nil {
		return x.BlobDigest
	}
	return nil
}

func (x *SpliceBlobRequest) GetChunkDigests() []*Digest {
	if x != nil {
		return x.ChunkDigests
	}
	return nil
}

func (x *SpliceBlobRequest) GetDigestFunction() DigestFunction_Value {
	if x != nil {
		return x.DigestFunction
	}
	return DigestFunction_UNKNOWN
}

func (x *SpliceBlobRequest) GetChunkingFunction() ChunkingFunction_Value {
	if x != nil {
		return x.ChunkingFunction
	}
	return ChunkingFunction_UNKNOWN
}

// A response message for
// [ContentAddressableStorage.SpliceBlob][build.bazel.remote.execution.v2.ContentAddressableStorage.SpliceBlob].
type SpliceBlobResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Computed digest of the spliced blob.
	//
	// The server MUST use the same digest function as the one explicitly or
	// implicitly (through hash length) specified in the splice request.
	BlobDigest    *Digest `protobuf:"bytes,1,opt,name=blob_digest,json=blobDigest,proto3" json:"blob_digest,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SpliceBlobResponse) Reset() {
	*x = SpliceBlobResponse{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[37]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SpliceBlobResponse) ProtoMessage() {}

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

// Deprecated: Use SpliceBlobResponse.ProtoReflect.Descriptor instead.
func (*SpliceBlobResponse) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{37}
}

func (x *SpliceBlobResponse) GetBlobDigest() *Digest {
	if x != nil {
		return x.BlobDigest
	}
	return nil
}

// A request message for
// [Capabilities.GetCapabilities][build.bazel.remote.execution.v2.Capabilities.GetCapabilities].
type GetCapabilitiesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The instance of the execution system to operate against. A server may
	// support multiple instances of the execution system (with their own workers,
	// storage, caches, etc.). The server MAY require use of this field to select
	// between them in an implementation-defined fashion, otherwise it can be
	// omitted.
	InstanceName  string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetCapabilitiesRequest) Reset() {
	*x = GetCapabilitiesRequest{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[38]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetCapabilitiesRequest) ProtoMessage() {}

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

// Deprecated: Use GetCapabilitiesRequest.ProtoReflect.Descriptor instead.
func (*GetCapabilitiesRequest) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{38}
}

func (x *GetCapabilitiesRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

// A response message for
// [Capabilities.GetCapabilities][build.bazel.remote.execution.v2.Capabilities.GetCapabilities].
type ServerCapabilities struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Capabilities of the remote cache system.
	CacheCapabilities *CacheCapabilities `protobuf:"bytes,1,opt,name=cache_capabilities,json=cacheCapabilities,proto3" json:"cache_capabilities,omitempty"`
	// Capabilities of the remote execution system.
	ExecutionCapabilities *ExecutionCapabilities `protobuf:"bytes,2,opt,name=execution_capabilities,json=executionCapabilities,proto3" json:"execution_capabilities,omitempty"`
	// Earliest RE API version supported, including deprecated versions.
	DeprecatedApiVersion *semver.SemVer `protobuf:"bytes,3,opt,name=deprecated_api_version,json=deprecatedApiVersion,proto3" json:"deprecated_api_version,omitempty"`
	// Earliest non-deprecated RE API version supported.
	LowApiVersion *semver.SemVer `protobuf:"bytes,4,opt,name=low_api_version,json=lowApiVersion,proto3" json:"low_api_version,omitempty"`
	// Latest RE API version supported.
	HighApiVersion *semver.SemVer `protobuf:"bytes,5,opt,name=high_api_version,json=highApiVersion,proto3" json:"high_api_version,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *ServerCapabilities) Reset() {
	*x = ServerCapabilities{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[39]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ServerCapabilities) ProtoMessage() {}

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

// Deprecated: Use ServerCapabilities.ProtoReflect.Descriptor instead.
func (*ServerCapabilities) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{39}
}

func (x *ServerCapabilities) GetCacheCapabilities() *CacheCapabilities {
	if x != nil {
		return x.CacheCapabilities
	}
	return nil
}

func (x *ServerCapabilities) GetExecutionCapabilities() *ExecutionCapabilities {
	if x != nil {
		return x.ExecutionCapabilities
	}
	return nil
}

func (x *ServerCapabilities) GetDeprecatedApiVersion() *semver.SemVer {
	if x != nil {
		return x.DeprecatedApiVersion
	}
	return nil
}

func (x *ServerCapabilities) GetLowApiVersion() *semver.SemVer {
	if x != nil {
		return x.LowApiVersion
	}
	return nil
}

func (x *ServerCapabilities) GetHighApiVersion() *semver.SemVer {
	if x != nil {
		return x.HighApiVersion
	}
	return nil
}

// The digest function used for converting values into keys for CAS and Action
// Cache.
type DigestFunction struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DigestFunction) Reset() {
	*x = DigestFunction{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[40]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DigestFunction) ProtoMessage() {}

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

// Deprecated: Use DigestFunction.ProtoReflect.Descriptor instead.
func (*DigestFunction) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{40}
}

// The chunking function is used to split a blob into chunks.
//
// The server advertises support for a chunking function by setting the
// corresponding params field in
// [CacheCapabilities][build.bazel.remote.execution.v2.CacheCapabilities].
// For example, if fast_cdc_2020_params is set, the server supports FAST_CDC_2020.
//
// For optimal deduplication, clients SHOULD use an advertised chunking function.
// When clients use UNKNOWN, the server chooses an algorithm for SplitBlob and
// simply verifies chunk concatenation for SpliceBlob.
type ChunkingFunction struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ChunkingFunction) Reset() {
	*x = ChunkingFunction{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[41]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ChunkingFunction) ProtoMessage() {}

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

// Deprecated: Use ChunkingFunction.ProtoReflect.Descriptor instead.
func (*ChunkingFunction) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{41}
}

// Describes the server/instance capabilities for updating the action cache.
type ActionCacheUpdateCapabilities struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	UpdateEnabled bool                   `protobuf:"varint,1,opt,name=update_enabled,json=updateEnabled,proto3" json:"update_enabled,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ActionCacheUpdateCapabilities) Reset() {
	*x = ActionCacheUpdateCapabilities{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[42]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ActionCacheUpdateCapabilities) ProtoMessage() {}

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

// Deprecated: Use ActionCacheUpdateCapabilities.ProtoReflect.Descriptor instead.
func (*ActionCacheUpdateCapabilities) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{42}
}

func (x *ActionCacheUpdateCapabilities) GetUpdateEnabled() bool {
	if x != nil {
		return x.UpdateEnabled
	}
	return false
}

// Allowed values for priority in
// [ResultsCachePolicy][build.bazel.remote.execution.v2.ResultsCachePolicy] and
// [ExecutionPolicy][build.bazel.remote.execution.v2.ExecutionPolicy]
// Used for querying both cache and execution valid priority ranges.
type PriorityCapabilities struct {
	state         protoimpl.MessageState                `protogen:"open.v1"`
	Priorities    []*PriorityCapabilities_PriorityRange `protobuf:"bytes,1,rep,name=priorities,proto3" json:"priorities,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PriorityCapabilities) Reset() {
	*x = PriorityCapabilities{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[43]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PriorityCapabilities) ProtoMessage() {}

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

// Deprecated: Use PriorityCapabilities.ProtoReflect.Descriptor instead.
func (*PriorityCapabilities) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{43}
}

func (x *PriorityCapabilities) GetPriorities() []*PriorityCapabilities_PriorityRange {
	if x != nil {
		return x.Priorities
	}
	return nil
}

// Describes how the server treats absolute symlink targets.
type SymlinkAbsolutePathStrategy struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SymlinkAbsolutePathStrategy) Reset() {
	*x = SymlinkAbsolutePathStrategy{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[44]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SymlinkAbsolutePathStrategy) ProtoMessage() {}

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

// Deprecated: Use SymlinkAbsolutePathStrategy.ProtoReflect.Descriptor instead.
func (*SymlinkAbsolutePathStrategy) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{44}
}

// Compression formats which may be supported.
type Compressor struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Compressor) Reset() {
	*x = Compressor{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[45]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Compressor) ProtoMessage() {}

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

// Deprecated: Use Compressor.ProtoReflect.Descriptor instead.
func (*Compressor) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{45}
}

// Capabilities of the remote cache system.
type CacheCapabilities struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// All the digest functions supported by the remote cache.
	// Remote cache may support multiple digest functions simultaneously.
	DigestFunctions []DigestFunction_Value `protobuf:"varint,1,rep,packed,name=digest_functions,json=digestFunctions,proto3,enum=build.bazel.remote.execution.v2.DigestFunction_Value" json:"digest_functions,omitempty"`
	// Capabilities for updating the action cache.
	ActionCacheUpdateCapabilities *ActionCacheUpdateCapabilities `protobuf:"bytes,2,opt,name=action_cache_update_capabilities,json=actionCacheUpdateCapabilities,proto3" json:"action_cache_update_capabilities,omitempty"`
	// Supported cache priority range for both CAS and ActionCache.
	CachePriorityCapabilities *PriorityCapabilities `protobuf:"bytes,3,opt,name=cache_priority_capabilities,json=cachePriorityCapabilities,proto3" json:"cache_priority_capabilities,omitempty"`
	// Maximum total size of blobs to be uploaded/downloaded using
	// batch methods. A value of 0 means no limit is set, although
	// in practice there will always be a message size limitation
	// of the protocol in use, e.g. GRPC.
	MaxBatchTotalSizeBytes int64 `protobuf:"varint,4,opt,name=max_batch_total_size_bytes,json=maxBatchTotalSizeBytes,proto3" json:"max_batch_total_size_bytes,omitempty"`
	// Whether absolute symlink targets are supported.
	SymlinkAbsolutePathStrategy SymlinkAbsolutePathStrategy_Value `protobuf:"varint,5,opt,name=symlink_absolute_path_strategy,json=symlinkAbsolutePathStrategy,proto3,enum=build.bazel.remote.execution.v2.SymlinkAbsolutePathStrategy_Value" json:"symlink_absolute_path_strategy,omitempty"`
	// Compressors supported by the "compressed-blobs" bytestream resources.
	// Servers MUST support identity/no-compression, even if it is not listed
	// here.
	//
	// Note that this does not imply which if any compressors are supported by
	// the server at the gRPC level.
	SupportedCompressors []Compressor_Value `protobuf:"varint,6,rep,packed,name=supported_compressors,json=supportedCompressors,proto3,enum=build.bazel.remote.execution.v2.Compressor_Value" json:"supported_compressors,omitempty"`
	// Compressors supported for inlined data in
	// [BatchUpdateBlobs][build.bazel.remote.execution.v2.ContentAddressableStorage.BatchUpdateBlobs]
	// requests.
	SupportedBatchUpdateCompressors []Compressor_Value `protobuf:"varint,7,rep,packed,name=supported_batch_update_compressors,json=supportedBatchUpdateCompressors,proto3,enum=build.bazel.remote.execution.v2.Compressor_Value" json:"supported_batch_update_compressors,omitempty"`
	// The maximum blob size that the server will accept for CAS blob uploads.
	//   - If it is 0, it means there is no limit set. A client may assume
	//     arbitrarily large blobs may be uploaded to and downloaded from the cache.
	//   - If it is larger than 0, implementations SHOULD NOT attempt to upload
	//     blobs with size larger than the limit. Servers SHOULD reject blob
	//     uploads over the `max_cas_blob_size_bytes` limit with response code
	//     `INVALID_ARGUMENT`
	//   - If the cache implementation returns a given limit, it MAY still serve
	//     blobs larger than this limit.
	MaxCasBlobSizeBytes int64 `protobuf:"varint,8,opt,name=max_cas_blob_size_bytes,json=maxCasBlobSizeBytes,proto3" json:"max_cas_blob_size_bytes,omitempty"`
	// Whether blob splitting is supported for the particular server/instance. If
	// yes, the server/instance implements the specified behavior for blob
	// splitting and a meaningful result can be expected from the
	// [ContentAddressableStorage.SplitBlob][build.bazel.remote.execution.v2.ContentAddressableStorage.SplitBlob]
	// operation.
	SplitBlobSupport bool `protobuf:"varint,9,opt,name=split_blob_support,json=splitBlobSupport,proto3" json:"split_blob_support,omitempty"`
	// Whether blob splicing is supported for the particular server/instance. If
	// yes, the server/instance implements the specified behavior for blob
	// splicing and a meaningful result can be expected from the
	// [ContentAddressableStorage.SpliceBlob][build.bazel.remote.execution.v2.ContentAddressableStorage.SpliceBlob]
	// operation.
	SpliceBlobSupport bool `protobuf:"varint,10,opt,name=splice_blob_support,json=spliceBlobSupport,proto3" json:"splice_blob_support,omitempty"`
	// The parameters for the FastCDC 2020 chunking algorithm.
	// If set, the server supports the FastCDC chunking algorithm.
	FastCdc_2020Params *FastCdc2020Params `protobuf:"bytes,11,opt,name=fast_cdc_2020_params,json=fastCdc2020Params,proto3" json:"fast_cdc_2020_params,omitempty"`
	// The parameters for the RepMaxCDC chunking algorithm.
	// If set, the server supports the RepMaxCDC chunking algorithm.
	RepMaxCdcParams *RepMaxCdcParams `protobuf:"bytes,12,opt,name=rep_max_cdc_params,json=repMaxCdcParams,proto3" json:"rep_max_cdc_params,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *CacheCapabilities) Reset() {
	*x = CacheCapabilities{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[46]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CacheCapabilities) ProtoMessage() {}

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

// Deprecated: Use CacheCapabilities.ProtoReflect.Descriptor instead.
func (*CacheCapabilities) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{46}
}

func (x *CacheCapabilities) GetDigestFunctions() []DigestFunction_Value {
	if x != nil {
		return x.DigestFunctions
	}
	return nil
}

func (x *CacheCapabilities) GetActionCacheUpdateCapabilities() *ActionCacheUpdateCapabilities {
	if x != nil {
		return x.ActionCacheUpdateCapabilities
	}
	return nil
}

func (x *CacheCapabilities) GetCachePriorityCapabilities() *PriorityCapabilities {
	if x != nil {
		return x.CachePriorityCapabilities
	}
	return nil
}

func (x *CacheCapabilities) GetMaxBatchTotalSizeBytes() int64 {
	if x != nil {
		return x.MaxBatchTotalSizeBytes
	}
	return 0
}

func (x *CacheCapabilities) GetSymlinkAbsolutePathStrategy() SymlinkAbsolutePathStrategy_Value {
	if x != nil {
		return x.SymlinkAbsolutePathStrategy
	}
	return SymlinkAbsolutePathStrategy_UNKNOWN
}

func (x *CacheCapabilities) GetSupportedCompressors() []Compressor_Value {
	if x != nil {
		return x.SupportedCompressors
	}
	return nil
}

func (x *CacheCapabilities) GetSupportedBatchUpdateCompressors() []Compressor_Value {
	if x != nil {
		return x.SupportedBatchUpdateCompressors
	}
	return nil
}

func (x *CacheCapabilities) GetMaxCasBlobSizeBytes() int64 {
	if x != nil {
		return x.MaxCasBlobSizeBytes
	}
	return 0
}

func (x *CacheCapabilities) GetSplitBlobSupport() bool {
	if x != nil {
		return x.SplitBlobSupport
	}
	return false
}

func (x *CacheCapabilities) GetSpliceBlobSupport() bool {
	if x != nil {
		return x.SpliceBlobSupport
	}
	return false
}

func (x *CacheCapabilities) GetFastCdc_2020Params() *FastCdc2020Params {
	if x != nil {
		return x.FastCdc_2020Params
	}
	return nil
}

func (x *CacheCapabilities) GetRepMaxCdcParams() *RepMaxCdcParams {
	if x != nil {
		return x.RepMaxCdcParams
	}
	return nil
}

// Parameters for the FastCDC content-defined chunking algorithm.
//
// Implementations MUST follow the FastCDC 2020 paper by Wen Xia, et al.:
// https://ieeexplore.ieee.org/document/9055082
//
// Supported implementations:
//   - Rust: https://docs.rs/fastcdc/3.2.1/fastcdc/v2020/index.html
//   - Go: https://github.com/buildbuddy-io/fastcdc2020
//
// Test vectors can be found in the accompanying fastcdc2020_test_vectors.txt file.
//
// Implementations MUST use normalization level 2, which has been found
// successful for build artifacts with an average chunk size of 512 KiB.
//
// Key algorithm components from the paper:
//
// GEAR table: 256 64-bit integers for the rolling hash, computed as:
//
//	GEAR[i] = high_64_bits(MD5(byte(i))) for i in 0..255
//
// MASKS table: Bit patterns for chunk boundary detection, derived from
// the C reference implementation. The mask selection based on average
// chunk size SHOULD match the paper.
//
// The minimum and maximum chunk sizes MUST be derived from the average:
//   - min_chunk_size = avg_chunk_size_bytes / 4
//   - max_chunk_size = avg_chunk_size_bytes * 4
//
// Blobs smaller than max_chunk_size (avg_chunk_size_bytes * 4) SHOULD be
// uploaded without chunking.
//
// If any of the advertised parameters are not within the expected range,
// the client SHOULD ignore FastCDC chunking function support.
type FastCdc2020Params struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The average (expected) chunk size for the FastCDC chunking algorithm.
	// The value MUST be between 1 KiB and 1 MiB. The recommended value is
	// 524288 (512 KiB).
	AvgChunkSizeBytes uint64 `protobuf:"varint,1,opt,name=avg_chunk_size_bytes,json=avgChunkSizeBytes,proto3" json:"avg_chunk_size_bytes,omitempty"`
	// The seed for the FastCDC mask generation.
	// The recommended value is 0.
	//
	// All clients sharing a cache SHOULD use the same seed to maximize
	// chunk reuse.
	Seed          uint32 `protobuf:"varint,2,opt,name=seed,proto3" json:"seed,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FastCdc2020Params) Reset() {
	*x = FastCdc2020Params{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[47]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FastCdc2020Params) ProtoMessage() {}

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

// Deprecated: Use FastCdc2020Params.ProtoReflect.Descriptor instead.
func (*FastCdc2020Params) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{47}
}

func (x *FastCdc2020Params) GetAvgChunkSizeBytes() uint64 {
	if x != nil {
		return x.AvgChunkSizeBytes
	}
	return 0
}

func (x *FastCdc2020Params) GetSeed() uint32 {
	if x != nil {
		return x.Seed
	}
	return 0
}

// Parameters for the RepMaxCDC content-defined chunking algorithm.
//
// Supported implementations:
//   - Go: https://github.com/buildbarn/go-cdc
//
// Key algorithm components:
//
// GEAR table: 256 64-bit integers for the rolling hash, computed as:
//
//	GEAR[i] = high_64_bits(MD5(byte(i))) for i in 0..255
//
// The algorithm repeatedly applies chunking until all chunks are in the
// range [min_chunk_size_bytes, 2*min_chunk_size_bytes). Cutting points are
// selected where the Gear rolling hash is maximized within a lookahead
// window of horizon_size_bytes.
//
// For sufficiently large files, the average chunk size prior to
// deduplication will approximately be min_chunk_size_bytes divided by
// Rényi's parking constant (0.7475979203...). More details:
// https://mathworld.wolfram.com/RenyisParkingConstants.html
//
// If any of the advertised parameters are not within the expected range,
// the client SHOULD ignore RepMaxCDC chunking function support.
type RepMaxCdcParams struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The minimum chunk size for the RepMaxCDC chunking algorithm.
	// The value MUST be at least 64 bytes (the Gear hash window size).
	// All chunks will be in the range [min_chunk_size_bytes, 2*min_chunk_size_bytes).
	// The recommended value is 262144 (256 KiB).
	MinChunkSizeBytes uint64 `protobuf:"varint,1,opt,name=min_chunk_size_bytes,json=minChunkSizeBytes,proto3" json:"min_chunk_size_bytes,omitempty"`
	// The lookahead window for finding optimal cutting points.
	// Larger values improve deduplication quality with diminishing returns.
	// Setting to 0 produces uniform chunks of min_chunk_size_bytes.
	// The recommended value is 8 * min_chunk_size_bytes.
	HorizonSizeBytes uint64 `protobuf:"varint,2,opt,name=horizon_size_bytes,json=horizonSizeBytes,proto3" json:"horizon_size_bytes,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *RepMaxCdcParams) Reset() {
	*x = RepMaxCdcParams{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[48]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RepMaxCdcParams) ProtoMessage() {}

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

// Deprecated: Use RepMaxCdcParams.ProtoReflect.Descriptor instead.
func (*RepMaxCdcParams) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{48}
}

func (x *RepMaxCdcParams) GetMinChunkSizeBytes() uint64 {
	if x != nil {
		return x.MinChunkSizeBytes
	}
	return 0
}

func (x *RepMaxCdcParams) GetHorizonSizeBytes() uint64 {
	if x != nil {
		return x.HorizonSizeBytes
	}
	return 0
}

// Capabilities of the remote execution system.
type ExecutionCapabilities struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Legacy field for indicating which digest function is supported by the
	// remote execution system. It MUST be set to a value other than UNKNOWN.
	// Implementations should consider the repeated digest_functions field
	// first, falling back to this singular field if digest_functions is unset.
	DigestFunction DigestFunction_Value `protobuf:"varint,1,opt,name=digest_function,json=digestFunction,proto3,enum=build.bazel.remote.execution.v2.DigestFunction_Value" json:"digest_function,omitempty"`
	// Whether remote execution is enabled for the particular server/instance.
	ExecEnabled bool `protobuf:"varint,2,opt,name=exec_enabled,json=execEnabled,proto3" json:"exec_enabled,omitempty"`
	// Supported execution priority range.
	ExecutionPriorityCapabilities *PriorityCapabilities `protobuf:"bytes,3,opt,name=execution_priority_capabilities,json=executionPriorityCapabilities,proto3" json:"execution_priority_capabilities,omitempty"`
	// Supported node properties.
	SupportedNodeProperties []string `protobuf:"bytes,4,rep,name=supported_node_properties,json=supportedNodeProperties,proto3" json:"supported_node_properties,omitempty"`
	// All the digest functions supported by the remote execution system.
	// If this field is set, it MUST also contain digest_function.
	//
	// Even if the remote execution system announces support for multiple
	// digest functions, individual execution requests may only reference
	// CAS objects using a single digest function. For example, it is not
	// permitted to execute actions having both MD5 and SHA-256 hashed
	// files in their input root.
	//
	// The CAS objects referenced by action results generated by the
	// remote execution system MUST use the same digest function as the
	// one used to construct the action.
	DigestFunctions []DigestFunction_Value `protobuf:"varint,5,rep,packed,name=digest_functions,json=digestFunctions,proto3,enum=build.bazel.remote.execution.v2.DigestFunction_Value" json:"digest_functions,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *ExecutionCapabilities) Reset() {
	*x = ExecutionCapabilities{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[49]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ExecutionCapabilities) ProtoMessage() {}

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

// Deprecated: Use ExecutionCapabilities.ProtoReflect.Descriptor instead.
func (*ExecutionCapabilities) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{49}
}

func (x *ExecutionCapabilities) GetDigestFunction() DigestFunction_Value {
	if x != nil {
		return x.DigestFunction
	}
	return DigestFunction_UNKNOWN
}

func (x *ExecutionCapabilities) GetExecEnabled() bool {
	if x != nil {
		return x.ExecEnabled
	}
	return false
}

func (x *ExecutionCapabilities) GetExecutionPriorityCapabilities() *PriorityCapabilities {
	if x != nil {
		return x.ExecutionPriorityCapabilities
	}
	return nil
}

func (x *ExecutionCapabilities) GetSupportedNodeProperties() []string {
	if x != nil {
		return x.SupportedNodeProperties
	}
	return nil
}

func (x *ExecutionCapabilities) GetDigestFunctions() []DigestFunction_Value {
	if x != nil {
		return x.DigestFunctions
	}
	return nil
}

// Details for the tool used to call the API.
type ToolDetails struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Name of the tool, e.g. bazel.
	ToolName string `protobuf:"bytes,1,opt,name=tool_name,json=toolName,proto3" json:"tool_name,omitempty"`
	// Version of the tool used for the request, e.g. 5.0.3.
	ToolVersion   string `protobuf:"bytes,2,opt,name=tool_version,json=toolVersion,proto3" json:"tool_version,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ToolDetails) Reset() {
	*x = ToolDetails{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[50]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ToolDetails) ProtoMessage() {}

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

// Deprecated: Use ToolDetails.ProtoReflect.Descriptor instead.
func (*ToolDetails) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{50}
}

func (x *ToolDetails) GetToolName() string {
	if x != nil {
		return x.ToolName
	}
	return ""
}

func (x *ToolDetails) GetToolVersion() string {
	if x != nil {
		return x.ToolVersion
	}
	return ""
}

// An optional Metadata to attach to any RPC request to tell the server about an
// external context of the request. The server may use this for logging or other
// purposes. To use it, the client attaches the header to the call using the
// canonical proto serialization:
//
// * name: `build.bazel.remote.execution.v2.requestmetadata-bin`
// * contents: the base64 encoded binary `RequestMetadata` message.
// Note: the gRPC library serializes binary headers encoded in base64 by
// default (https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests).
// Therefore, if the gRPC library is used to pass/retrieve this
// metadata, the user may ignore the base64 encoding and assume it is simply
// serialized as a binary message.
type RequestMetadata struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The details for the tool invoking the requests.
	ToolDetails *ToolDetails `protobuf:"bytes,1,opt,name=tool_details,json=toolDetails,proto3" json:"tool_details,omitempty"`
	// An identifier that ties multiple requests to the same action.
	// For example, multiple requests to the CAS, Action Cache, and Execution
	// API are used in order to compile foo.cc.
	ActionId string `protobuf:"bytes,2,opt,name=action_id,json=actionId,proto3" json:"action_id,omitempty"`
	// An identifier that ties multiple actions together to a final result.
	// For example, multiple actions are required to build and run foo_test.
	ToolInvocationId string `protobuf:"bytes,3,opt,name=tool_invocation_id,json=toolInvocationId,proto3" json:"tool_invocation_id,omitempty"`
	// An identifier to tie multiple tool invocations together. For example,
	// runs of foo_test, bar_test and baz_test on a post-submit of a given patch.
	CorrelatedInvocationsId string `protobuf:"bytes,4,opt,name=correlated_invocations_id,json=correlatedInvocationsId,proto3" json:"correlated_invocations_id,omitempty"`
	// A brief description of the kind of action, for example, CppCompile or GoLink.
	// There is no standard agreed set of values for this, and they are expected to vary between different client tools.
	ActionMnemonic string `protobuf:"bytes,5,opt,name=action_mnemonic,json=actionMnemonic,proto3" json:"action_mnemonic,omitempty"`
	// An identifier for the target which produced this action.
	// No guarantees are made around how many actions may relate to a single target.
	TargetId string `protobuf:"bytes,6,opt,name=target_id,json=targetId,proto3" json:"target_id,omitempty"`
	// An identifier for the configuration in which the target was built,
	// e.g. for differentiating building host tools or different target platforms.
	// There is no expectation that this value will have any particular structure,
	// or equality across invocations, though some client tools may offer these guarantees.
	ConfigurationId string `protobuf:"bytes,7,opt,name=configuration_id,json=configurationId,proto3" json:"configuration_id,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *RequestMetadata) Reset() {
	*x = RequestMetadata{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[51]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RequestMetadata) ProtoMessage() {}

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

// Deprecated: Use RequestMetadata.ProtoReflect.Descriptor instead.
func (*RequestMetadata) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{51}
}

func (x *RequestMetadata) GetToolDetails() *ToolDetails {
	if x != nil {
		return x.ToolDetails
	}
	return nil
}

func (x *RequestMetadata) GetActionId() string {
	if x != nil {
		return x.ActionId
	}
	return ""
}

func (x *RequestMetadata) GetToolInvocationId() string {
	if x != nil {
		return x.ToolInvocationId
	}
	return ""
}

func (x *RequestMetadata) GetCorrelatedInvocationsId() string {
	if x != nil {
		return x.CorrelatedInvocationsId
	}
	return ""
}

func (x *RequestMetadata) GetActionMnemonic() string {
	if x != nil {
		return x.ActionMnemonic
	}
	return ""
}

func (x *RequestMetadata) GetTargetId() string {
	if x != nil {
		return x.TargetId
	}
	return ""
}

func (x *RequestMetadata) GetConfigurationId() string {
	if x != nil {
		return x.ConfigurationId
	}
	return ""
}

// An `EnvironmentVariable` is one variable to set in the running program's
// environment.
type Command_EnvironmentVariable struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The variable name.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The variable value.
	Value         string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Command_EnvironmentVariable) Reset() {
	*x = Command_EnvironmentVariable{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[52]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Command_EnvironmentVariable) ProtoMessage() {}

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

// Deprecated: Use Command_EnvironmentVariable.ProtoReflect.Descriptor instead.
func (*Command_EnvironmentVariable) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{1, 0}
}

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

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

// A single property for the environment. The server is responsible for
// specifying the property `name`s that it accepts. If an unknown `name` is
// provided in the requirements for an
// [Action][build.bazel.remote.execution.v2.Action], the server SHOULD
// reject the execution request. If permitted by the server, the same `name`
// may occur multiple times.
//
// The server is also responsible for specifying the interpretation of
// property `value`s. For instance, a property describing how much RAM must be
// available may be interpreted as allowing a worker with 16GB to fulfill a
// request for 8GB, while a property describing the OS environment on which
// the action must be performed may require an exact match with the worker's
// OS.
//
// The server MAY use the `value` of one or more properties to determine how
// it sets up the execution environment, such as by making specific system
// files available to the worker.
//
// Both names and values are typically case-sensitive. Note that the platform
// is implicitly part of the action digest, so even tiny changes in the names
// or values (like changing case) may result in different action cache
// entries.
type Platform_Property struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The property name.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The property value.
	Value         string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Platform_Property) Reset() {
	*x = Platform_Property{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[53]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Platform_Property) ProtoMessage() {}

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

// Deprecated: Use Platform_Property.ProtoReflect.Descriptor instead.
func (*Platform_Property) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{2, 0}
}

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

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

// A request corresponding to a single blob that the client wants to upload.
type BatchUpdateBlobsRequest_Request struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The digest of the blob. This MUST be the digest of `data`. All
	// digests MUST use the same digest function.
	Digest *Digest `protobuf:"bytes,1,opt,name=digest,proto3" json:"digest,omitempty"`
	// The raw binary data.
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// The format of `data`. Must be `IDENTITY`/unspecified, or one of the
	// compressors advertised by the
	// [CacheCapabilities.supported_batch_update_compressors][build.bazel.remote.execution.v2.CacheCapabilities.supported_batch_update_compressors]
	// field.
	Compressor    Compressor_Value `protobuf:"varint,3,opt,name=compressor,proto3,enum=build.bazel.remote.execution.v2.Compressor_Value" json:"compressor,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BatchUpdateBlobsRequest_Request) Reset() {
	*x = BatchUpdateBlobsRequest_Request{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[55]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BatchUpdateBlobsRequest_Request) ProtoMessage() {}

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

// Deprecated: Use BatchUpdateBlobsRequest_Request.ProtoReflect.Descriptor instead.
func (*BatchUpdateBlobsRequest_Request) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{28, 0}
}

func (x *BatchUpdateBlobsRequest_Request) GetDigest() *Digest {
	if x != nil {
		return x.Digest
	}
	return nil
}

func (x *BatchUpdateBlobsRequest_Request) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

func (x *BatchUpdateBlobsRequest_Request) GetCompressor() Compressor_Value {
	if x != nil {
		return x.Compressor
	}
	return Compressor_IDENTITY
}

// A response corresponding to a single blob that the client tried to upload.
type BatchUpdateBlobsResponse_Response struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The blob digest to which this response corresponds.
	Digest *Digest `protobuf:"bytes,1,opt,name=digest,proto3" json:"digest,omitempty"`
	// The result of attempting to upload that blob.
	Status        *status.Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BatchUpdateBlobsResponse_Response) Reset() {
	*x = BatchUpdateBlobsResponse_Response{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[56]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BatchUpdateBlobsResponse_Response) ProtoMessage() {}

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

// Deprecated: Use BatchUpdateBlobsResponse_Response.ProtoReflect.Descriptor instead.
func (*BatchUpdateBlobsResponse_Response) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{29, 0}
}

func (x *BatchUpdateBlobsResponse_Response) GetDigest() *Digest {
	if x != nil {
		return x.Digest
	}
	return nil
}

func (x *BatchUpdateBlobsResponse_Response) GetStatus() *status.Status {
	if x != nil {
		return x.Status
	}
	return nil
}

// A response corresponding to a single blob that the client tried to download.
type BatchReadBlobsResponse_Response struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The digest to which this response corresponds.
	Digest *Digest `protobuf:"bytes,1,opt,name=digest,proto3" json:"digest,omitempty"`
	// The raw binary data.
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// The format the data is encoded in. MUST be `IDENTITY`/unspecified,
	// or one of the acceptable compressors specified in the `BatchReadBlobsRequest`.
	Compressor Compressor_Value `protobuf:"varint,4,opt,name=compressor,proto3,enum=build.bazel.remote.execution.v2.Compressor_Value" json:"compressor,omitempty"`
	// The result of attempting to download that blob.
	Status        *status.Status `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BatchReadBlobsResponse_Response) Reset() {
	*x = BatchReadBlobsResponse_Response{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[57]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BatchReadBlobsResponse_Response) ProtoMessage() {}

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

// Deprecated: Use BatchReadBlobsResponse_Response.ProtoReflect.Descriptor instead.
func (*BatchReadBlobsResponse_Response) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{31, 0}
}

func (x *BatchReadBlobsResponse_Response) GetDigest() *Digest {
	if x != nil {
		return x.Digest
	}
	return nil
}

func (x *BatchReadBlobsResponse_Response) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

func (x *BatchReadBlobsResponse_Response) GetCompressor() Compressor_Value {
	if x != nil {
		return x.Compressor
	}
	return Compressor_IDENTITY
}

func (x *BatchReadBlobsResponse_Response) GetStatus() *status.Status {
	if x != nil {
		return x.Status
	}
	return nil
}

// Supported range of priorities, including boundaries.
type PriorityCapabilities_PriorityRange struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The minimum numeric value for this priority range, which represents the
	// most urgent task or longest retained item.
	MinPriority int32 `protobuf:"varint,1,opt,name=min_priority,json=minPriority,proto3" json:"min_priority,omitempty"`
	// The maximum numeric value for this priority range, which represents the
	// least urgent task or shortest retained item.
	MaxPriority   int32 `protobuf:"varint,2,opt,name=max_priority,json=maxPriority,proto3" json:"max_priority,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PriorityCapabilities_PriorityRange) Reset() {
	*x = PriorityCapabilities_PriorityRange{}
	mi := &file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes[58]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PriorityCapabilities_PriorityRange) ProtoMessage() {}

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

// Deprecated: Use PriorityCapabilities_PriorityRange.ProtoReflect.Descriptor instead.
func (*PriorityCapabilities_PriorityRange) Descriptor() ([]byte, []int) {
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP(), []int{43, 0}
}

func (x *PriorityCapabilities_PriorityRange) GetMinPriority() int32 {
	if x != nil {
		return x.MinPriority
	}
	return 0
}

func (x *PriorityCapabilities_PriorityRange) GetMaxPriority() int32 {
	if x != nil {
		return x.MaxPriority
	}
	return 0
}

var File_build_bazel_remote_execution_v2_remote_execution_proto protoreflect.FileDescriptor

const file_build_bazel_remote_execution_v2_remote_execution_proto_rawDesc = "" +
	"\n" +
	"6build/bazel/remote/execution/v2/remote_execution.proto\x12\x1fbuild.bazel.remote.execution.v2\x1a\x1fbuild/bazel/semver/semver.proto\x1a\x1cgoogle/api/annotations.proto\x1a#google/longrunning/operations.proto\x1a\x19google/protobuf/any.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1egoogle/protobuf/wrappers.proto\x1a\x17google/rpc/status.proto\"\xeb\x02\n" +
	"\x06Action\x12N\n" +
	"\x0ecommand_digest\x18\x01 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\rcommandDigest\x12S\n" +
	"\x11input_root_digest\x18\x02 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\x0finputRootDigest\x123\n" +
	"\atimeout\x18\x06 \x01(\v2\x19.google.protobuf.DurationR\atimeout\x12 \n" +
	"\fdo_not_cache\x18\a \x01(\bR\n" +
	"doNotCache\x12\x12\n" +
	"\x04salt\x18\t \x01(\fR\x04salt\x12E\n" +
	"\bplatform\x18\n" +
	" \x01(\v2).build.bazel.remote.execution.v2.PlatformR\bplatformJ\x04\b\x03\x10\x06J\x04\b\b\x10\t\"\xd2\x05\n" +
	"\aCommand\x12\x1c\n" +
	"\targuments\x18\x01 \x03(\tR\targuments\x12q\n" +
	"\x15environment_variables\x18\x02 \x03(\v2<.build.bazel.remote.execution.v2.Command.EnvironmentVariableR\x14environmentVariables\x12%\n" +
	"\foutput_files\x18\x03 \x03(\tB\x02\x18\x01R\voutputFiles\x121\n" +
	"\x12output_directories\x18\x04 \x03(\tB\x02\x18\x01R\x11outputDirectories\x12!\n" +
	"\foutput_paths\x18\a \x03(\tR\voutputPaths\x12I\n" +
	"\bplatform\x18\x05 \x01(\v2).build.bazel.remote.execution.v2.PlatformB\x02\x18\x01R\bplatform\x12+\n" +
	"\x11working_directory\x18\x06 \x01(\tR\x10workingDirectory\x124\n" +
	"\x16output_node_properties\x18\b \x03(\tR\x14outputNodeProperties\x12v\n" +
	"\x17output_directory_format\x18\t \x01(\x0e2>.build.bazel.remote.execution.v2.Command.OutputDirectoryFormatR\x15outputDirectoryFormat\x1a?\n" +
	"\x13EnvironmentVariable\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value\"R\n" +
	"\x15OutputDirectoryFormat\x12\r\n" +
	"\tTREE_ONLY\x10\x00\x12\x12\n" +
	"\x0eDIRECTORY_ONLY\x10\x01\x12\x16\n" +
	"\x12TREE_AND_DIRECTORY\x10\x02\"\x94\x01\n" +
	"\bPlatform\x12R\n" +
	"\n" +
	"properties\x18\x01 \x03(\v22.build.bazel.remote.execution.v2.Platform.PropertyR\n" +
	"properties\x1a4\n" +
	"\bProperty\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value\"\xc8\x02\n" +
	"\tDirectory\x12?\n" +
	"\x05files\x18\x01 \x03(\v2).build.bazel.remote.execution.v2.FileNodeR\x05files\x12P\n" +
	"\vdirectories\x18\x02 \x03(\v2..build.bazel.remote.execution.v2.DirectoryNodeR\vdirectories\x12H\n" +
	"\bsymlinks\x18\x03 \x03(\v2,.build.bazel.remote.execution.v2.SymlinkNodeR\bsymlinks\x12X\n" +
	"\x0fnode_properties\x18\x05 \x01(\v2/.build.bazel.remote.execution.v2.NodePropertiesR\x0enodePropertiesJ\x04\b\x04\x10\x05\"8\n" +
	"\fNodeProperty\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value\"\xcc\x01\n" +
	"\x0eNodeProperties\x12M\n" +
	"\n" +
	"properties\x18\x01 \x03(\v2-.build.bazel.remote.execution.v2.NodePropertyR\n" +
	"properties\x120\n" +
	"\x05mtime\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\x05mtime\x129\n" +
	"\tunix_mode\x18\x03 \x01(\v2\x1c.google.protobuf.UInt32ValueR\bunixMode\"\xea\x01\n" +
	"\bFileNode\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12?\n" +
	"\x06digest\x18\x02 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\x06digest\x12#\n" +
	"\ris_executable\x18\x04 \x01(\bR\fisExecutable\x12X\n" +
	"\x0fnode_properties\x18\x06 \x01(\v2/.build.bazel.remote.execution.v2.NodePropertiesR\x0enodePropertiesJ\x04\b\x03\x10\x04J\x04\b\x05\x10\x06\"d\n" +
	"\rDirectoryNode\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12?\n" +
	"\x06digest\x18\x02 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\x06digest\"\x99\x01\n" +
	"\vSymlinkNode\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n" +
	"\x06target\x18\x02 \x01(\tR\x06target\x12X\n" +
	"\x0fnode_properties\x18\x04 \x01(\v2/.build.bazel.remote.execution.v2.NodePropertiesR\x0enodePropertiesJ\x04\b\x03\x10\x04\";\n" +
	"\x06Digest\x12\x12\n" +
	"\x04hash\x18\x01 \x01(\tR\x04hash\x12\x1d\n" +
	"\n" +
	"size_bytes\x18\x02 \x01(\x03R\tsizeBytes\"\xfd\a\n" +
	"\x16ExecutedActionMetadata\x12\x16\n" +
	"\x06worker\x18\x01 \x01(\tR\x06worker\x12E\n" +
	"\x10queued_timestamp\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\x0fqueuedTimestamp\x12P\n" +
	"\x16worker_start_timestamp\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\x14workerStartTimestamp\x12X\n" +
	"\x1aworker_completed_timestamp\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\x18workerCompletedTimestamp\x12Y\n" +
	"\x1binput_fetch_start_timestamp\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\x18inputFetchStartTimestamp\x12a\n" +
	"\x1finput_fetch_completed_timestamp\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\x1cinputFetchCompletedTimestamp\x12V\n" +
	"\x19execution_start_timestamp\x18\a \x01(\v2\x1a.google.protobuf.TimestampR\x17executionStartTimestamp\x12^\n" +
	"\x1dexecution_completed_timestamp\x18\b \x01(\v2\x1a.google.protobuf.TimestampR\x1bexecutionCompletedTimestamp\x12W\n" +
	"\x1avirtual_execution_duration\x18\f \x01(\v2\x19.google.protobuf.DurationR\x18virtualExecutionDuration\x12]\n" +
	"\x1doutput_upload_start_timestamp\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\x1aoutputUploadStartTimestamp\x12e\n" +
	"!output_upload_completed_timestamp\x18\n" +
	" \x01(\v2\x1a.google.protobuf.TimestampR\x1eoutputUploadCompletedTimestamp\x12C\n" +
	"\x12auxiliary_metadata\x18\v \x03(\v2\x14.google.protobuf.AnyR\x11auxiliaryMetadata\"\xd3\x06\n" +
	"\fActionResult\x12N\n" +
	"\foutput_files\x18\x02 \x03(\v2+.build.bazel.remote.execution.v2.OutputFileR\voutputFiles\x12d\n" +
	"\x14output_file_symlinks\x18\n" +
	" \x03(\v2..build.bazel.remote.execution.v2.OutputSymlinkB\x02\x18\x01R\x12outputFileSymlinks\x12W\n" +
	"\x0foutput_symlinks\x18\f \x03(\v2..build.bazel.remote.execution.v2.OutputSymlinkR\x0eoutputSymlinks\x12_\n" +
	"\x12output_directories\x18\x03 \x03(\v20.build.bazel.remote.execution.v2.OutputDirectoryR\x11outputDirectories\x12n\n" +
	"\x19output_directory_symlinks\x18\v \x03(\v2..build.bazel.remote.execution.v2.OutputSymlinkB\x02\x18\x01R\x17outputDirectorySymlinks\x12\x1b\n" +
	"\texit_code\x18\x04 \x01(\x05R\bexitCode\x12\x1d\n" +
	"\n" +
	"stdout_raw\x18\x05 \x01(\fR\tstdoutRaw\x12L\n" +
	"\rstdout_digest\x18\x06 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\fstdoutDigest\x12\x1d\n" +
	"\n" +
	"stderr_raw\x18\a \x01(\fR\tstderrRaw\x12L\n" +
	"\rstderr_digest\x18\b \x01(\v2'.build.bazel.remote.execution.v2.DigestR\fstderrDigest\x12f\n" +
	"\x12execution_metadata\x18\t \x01(\v27.build.bazel.remote.execution.v2.ExecutedActionMetadataR\x11executionMetadataJ\x04\b\x01\x10\x02\"\x88\x02\n" +
	"\n" +
	"OutputFile\x12\x12\n" +
	"\x04path\x18\x01 \x01(\tR\x04path\x12?\n" +
	"\x06digest\x18\x02 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\x06digest\x12#\n" +
	"\ris_executable\x18\x04 \x01(\bR\fisExecutable\x12\x1a\n" +
	"\bcontents\x18\x05 \x01(\fR\bcontents\x12X\n" +
	"\x0fnode_properties\x18\a \x01(\v2/.build.bazel.remote.execution.v2.NodePropertiesR\x0enodePropertiesJ\x04\b\x03\x10\x04J\x04\b\x06\x10\a\"\x8e\x01\n" +
	"\x04Tree\x12>\n" +
	"\x04root\x18\x01 \x01(\v2*.build.bazel.remote.execution.v2.DirectoryR\x04root\x12F\n" +
	"\bchildren\x18\x02 \x03(\v2*.build.bazel.remote.execution.v2.DirectoryR\bchildren\"\x8a\x02\n" +
	"\x0fOutputDirectory\x12\x12\n" +
	"\x04path\x18\x01 \x01(\tR\x04path\x12H\n" +
	"\vtree_digest\x18\x03 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\n" +
	"treeDigest\x126\n" +
	"\x17is_topologically_sorted\x18\x04 \x01(\bR\x15isTopologicallySorted\x12[\n" +
	"\x15root_directory_digest\x18\x05 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\x13rootDirectoryDigestJ\x04\b\x02\x10\x03\"\x9b\x01\n" +
	"\rOutputSymlink\x12\x12\n" +
	"\x04path\x18\x01 \x01(\tR\x04path\x12\x16\n" +
	"\x06target\x18\x02 \x01(\tR\x06target\x12X\n" +
	"\x0fnode_properties\x18\x04 \x01(\v2/.build.bazel.remote.execution.v2.NodePropertiesR\x0enodePropertiesJ\x04\b\x03\x10\x04\"-\n" +
	"\x0fExecutionPolicy\x12\x1a\n" +
	"\bpriority\x18\x01 \x01(\x05R\bpriority\"0\n" +
	"\x12ResultsCachePolicy\x12\x1a\n" +
	"\bpriority\x18\x01 \x01(\x05R\bpriority\"\xdf\x04\n" +
	"\x0eExecuteRequest\x12#\n" +
	"\rinstance_name\x18\x01 \x01(\tR\finstanceName\x12*\n" +
	"\x11skip_cache_lookup\x18\x03 \x01(\bR\x0fskipCacheLookup\x12L\n" +
	"\raction_digest\x18\x06 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\factionDigest\x12[\n" +
	"\x10execution_policy\x18\a \x01(\v20.build.bazel.remote.execution.v2.ExecutionPolicyR\x0fexecutionPolicy\x12e\n" +
	"\x14results_cache_policy\x18\b \x01(\v23.build.bazel.remote.execution.v2.ResultsCachePolicyR\x12resultsCachePolicy\x12^\n" +
	"\x0fdigest_function\x18\t \x01(\x0e25.build.bazel.remote.execution.v2.DigestFunction.ValueR\x0edigestFunction\x12#\n" +
	"\rinline_stdout\x18\n" +
	" \x01(\bR\finlineStdout\x12#\n" +
	"\rinline_stderr\x18\v \x01(\bR\finlineStderr\x12.\n" +
	"\x13inline_output_files\x18\f \x03(\tR\x11inlineOutputFilesJ\x04\b\x02\x10\x03J\x04\b\x04\x10\x05J\x04\b\x05\x10\x06\"q\n" +
	"\aLogFile\x12?\n" +
	"\x06digest\x18\x01 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\x06digest\x12%\n" +
	"\x0ehuman_readable\x18\x02 \x01(\bR\rhumanReadable\"\x8f\x03\n" +
	"\x0fExecuteResponse\x12E\n" +
	"\x06result\x18\x01 \x01(\v2-.build.bazel.remote.execution.v2.ActionResultR\x06result\x12#\n" +
	"\rcached_result\x18\x02 \x01(\bR\fcachedResult\x12*\n" +
	"\x06status\x18\x03 \x01(\v2\x12.google.rpc.StatusR\x06status\x12a\n" +
	"\vserver_logs\x18\x04 \x03(\v2@.build.bazel.remote.execution.v2.ExecuteResponse.ServerLogsEntryR\n" +
	"serverLogs\x12\x18\n" +
	"\amessage\x18\x05 \x01(\tR\amessage\x1ag\n" +
	"\x0fServerLogsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12>\n" +
	"\x05value\x18\x02 \x01(\v2(.build.bazel.remote.execution.v2.LogFileR\x05value:\x028\x01\"a\n" +
	"\x0eExecutionStage\"O\n" +
	"\x05Value\x12\v\n" +
	"\aUNKNOWN\x10\x00\x12\x0f\n" +
	"\vCACHE_CHECK\x10\x01\x12\n" +
	"\n" +
	"\x06QUEUED\x10\x02\x12\r\n" +
	"\tEXECUTING\x10\x03\x12\r\n" +
	"\tCOMPLETED\x10\x04\"\xe8\x03\n" +
	"\x18ExecuteOperationMetadata\x12K\n" +
	"\x05stage\x18\x01 \x01(\x0e25.build.bazel.remote.execution.v2.ExecutionStage.ValueR\x05stage\x12L\n" +
	"\raction_digest\x18\x02 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\factionDigest\x12,\n" +
	"\x12stdout_stream_name\x18\x03 \x01(\tR\x10stdoutStreamName\x12,\n" +
	"\x12stderr_stream_name\x18\x04 \x01(\tR\x10stderrStreamName\x12u\n" +
	"\x1apartial_execution_metadata\x18\x05 \x01(\v27.build.bazel.remote.execution.v2.ExecutedActionMetadataR\x18partialExecutionMetadata\x12^\n" +
	"\x0fdigest_function\x18\x06 \x01(\x0e25.build.bazel.remote.execution.v2.DigestFunction.ValueR\x0edigestFunction\"*\n" +
	"\x14WaitExecutionRequest\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\"\xe5\x02\n" +
	"\x16GetActionResultRequest\x12#\n" +
	"\rinstance_name\x18\x01 \x01(\tR\finstanceName\x12L\n" +
	"\raction_digest\x18\x02 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\factionDigest\x12#\n" +
	"\rinline_stdout\x18\x03 \x01(\bR\finlineStdout\x12#\n" +
	"\rinline_stderr\x18\x04 \x01(\bR\finlineStderr\x12.\n" +
	"\x13inline_output_files\x18\x05 \x03(\tR\x11inlineOutputFiles\x12^\n" +
	"\x0fdigest_function\x18\x06 \x01(\x0e25.build.bazel.remote.execution.v2.DigestFunction.ValueR\x0edigestFunction\"\xa9\x03\n" +
	"\x19UpdateActionResultRequest\x12#\n" +
	"\rinstance_name\x18\x01 \x01(\tR\finstanceName\x12L\n" +
	"\raction_digest\x18\x02 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\factionDigest\x12R\n" +
	"\raction_result\x18\x03 \x01(\v2-.build.bazel.remote.execution.v2.ActionResultR\factionResult\x12e\n" +
	"\x14results_cache_policy\x18\x04 \x01(\v23.build.bazel.remote.execution.v2.ResultsCachePolicyR\x12resultsCachePolicy\x12^\n" +
	"\x0fdigest_function\x18\x05 \x01(\x0e25.build.bazel.remote.execution.v2.DigestFunction.ValueR\x0edigestFunction\"\xea\x01\n" +
	"\x17FindMissingBlobsRequest\x12#\n" +
	"\rinstance_name\x18\x01 \x01(\tR\finstanceName\x12J\n" +
	"\fblob_digests\x18\x02 \x03(\v2'.build.bazel.remote.execution.v2.DigestR\vblobDigests\x12^\n" +
	"\x0fdigest_function\x18\x03 \x01(\x0e25.build.bazel.remote.execution.v2.DigestFunction.ValueR\x0edigestFunction\"u\n" +
	"\x18FindMissingBlobsResponse\x12Y\n" +
	"\x14missing_blob_digests\x18\x02 \x03(\v2'.build.bazel.remote.execution.v2.DigestR\x12missingBlobDigests\"\xb0\x03\n" +
	"\x17BatchUpdateBlobsRequest\x12#\n" +
	"\rinstance_name\x18\x01 \x01(\tR\finstanceName\x12\\\n" +
	"\brequests\x18\x02 \x03(\v2@.build.bazel.remote.execution.v2.BatchUpdateBlobsRequest.RequestR\brequests\x12^\n" +
	"\x0fdigest_function\x18\x05 \x01(\x0e25.build.bazel.remote.execution.v2.DigestFunction.ValueR\x0edigestFunction\x1a\xb1\x01\n" +
	"\aRequest\x12?\n" +
	"\x06digest\x18\x01 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\x06digest\x12\x12\n" +
	"\x04data\x18\x02 \x01(\fR\x04data\x12Q\n" +
	"\n" +
	"compressor\x18\x03 \x01(\x0e21.build.bazel.remote.execution.v2.Compressor.ValueR\n" +
	"compressor\"\xf5\x01\n" +
	"\x18BatchUpdateBlobsResponse\x12`\n" +
	"\tresponses\x18\x01 \x03(\v2B.build.bazel.remote.execution.v2.BatchUpdateBlobsResponse.ResponseR\tresponses\x1aw\n" +
	"\bResponse\x12?\n" +
	"\x06digest\x18\x01 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\x06digest\x12*\n" +
	"\x06status\x18\x02 \x01(\v2\x12.google.rpc.StatusR\x06status\"\xc9\x02\n" +
	"\x15BatchReadBlobsRequest\x12#\n" +
	"\rinstance_name\x18\x01 \x01(\tR\finstanceName\x12A\n" +
	"\adigests\x18\x02 \x03(\v2'.build.bazel.remote.execution.v2.DigestR\adigests\x12h\n" +
	"\x16acceptable_compressors\x18\x03 \x03(\x0e21.build.bazel.remote.execution.v2.Compressor.ValueR\x15acceptableCompressors\x12^\n" +
	"\x0fdigest_function\x18\x04 \x01(\x0e25.build.bazel.remote.execution.v2.DigestFunction.ValueR\x0edigestFunction\"\xd9\x02\n" +
	"\x16BatchReadBlobsResponse\x12^\n" +
	"\tresponses\x18\x01 \x03(\v2@.build.bazel.remote.execution.v2.BatchReadBlobsResponse.ResponseR\tresponses\x1a\xde\x01\n" +
	"\bResponse\x12?\n" +
	"\x06digest\x18\x01 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\x06digest\x12\x12\n" +
	"\x04data\x18\x02 \x01(\fR\x04data\x12Q\n" +
	"\n" +
	"compressor\x18\x04 \x01(\x0e21.build.bazel.remote.execution.v2.Compressor.ValueR\n" +
	"compressor\x12*\n" +
	"\x06status\x18\x03 \x01(\v2\x12.google.rpc.StatusR\x06status\"\x9b\x02\n" +
	"\x0eGetTreeRequest\x12#\n" +
	"\rinstance_name\x18\x01 \x01(\tR\finstanceName\x12H\n" +
	"\vroot_digest\x18\x02 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\n" +
	"rootDigest\x12\x1b\n" +
	"\tpage_size\x18\x03 \x01(\x05R\bpageSize\x12\x1d\n" +
	"\n" +
	"page_token\x18\x04 \x01(\tR\tpageToken\x12^\n" +
	"\x0fdigest_function\x18\x05 \x01(\x0e25.build.bazel.remote.execution.v2.DigestFunction.ValueR\x0edigestFunction\"\x87\x01\n" +
	"\x0fGetTreeResponse\x12L\n" +
	"\vdirectories\x18\x01 \x03(\v2*.build.bazel.remote.execution.v2.DirectoryR\vdirectories\x12&\n" +
	"\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"\xc7\x02\n" +
	"\x10SplitBlobRequest\x12#\n" +
	"\rinstance_name\x18\x01 \x01(\tR\finstanceName\x12H\n" +
	"\vblob_digest\x18\x02 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\n" +
	"blobDigest\x12^\n" +
	"\x0fdigest_function\x18\x03 \x01(\x0e25.build.bazel.remote.execution.v2.DigestFunction.ValueR\x0edigestFunction\x12d\n" +
	"\x11chunking_function\x18\x04 \x01(\x0e27.build.bazel.remote.execution.v2.ChunkingFunction.ValueR\x10chunkingFunction\"\xc7\x01\n" +
	"\x11SplitBlobResponse\x12L\n" +
	"\rchunk_digests\x18\x01 \x03(\v2'.build.bazel.remote.execution.v2.DigestR\fchunkDigests\x12d\n" +
	"\x11chunking_function\x18\x02 \x01(\x0e27.build.bazel.remote.execution.v2.ChunkingFunction.ValueR\x10chunkingFunction\"\x96\x03\n" +
	"\x11SpliceBlobRequest\x12#\n" +
	"\rinstance_name\x18\x01 \x01(\tR\finstanceName\x12H\n" +
	"\vblob_digest\x18\x02 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\n" +
	"blobDigest\x12L\n" +
	"\rchunk_digests\x18\x03 \x03(\v2'.build.bazel.remote.execution.v2.DigestR\fchunkDigests\x12^\n" +
	"\x0fdigest_function\x18\x04 \x01(\x0e25.build.bazel.remote.execution.v2.DigestFunction.ValueR\x0edigestFunction\x12d\n" +
	"\x11chunking_function\x18\x05 \x01(\x0e27.build.bazel.remote.execution.v2.ChunkingFunction.ValueR\x10chunkingFunction\"^\n" +
	"\x12SpliceBlobResponse\x12H\n" +
	"\vblob_digest\x18\x01 \x01(\v2'.build.bazel.remote.execution.v2.DigestR\n" +
	"blobDigest\"=\n" +
	"\x16GetCapabilitiesRequest\x12#\n" +
	"\rinstance_name\x18\x01 \x01(\tR\finstanceName\"\xc2\x03\n" +
	"\x12ServerCapabilities\x12a\n" +
	"\x12cache_capabilities\x18\x01 \x01(\v22.build.bazel.remote.execution.v2.CacheCapabilitiesR\x11cacheCapabilities\x12m\n" +
	"\x16execution_capabilities\x18\x02 \x01(\v26.build.bazel.remote.execution.v2.ExecutionCapabilitiesR\x15executionCapabilities\x12P\n" +
	"\x16deprecated_api_version\x18\x03 \x01(\v2\x1a.build.bazel.semver.SemVerR\x14deprecatedApiVersion\x12B\n" +
	"\x0flow_api_version\x18\x04 \x01(\v2\x1a.build.bazel.semver.SemVerR\rlowApiVersion\x12D\n" +
	"\x10high_api_version\x18\x05 \x01(\v2\x1a.build.bazel.semver.SemVerR\x0ehighApiVersion\"\x9d\x01\n" +
	"\x0eDigestFunction\"\x8a\x01\n" +
	"\x05Value\x12\v\n" +
	"\aUNKNOWN\x10\x00\x12\n" +
	"\n" +
	"\x06SHA256\x10\x01\x12\b\n" +
	"\x04SHA1\x10\x02\x12\a\n" +
	"\x03MD5\x10\x03\x12\a\n" +
	"\x03VSO\x10\x04\x12\n" +
	"\n" +
	"\x06SHA384\x10\x05\x12\n" +
	"\n" +
	"\x06SHA512\x10\x06\x12\v\n" +
	"\aMURMUR3\x10\a\x12\x0e\n" +
	"\n" +
	"SHA256TREE\x10\b\x12\n" +
	"\n" +
	"\x06BLAKE3\x10\t\x12\v\n" +
	"\aGITSHA1\x10\n" +
	"\"L\n" +
	"\x10ChunkingFunction\"8\n" +
	"\x05Value\x12\v\n" +
	"\aUNKNOWN\x10\x00\x12\x11\n" +
	"\rFAST_CDC_2020\x10\x01\x12\x0f\n" +
	"\vREP_MAX_CDC\x10\x02\"F\n" +
	"\x1dActionCacheUpdateCapabilities\x12%\n" +
	"\x0eupdate_enabled\x18\x01 \x01(\bR\rupdateEnabled\"\xd2\x01\n" +
	"\x14PriorityCapabilities\x12c\n" +
	"\n" +
	"priorities\x18\x01 \x03(\v2C.build.bazel.remote.execution.v2.PriorityCapabilities.PriorityRangeR\n" +
	"priorities\x1aU\n" +
	"\rPriorityRange\x12!\n" +
	"\fmin_priority\x18\x01 \x01(\x05R\vminPriority\x12!\n" +
	"\fmax_priority\x18\x02 \x01(\x05R\vmaxPriority\"P\n" +
	"\x1bSymlinkAbsolutePathStrategy\"1\n" +
	"\x05Value\x12\v\n" +
	"\aUNKNOWN\x10\x00\x12\x0e\n" +
	"\n" +
	"DISALLOWED\x10\x01\x12\v\n" +
	"\aALLOWED\x10\x02\"F\n" +
	"\n" +
	"Compressor\"8\n" +
	"\x05Value\x12\f\n" +
	"\bIDENTITY\x10\x00\x12\b\n" +
	"\x04ZSTD\x10\x01\x12\v\n" +
	"\aDEFLATE\x10\x02\x12\n" +
	"\n" +
	"\x06BROTLI\x10\x03\"\xfc\b\n" +
	"\x11CacheCapabilities\x12`\n" +
	"\x10digest_functions\x18\x01 \x03(\x0e25.build.bazel.remote.execution.v2.DigestFunction.ValueR\x0fdigestFunctions\x12\x87\x01\n" +
	" action_cache_update_capabilities\x18\x02 \x01(\v2>.build.bazel.remote.execution.v2.ActionCacheUpdateCapabilitiesR\x1dactionCacheUpdateCapabilities\x12u\n" +
	"\x1bcache_priority_capabilities\x18\x03 \x01(\v25.build.bazel.remote.execution.v2.PriorityCapabilitiesR\x19cachePriorityCapabilities\x12:\n" +
	"\x1amax_batch_total_size_bytes\x18\x04 \x01(\x03R\x16maxBatchTotalSizeBytes\x12\x87\x01\n" +
	"\x1esymlink_absolute_path_strategy\x18\x05 \x01(\x0e2B.build.bazel.remote.execution.v2.SymlinkAbsolutePathStrategy.ValueR\x1bsymlinkAbsolutePathStrategy\x12f\n" +
	"\x15supported_compressors\x18\x06 \x03(\x0e21.build.bazel.remote.execution.v2.Compressor.ValueR\x14supportedCompressors\x12~\n" +
	"\"supported_batch_update_compressors\x18\a \x03(\x0e21.build.bazel.remote.execution.v2.Compressor.ValueR\x1fsupportedBatchUpdateCompressors\x124\n" +
	"\x17max_cas_blob_size_bytes\x18\b \x01(\x03R\x13maxCasBlobSizeBytes\x12,\n" +
	"\x12split_blob_support\x18\t \x01(\bR\x10splitBlobSupport\x12.\n" +
	"\x13splice_blob_support\x18\n" +
	" \x01(\bR\x11spliceBlobSupport\x12c\n" +
	"\x14fast_cdc_2020_params\x18\v \x01(\v22.build.bazel.remote.execution.v2.FastCdc2020ParamsR\x11fastCdc2020Params\x12]\n" +
	"\x12rep_max_cdc_params\x18\f \x01(\v20.build.bazel.remote.execution.v2.RepMaxCdcParamsR\x0frepMaxCdcParams\"X\n" +
	"\x11FastCdc2020Params\x12/\n" +
	"\x14avg_chunk_size_bytes\x18\x01 \x01(\x04R\x11avgChunkSizeBytes\x12\x12\n" +
	"\x04seed\x18\x02 \x01(\rR\x04seed\"p\n" +
	"\x0fRepMaxCdcParams\x12/\n" +
	"\x14min_chunk_size_bytes\x18\x01 \x01(\x04R\x11minChunkSizeBytes\x12,\n" +
	"\x12horizon_size_bytes\x18\x02 \x01(\x04R\x10horizonSizeBytes\"\xb7\x03\n" +
	"\x15ExecutionCapabilities\x12^\n" +
	"\x0fdigest_function\x18\x01 \x01(\x0e25.build.bazel.remote.execution.v2.DigestFunction.ValueR\x0edigestFunction\x12!\n" +
	"\fexec_enabled\x18\x02 \x01(\bR\vexecEnabled\x12}\n" +
	"\x1fexecution_priority_capabilities\x18\x03 \x01(\v25.build.bazel.remote.execution.v2.PriorityCapabilitiesR\x1dexecutionPriorityCapabilities\x12:\n" +
	"\x19supported_node_properties\x18\x04 \x03(\tR\x17supportedNodeProperties\x12`\n" +
	"\x10digest_functions\x18\x05 \x03(\x0e25.build.bazel.remote.execution.v2.DigestFunction.ValueR\x0fdigestFunctions\"M\n" +
	"\vToolDetails\x12\x1b\n" +
	"\ttool_name\x18\x01 \x01(\tR\btoolName\x12!\n" +
	"\ftool_version\x18\x02 \x01(\tR\vtoolVersion\"\xda\x02\n" +
	"\x0fRequestMetadata\x12O\n" +
	"\ftool_details\x18\x01 \x01(\v2,.build.bazel.remote.execution.v2.ToolDetailsR\vtoolDetails\x12\x1b\n" +
	"\taction_id\x18\x02 \x01(\tR\bactionId\x12,\n" +
	"\x12tool_invocation_id\x18\x03 \x01(\tR\x10toolInvocationId\x12:\n" +
	"\x19correlated_invocations_id\x18\x04 \x01(\tR\x17correlatedInvocationsId\x12'\n" +
	"\x0faction_mnemonic\x18\x05 \x01(\tR\x0eactionMnemonic\x12\x1b\n" +
	"\ttarget_id\x18\x06 \x01(\tR\btargetId\x12)\n" +
	"\x10configuration_id\x18\a \x01(\tR\x0fconfigurationId2\xb9\x02\n" +
	"\tExecution\x12\x8e\x01\n" +
	"\aExecute\x12/.build.bazel.remote.execution.v2.ExecuteRequest\x1a\x1d.google.longrunning.Operation\"1\x82\xd3\xe4\x93\x02+:\x01*\"&/v2/{instance_name=**}/actions:execute0\x01\x12\x9a\x01\n" +
	"\rWaitExecution\x125.build.bazel.remote.execution.v2.WaitExecutionRequest\x1a\x1d.google.longrunning.Operation\"1\x82\xd3\xe4\x93\x02+:\x01*\"&/v2/{name=operations/**}:waitExecution0\x012\xd6\x03\n" +
	"\vActionCache\x12\xd7\x01\n" +
	"\x0fGetActionResult\x127.build.bazel.remote.execution.v2.GetActionResultRequest\x1a-.build.bazel.remote.execution.v2.ActionResult\"\\\x82\xd3\xe4\x93\x02V\x12T/v2/{instance_name=**}/actionResults/{action_digest.hash}/{action_digest.size_bytes}\x12\xec\x01\n" +
	"\x12UpdateActionResult\x12:.build.bazel.remote.execution.v2.UpdateActionResultRequest\x1a-.build.bazel.remote.execution.v2.ActionResult\"k\x82\xd3\xe4\x93\x02e:\raction_result\x1aT/v2/{instance_name=**}/actionResults/{action_digest.hash}/{action_digest.size_bytes}2\x98\t\n" +
	"\x19ContentAddressableStorage\x12\xbc\x01\n" +
	"\x10FindMissingBlobs\x128.build.bazel.remote.execution.v2.FindMissingBlobsRequest\x1a9.build.bazel.remote.execution.v2.FindMissingBlobsResponse\"3\x82\xd3\xe4\x93\x02-:\x01*\"(/v2/{instance_name=**}/blobs:findMissing\x12\xbc\x01\n" +
	"\x10BatchUpdateBlobs\x128.build.bazel.remote.execution.v2.BatchUpdateBlobsRequest\x1a9.build.bazel.remote.execution.v2.BatchUpdateBlobsResponse\"3\x82\xd3\xe4\x93\x02-:\x01*\"(/v2/{instance_name=**}/blobs:batchUpdate\x12\xb4\x01\n" +
	"\x0eBatchReadBlobs\x126.build.bazel.remote.execution.v2.BatchReadBlobsRequest\x1a7.build.bazel.remote.execution.v2.BatchReadBlobsResponse\"1\x82\xd3\xe4\x93\x02+:\x01*\"&/v2/{instance_name=**}/blobs:batchRead\x12\xc8\x01\n" +
	"\aGetTree\x12/.build.bazel.remote.execution.v2.GetTreeRequest\x1a0.build.bazel.remote.execution.v2.GetTreeResponse\"X\x82\xd3\xe4\x93\x02R\x12P/v2/{instance_name=**}/blobs/{root_digest.hash}/{root_digest.size_bytes}:getTree0\x01\x12\xce\x01\n" +
	"\tSplitBlob\x121.build.bazel.remote.execution.v2.SplitBlobRequest\x1a2.build.bazel.remote.execution.v2.SplitBlobResponse\"Z\x82\xd3\xe4\x93\x02T\x12R/v2/{instance_name=**}/blobs/{blob_digest.hash}/{blob_digest.size_bytes}:splitBlob\x12\xa9\x01\n" +
	"\n" +
	"SpliceBlob\x122.build.bazel.remote.execution.v2.SpliceBlobRequest\x1a3.build.bazel.remote.execution.v2.SpliceBlobResponse\"2\x82\xd3\xe4\x93\x02,:\x01*\"'/v2/{instance_name=**}/blobs:spliceBlob2\xbd\x01\n" +
	"\fCapabilities\x12\xac\x01\n" +
	"\x0fGetCapabilities\x127.build.bazel.remote.execution.v2.GetCapabilitiesRequest\x1a3.build.bazel.remote.execution.v2.ServerCapabilities\"+\x82\xd3\xe4\x93\x02%\x12#/v2/{instance_name=**}/capabilitiesB\xb4\x01\n" +
	"\x1fbuild.bazel.remote.execution.v2B\x14RemoteExecutionProtoP\x01ZQgithub.com/bazelbuild/remote-apis/build/bazel/remote/execution/v2;remoteexecution\xa2\x02\x03REX\xaa\x02\x1fBuild.Bazel.Remote.Execution.V2b\x06proto3"

var (
	file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescOnce sync.Once
	file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescData []byte
)

func file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescGZIP() []byte {
	file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescOnce.Do(func() {
		file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_build_bazel_remote_execution_v2_remote_execution_proto_rawDesc), len(file_build_bazel_remote_execution_v2_remote_execution_proto_rawDesc)))
	})
	return file_build_bazel_remote_execution_v2_remote_execution_proto_rawDescData
}

var file_build_bazel_remote_execution_v2_remote_execution_proto_enumTypes = make([]protoimpl.EnumInfo, 6)
var file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes = make([]protoimpl.MessageInfo, 59)
var file_build_bazel_remote_execution_v2_remote_execution_proto_goTypes = []any{
	(Command_OutputDirectoryFormat)(0),         // 0: build.bazel.remote.execution.v2.Command.OutputDirectoryFormat
	(ExecutionStage_Value)(0),                  // 1: build.bazel.remote.execution.v2.ExecutionStage.Value
	(DigestFunction_Value)(0),                  // 2: build.bazel.remote.execution.v2.DigestFunction.Value
	(ChunkingFunction_Value)(0),                // 3: build.bazel.remote.execution.v2.ChunkingFunction.Value
	(SymlinkAbsolutePathStrategy_Value)(0),     // 4: build.bazel.remote.execution.v2.SymlinkAbsolutePathStrategy.Value
	(Compressor_Value)(0),                      // 5: build.bazel.remote.execution.v2.Compressor.Value
	(*Action)(nil),                             // 6: build.bazel.remote.execution.v2.Action
	(*Command)(nil),                            // 7: build.bazel.remote.execution.v2.Command
	(*Platform)(nil),                           // 8: build.bazel.remote.execution.v2.Platform
	(*Directory)(nil),                          // 9: build.bazel.remote.execution.v2.Directory
	(*NodeProperty)(nil),                       // 10: build.bazel.remote.execution.v2.NodeProperty
	(*NodeProperties)(nil),                     // 11: build.bazel.remote.execution.v2.NodeProperties
	(*FileNode)(nil),                           // 12: build.bazel.remote.execution.v2.FileNode
	(*DirectoryNode)(nil),                      // 13: build.bazel.remote.execution.v2.DirectoryNode
	(*SymlinkNode)(nil),                        // 14: build.bazel.remote.execution.v2.SymlinkNode
	(*Digest)(nil),                             // 15: build.bazel.remote.execution.v2.Digest
	(*ExecutedActionMetadata)(nil),             // 16: build.bazel.remote.execution.v2.ExecutedActionMetadata
	(*ActionResult)(nil),                       // 17: build.bazel.remote.execution.v2.ActionResult
	(*OutputFile)(nil),                         // 18: build.bazel.remote.execution.v2.OutputFile
	(*Tree)(nil),                               // 19: build.bazel.remote.execution.v2.Tree
	(*OutputDirectory)(nil),                    // 20: build.bazel.remote.execution.v2.OutputDirectory
	(*OutputSymlink)(nil),                      // 21: build.bazel.remote.execution.v2.OutputSymlink
	(*ExecutionPolicy)(nil),                    // 22: build.bazel.remote.execution.v2.ExecutionPolicy
	(*ResultsCachePolicy)(nil),                 // 23: build.bazel.remote.execution.v2.ResultsCachePolicy
	(*ExecuteRequest)(nil),                     // 24: build.bazel.remote.execution.v2.ExecuteRequest
	(*LogFile)(nil),                            // 25: build.bazel.remote.execution.v2.LogFile
	(*ExecuteResponse)(nil),                    // 26: build.bazel.remote.execution.v2.ExecuteResponse
	(*ExecutionStage)(nil),                     // 27: build.bazel.remote.execution.v2.ExecutionStage
	(*ExecuteOperationMetadata)(nil),           // 28: build.bazel.remote.execution.v2.ExecuteOperationMetadata
	(*WaitExecutionRequest)(nil),               // 29: build.bazel.remote.execution.v2.WaitExecutionRequest
	(*GetActionResultRequest)(nil),             // 30: build.bazel.remote.execution.v2.GetActionResultRequest
	(*UpdateActionResultRequest)(nil),          // 31: build.bazel.remote.execution.v2.UpdateActionResultRequest
	(*FindMissingBlobsRequest)(nil),            // 32: build.bazel.remote.execution.v2.FindMissingBlobsRequest
	(*FindMissingBlobsResponse)(nil),           // 33: build.bazel.remote.execution.v2.FindMissingBlobsResponse
	(*BatchUpdateBlobsRequest)(nil),            // 34: build.bazel.remote.execution.v2.BatchUpdateBlobsRequest
	(*BatchUpdateBlobsResponse)(nil),           // 35: build.bazel.remote.execution.v2.BatchUpdateBlobsResponse
	(*BatchReadBlobsRequest)(nil),              // 36: build.bazel.remote.execution.v2.BatchReadBlobsRequest
	(*BatchReadBlobsResponse)(nil),             // 37: build.bazel.remote.execution.v2.BatchReadBlobsResponse
	(*GetTreeRequest)(nil),                     // 38: build.bazel.remote.execution.v2.GetTreeRequest
	(*GetTreeResponse)(nil),                    // 39: build.bazel.remote.execution.v2.GetTreeResponse
	(*SplitBlobRequest)(nil),                   // 40: build.bazel.remote.execution.v2.SplitBlobRequest
	(*SplitBlobResponse)(nil),                  // 41: build.bazel.remote.execution.v2.SplitBlobResponse
	(*SpliceBlobRequest)(nil),                  // 42: build.bazel.remote.execution.v2.SpliceBlobRequest
	(*SpliceBlobResponse)(nil),                 // 43: build.bazel.remote.execution.v2.SpliceBlobResponse
	(*GetCapabilitiesRequest)(nil),             // 44: build.bazel.remote.execution.v2.GetCapabilitiesRequest
	(*ServerCapabilities)(nil),                 // 45: build.bazel.remote.execution.v2.ServerCapabilities
	(*DigestFunction)(nil),                     // 46: build.bazel.remote.execution.v2.DigestFunction
	(*ChunkingFunction)(nil),                   // 47: build.bazel.remote.execution.v2.ChunkingFunction
	(*ActionCacheUpdateCapabilities)(nil),      // 48: build.bazel.remote.execution.v2.ActionCacheUpdateCapabilities
	(*PriorityCapabilities)(nil),               // 49: build.bazel.remote.execution.v2.PriorityCapabilities
	(*SymlinkAbsolutePathStrategy)(nil),        // 50: build.bazel.remote.execution.v2.SymlinkAbsolutePathStrategy
	(*Compressor)(nil),                         // 51: build.bazel.remote.execution.v2.Compressor
	(*CacheCapabilities)(nil),                  // 52: build.bazel.remote.execution.v2.CacheCapabilities
	(*FastCdc2020Params)(nil),                  // 53: build.bazel.remote.execution.v2.FastCdc2020Params
	(*RepMaxCdcParams)(nil),                    // 54: build.bazel.remote.execution.v2.RepMaxCdcParams
	(*ExecutionCapabilities)(nil),              // 55: build.bazel.remote.execution.v2.ExecutionCapabilities
	(*ToolDetails)(nil),                        // 56: build.bazel.remote.execution.v2.ToolDetails
	(*RequestMetadata)(nil),                    // 57: build.bazel.remote.execution.v2.RequestMetadata
	(*Command_EnvironmentVariable)(nil),        // 58: build.bazel.remote.execution.v2.Command.EnvironmentVariable
	(*Platform_Property)(nil),                  // 59: build.bazel.remote.execution.v2.Platform.Property
	nil,                                        // 60: build.bazel.remote.execution.v2.ExecuteResponse.ServerLogsEntry
	(*BatchUpdateBlobsRequest_Request)(nil),    // 61: build.bazel.remote.execution.v2.BatchUpdateBlobsRequest.Request
	(*BatchUpdateBlobsResponse_Response)(nil),  // 62: build.bazel.remote.execution.v2.BatchUpdateBlobsResponse.Response
	(*BatchReadBlobsResponse_Response)(nil),    // 63: build.bazel.remote.execution.v2.BatchReadBlobsResponse.Response
	(*PriorityCapabilities_PriorityRange)(nil), // 64: build.bazel.remote.execution.v2.PriorityCapabilities.PriorityRange
	(*durationpb.Duration)(nil),                // 65: google.protobuf.Duration
	(*timestamppb.Timestamp)(nil),              // 66: google.protobuf.Timestamp
	(*wrapperspb.UInt32Value)(nil),             // 67: google.protobuf.UInt32Value
	(*anypb.Any)(nil),                          // 68: google.protobuf.Any
	(*status.Status)(nil),                      // 69: google.rpc.Status
	(*semver.SemVer)(nil),                      // 70: build.bazel.semver.SemVer
	(*longrunningpb.Operation)(nil),            // 71: google.longrunning.Operation
}
var file_build_bazel_remote_execution_v2_remote_execution_proto_depIdxs = []int32{
	15,  // 0: build.bazel.remote.execution.v2.Action.command_digest:type_name -> build.bazel.remote.execution.v2.Digest
	15,  // 1: build.bazel.remote.execution.v2.Action.input_root_digest:type_name -> build.bazel.remote.execution.v2.Digest
	65,  // 2: build.bazel.remote.execution.v2.Action.timeout:type_name -> google.protobuf.Duration
	8,   // 3: build.bazel.remote.execution.v2.Action.platform:type_name -> build.bazel.remote.execution.v2.Platform
	58,  // 4: build.bazel.remote.execution.v2.Command.environment_variables:type_name -> build.bazel.remote.execution.v2.Command.EnvironmentVariable
	8,   // 5: build.bazel.remote.execution.v2.Command.platform:type_name -> build.bazel.remote.execution.v2.Platform
	0,   // 6: build.bazel.remote.execution.v2.Command.output_directory_format:type_name -> build.bazel.remote.execution.v2.Command.OutputDirectoryFormat
	59,  // 7: build.bazel.remote.execution.v2.Platform.properties:type_name -> build.bazel.remote.execution.v2.Platform.Property
	12,  // 8: build.bazel.remote.execution.v2.Directory.files:type_name -> build.bazel.remote.execution.v2.FileNode
	13,  // 9: build.bazel.remote.execution.v2.Directory.directories:type_name -> build.bazel.remote.execution.v2.DirectoryNode
	14,  // 10: build.bazel.remote.execution.v2.Directory.symlinks:type_name -> build.bazel.remote.execution.v2.SymlinkNode
	11,  // 11: build.bazel.remote.execution.v2.Directory.node_properties:type_name -> build.bazel.remote.execution.v2.NodeProperties
	10,  // 12: build.bazel.remote.execution.v2.NodeProperties.properties:type_name -> build.bazel.remote.execution.v2.NodeProperty
	66,  // 13: build.bazel.remote.execution.v2.NodeProperties.mtime:type_name -> google.protobuf.Timestamp
	67,  // 14: build.bazel.remote.execution.v2.NodeProperties.unix_mode:type_name -> google.protobuf.UInt32Value
	15,  // 15: build.bazel.remote.execution.v2.FileNode.digest:type_name -> build.bazel.remote.execution.v2.Digest
	11,  // 16: build.bazel.remote.execution.v2.FileNode.node_properties:type_name -> build.bazel.remote.execution.v2.NodeProperties
	15,  // 17: build.bazel.remote.execution.v2.DirectoryNode.digest:type_name -> build.bazel.remote.execution.v2.Digest
	11,  // 18: build.bazel.remote.execution.v2.SymlinkNode.node_properties:type_name -> build.bazel.remote.execution.v2.NodeProperties
	66,  // 19: build.bazel.remote.execution.v2.ExecutedActionMetadata.queued_timestamp:type_name -> google.protobuf.Timestamp
	66,  // 20: build.bazel.remote.execution.v2.ExecutedActionMetadata.worker_start_timestamp:type_name -> google.protobuf.Timestamp
	66,  // 21: build.bazel.remote.execution.v2.ExecutedActionMetadata.worker_completed_timestamp:type_name -> google.protobuf.Timestamp
	66,  // 22: build.bazel.remote.execution.v2.ExecutedActionMetadata.input_fetch_start_timestamp:type_name -> google.protobuf.Timestamp
	66,  // 23: build.bazel.remote.execution.v2.ExecutedActionMetadata.input_fetch_completed_timestamp:type_name -> google.protobuf.Timestamp
	66,  // 24: build.bazel.remote.execution.v2.ExecutedActionMetadata.execution_start_timestamp:type_name -> google.protobuf.Timestamp
	66,  // 25: build.bazel.remote.execution.v2.ExecutedActionMetadata.execution_completed_timestamp:type_name -> google.protobuf.Timestamp
	65,  // 26: build.bazel.remote.execution.v2.ExecutedActionMetadata.virtual_execution_duration:type_name -> google.protobuf.Duration
	66,  // 27: build.bazel.remote.execution.v2.ExecutedActionMetadata.output_upload_start_timestamp:type_name -> google.protobuf.Timestamp
	66,  // 28: build.bazel.remote.execution.v2.ExecutedActionMetadata.output_upload_completed_timestamp:type_name -> google.protobuf.Timestamp
	68,  // 29: build.bazel.remote.execution.v2.ExecutedActionMetadata.auxiliary_metadata:type_name -> google.protobuf.Any
	18,  // 30: build.bazel.remote.execution.v2.ActionResult.output_files:type_name -> build.bazel.remote.execution.v2.OutputFile
	21,  // 31: build.bazel.remote.execution.v2.ActionResult.output_file_symlinks:type_name -> build.bazel.remote.execution.v2.OutputSymlink
	21,  // 32: build.bazel.remote.execution.v2.ActionResult.output_symlinks:type_name -> build.bazel.remote.execution.v2.OutputSymlink
	20,  // 33: build.bazel.remote.execution.v2.ActionResult.output_directories:type_name -> build.bazel.remote.execution.v2.OutputDirectory
	21,  // 34: build.bazel.remote.execution.v2.ActionResult.output_directory_symlinks:type_name -> build.bazel.remote.execution.v2.OutputSymlink
	15,  // 35: build.bazel.remote.execution.v2.ActionResult.stdout_digest:type_name -> build.bazel.remote.execution.v2.Digest
	15,  // 36: build.bazel.remote.execution.v2.ActionResult.stderr_digest:type_name -> build.bazel.remote.execution.v2.Digest
	16,  // 37: build.bazel.remote.execution.v2.ActionResult.execution_metadata:type_name -> build.bazel.remote.execution.v2.ExecutedActionMetadata
	15,  // 38: build.bazel.remote.execution.v2.OutputFile.digest:type_name -> build.bazel.remote.execution.v2.Digest
	11,  // 39: build.bazel.remote.execution.v2.OutputFile.node_properties:type_name -> build.bazel.remote.execution.v2.NodeProperties
	9,   // 40: build.bazel.remote.execution.v2.Tree.root:type_name -> build.bazel.remote.execution.v2.Directory
	9,   // 41: build.bazel.remote.execution.v2.Tree.children:type_name -> build.bazel.remote.execution.v2.Directory
	15,  // 42: build.bazel.remote.execution.v2.OutputDirectory.tree_digest:type_name -> build.bazel.remote.execution.v2.Digest
	15,  // 43: build.bazel.remote.execution.v2.OutputDirectory.root_directory_digest:type_name -> build.bazel.remote.execution.v2.Digest
	11,  // 44: build.bazel.remote.execution.v2.OutputSymlink.node_properties:type_name -> build.bazel.remote.execution.v2.NodeProperties
	15,  // 45: build.bazel.remote.execution.v2.ExecuteRequest.action_digest:type_name -> build.bazel.remote.execution.v2.Digest
	22,  // 46: build.bazel.remote.execution.v2.ExecuteRequest.execution_policy:type_name -> build.bazel.remote.execution.v2.ExecutionPolicy
	23,  // 47: build.bazel.remote.execution.v2.ExecuteRequest.results_cache_policy:type_name -> build.bazel.remote.execution.v2.ResultsCachePolicy
	2,   // 48: build.bazel.remote.execution.v2.ExecuteRequest.digest_function:type_name -> build.bazel.remote.execution.v2.DigestFunction.Value
	15,  // 49: build.bazel.remote.execution.v2.LogFile.digest:type_name -> build.bazel.remote.execution.v2.Digest
	17,  // 50: build.bazel.remote.execution.v2.ExecuteResponse.result:type_name -> build.bazel.remote.execution.v2.ActionResult
	69,  // 51: build.bazel.remote.execution.v2.ExecuteResponse.status:type_name -> google.rpc.Status
	60,  // 52: build.bazel.remote.execution.v2.ExecuteResponse.server_logs:type_name -> build.bazel.remote.execution.v2.ExecuteResponse.ServerLogsEntry
	1,   // 53: build.bazel.remote.execution.v2.ExecuteOperationMetadata.stage:type_name -> build.bazel.remote.execution.v2.ExecutionStage.Value
	15,  // 54: build.bazel.remote.execution.v2.ExecuteOperationMetadata.action_digest:type_name -> build.bazel.remote.execution.v2.Digest
	16,  // 55: build.bazel.remote.execution.v2.ExecuteOperationMetadata.partial_execution_metadata:type_name -> build.bazel.remote.execution.v2.ExecutedActionMetadata
	2,   // 56: build.bazel.remote.execution.v2.ExecuteOperationMetadata.digest_function:type_name -> build.bazel.remote.execution.v2.DigestFunction.Value
	15,  // 57: build.bazel.remote.execution.v2.GetActionResultRequest.action_digest:type_name -> build.bazel.remote.execution.v2.Digest
	2,   // 58: build.bazel.remote.execution.v2.GetActionResultRequest.digest_function:type_name -> build.bazel.remote.execution.v2.DigestFunction.Value
	15,  // 59: build.bazel.remote.execution.v2.UpdateActionResultRequest.action_digest:type_name -> build.bazel.remote.execution.v2.Digest
	17,  // 60: build.bazel.remote.execution.v2.UpdateActionResultRequest.action_result:type_name -> build.bazel.remote.execution.v2.ActionResult
	23,  // 61: build.bazel.remote.execution.v2.UpdateActionResultRequest.results_cache_policy:type_name -> build.bazel.remote.execution.v2.ResultsCachePolicy
	2,   // 62: build.bazel.remote.execution.v2.UpdateActionResultRequest.digest_function:type_name -> build.bazel.remote.execution.v2.DigestFunction.Value
	15,  // 63: build.bazel.remote.execution.v2.FindMissingBlobsRequest.blob_digests:type_name -> build.bazel.remote.execution.v2.Digest
	2,   // 64: build.bazel.remote.execution.v2.FindMissingBlobsRequest.digest_function:type_name -> build.bazel.remote.execution.v2.DigestFunction.Value
	15,  // 65: build.bazel.remote.execution.v2.FindMissingBlobsResponse.missing_blob_digests:type_name -> build.bazel.remote.execution.v2.Digest
	61,  // 66: build.bazel.remote.execution.v2.BatchUpdateBlobsRequest.requests:type_name -> build.bazel.remote.execution.v2.BatchUpdateBlobsRequest.Request
	2,   // 67: build.bazel.remote.execution.v2.BatchUpdateBlobsRequest.digest_function:type_name -> build.bazel.remote.execution.v2.DigestFunction.Value
	62,  // 68: build.bazel.remote.execution.v2.BatchUpdateBlobsResponse.responses:type_name -> build.bazel.remote.execution.v2.BatchUpdateBlobsResponse.Response
	15,  // 69: build.bazel.remote.execution.v2.BatchReadBlobsRequest.digests:type_name -> build.bazel.remote.execution.v2.Digest
	5,   // 70: build.bazel.remote.execution.v2.BatchReadBlobsRequest.acceptable_compressors:type_name -> build.bazel.remote.execution.v2.Compressor.Value
	2,   // 71: build.bazel.remote.execution.v2.BatchReadBlobsRequest.digest_function:type_name -> build.bazel.remote.execution.v2.DigestFunction.Value
	63,  // 72: build.bazel.remote.execution.v2.BatchReadBlobsResponse.responses:type_name -> build.bazel.remote.execution.v2.BatchReadBlobsResponse.Response
	15,  // 73: build.bazel.remote.execution.v2.GetTreeRequest.root_digest:type_name -> build.bazel.remote.execution.v2.Digest
	2,   // 74: build.bazel.remote.execution.v2.GetTreeRequest.digest_function:type_name -> build.bazel.remote.execution.v2.DigestFunction.Value
	9,   // 75: build.bazel.remote.execution.v2.GetTreeResponse.directories:type_name -> build.bazel.remote.execution.v2.Directory
	15,  // 76: build.bazel.remote.execution.v2.SplitBlobRequest.blob_digest:type_name -> build.bazel.remote.execution.v2.Digest
	2,   // 77: build.bazel.remote.execution.v2.SplitBlobRequest.digest_function:type_name -> build.bazel.remote.execution.v2.DigestFunction.Value
	3,   // 78: build.bazel.remote.execution.v2.SplitBlobRequest.chunking_function:type_name -> build.bazel.remote.execution.v2.ChunkingFunction.Value
	15,  // 79: build.bazel.remote.execution.v2.SplitBlobResponse.chunk_digests:type_name -> build.bazel.remote.execution.v2.Digest
	3,   // 80: build.bazel.remote.execution.v2.SplitBlobResponse.chunking_function:type_name -> build.bazel.remote.execution.v2.ChunkingFunction.Value
	15,  // 81: build.bazel.remote.execution.v2.SpliceBlobRequest.blob_digest:type_name -> build.bazel.remote.execution.v2.Digest
	15,  // 82: build.bazel.remote.execution.v2.SpliceBlobRequest.chunk_digests:type_name -> build.bazel.remote.execution.v2.Digest
	2,   // 83: build.bazel.remote.execution.v2.SpliceBlobRequest.digest_function:type_name -> build.bazel.remote.execution.v2.DigestFunction.Value
	3,   // 84: build.bazel.remote.execution.v2.SpliceBlobRequest.chunking_function:type_name -> build.bazel.remote.execution.v2.ChunkingFunction.Value
	15,  // 85: build.bazel.remote.execution.v2.SpliceBlobResponse.blob_digest:type_name -> build.bazel.remote.execution.v2.Digest
	52,  // 86: build.bazel.remote.execution.v2.ServerCapabilities.cache_capabilities:type_name -> build.bazel.remote.execution.v2.CacheCapabilities
	55,  // 87: build.bazel.remote.execution.v2.ServerCapabilities.execution_capabilities:type_name -> build.bazel.remote.execution.v2.ExecutionCapabilities
	70,  // 88: build.bazel.remote.execution.v2.ServerCapabilities.deprecated_api_version:type_name -> build.bazel.semver.SemVer
	70,  // 89: build.bazel.remote.execution.v2.ServerCapabilities.low_api_version:type_name -> build.bazel.semver.SemVer
	70,  // 90: build.bazel.remote.execution.v2.ServerCapabilities.high_api_version:type_name -> build.bazel.semver.SemVer
	64,  // 91: build.bazel.remote.execution.v2.PriorityCapabilities.priorities:type_name -> build.bazel.remote.execution.v2.PriorityCapabilities.PriorityRange
	2,   // 92: build.bazel.remote.execution.v2.CacheCapabilities.digest_functions:type_name -> build.bazel.remote.execution.v2.DigestFunction.Value
	48,  // 93: build.bazel.remote.execution.v2.CacheCapabilities.action_cache_update_capabilities:type_name -> build.bazel.remote.execution.v2.ActionCacheUpdateCapabilities
	49,  // 94: build.bazel.remote.execution.v2.CacheCapabilities.cache_priority_capabilities:type_name -> build.bazel.remote.execution.v2.PriorityCapabilities
	4,   // 95: build.bazel.remote.execution.v2.CacheCapabilities.symlink_absolute_path_strategy:type_name -> build.bazel.remote.execution.v2.SymlinkAbsolutePathStrategy.Value
	5,   // 96: build.bazel.remote.execution.v2.CacheCapabilities.supported_compressors:type_name -> build.bazel.remote.execution.v2.Compressor.Value
	5,   // 97: build.bazel.remote.execution.v2.CacheCapabilities.supported_batch_update_compressors:type_name -> build.bazel.remote.execution.v2.Compressor.Value
	53,  // 98: build.bazel.remote.execution.v2.CacheCapabilities.fast_cdc_2020_params:type_name -> build.bazel.remote.execution.v2.FastCdc2020Params
	54,  // 99: build.bazel.remote.execution.v2.CacheCapabilities.rep_max_cdc_params:type_name -> build.bazel.remote.execution.v2.RepMaxCdcParams
	2,   // 100: build.bazel.remote.execution.v2.ExecutionCapabilities.digest_function:type_name -> build.bazel.remote.execution.v2.DigestFunction.Value
	49,  // 101: build.bazel.remote.execution.v2.ExecutionCapabilities.execution_priority_capabilities:type_name -> build.bazel.remote.execution.v2.PriorityCapabilities
	2,   // 102: build.bazel.remote.execution.v2.ExecutionCapabilities.digest_functions:type_name -> build.bazel.remote.execution.v2.DigestFunction.Value
	56,  // 103: build.bazel.remote.execution.v2.RequestMetadata.tool_details:type_name -> build.bazel.remote.execution.v2.ToolDetails
	25,  // 104: build.bazel.remote.execution.v2.ExecuteResponse.ServerLogsEntry.value:type_name -> build.bazel.remote.execution.v2.LogFile
	15,  // 105: build.bazel.remote.execution.v2.BatchUpdateBlobsRequest.Request.digest:type_name -> build.bazel.remote.execution.v2.Digest
	5,   // 106: build.bazel.remote.execution.v2.BatchUpdateBlobsRequest.Request.compressor:type_name -> build.bazel.remote.execution.v2.Compressor.Value
	15,  // 107: build.bazel.remote.execution.v2.BatchUpdateBlobsResponse.Response.digest:type_name -> build.bazel.remote.execution.v2.Digest
	69,  // 108: build.bazel.remote.execution.v2.BatchUpdateBlobsResponse.Response.status:type_name -> google.rpc.Status
	15,  // 109: build.bazel.remote.execution.v2.BatchReadBlobsResponse.Response.digest:type_name -> build.bazel.remote.execution.v2.Digest
	5,   // 110: build.bazel.remote.execution.v2.BatchReadBlobsResponse.Response.compressor:type_name -> build.bazel.remote.execution.v2.Compressor.Value
	69,  // 111: build.bazel.remote.execution.v2.BatchReadBlobsResponse.Response.status:type_name -> google.rpc.Status
	24,  // 112: build.bazel.remote.execution.v2.Execution.Execute:input_type -> build.bazel.remote.execution.v2.ExecuteRequest
	29,  // 113: build.bazel.remote.execution.v2.Execution.WaitExecution:input_type -> build.bazel.remote.execution.v2.WaitExecutionRequest
	30,  // 114: build.bazel.remote.execution.v2.ActionCache.GetActionResult:input_type -> build.bazel.remote.execution.v2.GetActionResultRequest
	31,  // 115: build.bazel.remote.execution.v2.ActionCache.UpdateActionResult:input_type -> build.bazel.remote.execution.v2.UpdateActionResultRequest
	32,  // 116: build.bazel.remote.execution.v2.ContentAddressableStorage.FindMissingBlobs:input_type -> build.bazel.remote.execution.v2.FindMissingBlobsRequest
	34,  // 117: build.bazel.remote.execution.v2.ContentAddressableStorage.BatchUpdateBlobs:input_type -> build.bazel.remote.execution.v2.BatchUpdateBlobsRequest
	36,  // 118: build.bazel.remote.execution.v2.ContentAddressableStorage.BatchReadBlobs:input_type -> build.bazel.remote.execution.v2.BatchReadBlobsRequest
	38,  // 119: build.bazel.remote.execution.v2.ContentAddressableStorage.GetTree:input_type -> build.bazel.remote.execution.v2.GetTreeRequest
	40,  // 120: build.bazel.remote.execution.v2.ContentAddressableStorage.SplitBlob:input_type -> build.bazel.remote.execution.v2.SplitBlobRequest
	42,  // 121: build.bazel.remote.execution.v2.ContentAddressableStorage.SpliceBlob:input_type -> build.bazel.remote.execution.v2.SpliceBlobRequest
	44,  // 122: build.bazel.remote.execution.v2.Capabilities.GetCapabilities:input_type -> build.bazel.remote.execution.v2.GetCapabilitiesRequest
	71,  // 123: build.bazel.remote.execution.v2.Execution.Execute:output_type -> google.longrunning.Operation
	71,  // 124: build.bazel.remote.execution.v2.Execution.WaitExecution:output_type -> google.longrunning.Operation
	17,  // 125: build.bazel.remote.execution.v2.ActionCache.GetActionResult:output_type -> build.bazel.remote.execution.v2.ActionResult
	17,  // 126: build.bazel.remote.execution.v2.ActionCache.UpdateActionResult:output_type -> build.bazel.remote.execution.v2.ActionResult
	33,  // 127: build.bazel.remote.execution.v2.ContentAddressableStorage.FindMissingBlobs:output_type -> build.bazel.remote.execution.v2.FindMissingBlobsResponse
	35,  // 128: build.bazel.remote.execution.v2.ContentAddressableStorage.BatchUpdateBlobs:output_type -> build.bazel.remote.execution.v2.BatchUpdateBlobsResponse
	37,  // 129: build.bazel.remote.execution.v2.ContentAddressableStorage.BatchReadBlobs:output_type -> build.bazel.remote.execution.v2.BatchReadBlobsResponse
	39,  // 130: build.bazel.remote.execution.v2.ContentAddressableStorage.GetTree:output_type -> build.bazel.remote.execution.v2.GetTreeResponse
	41,  // 131: build.bazel.remote.execution.v2.ContentAddressableStorage.SplitBlob:output_type -> build.bazel.remote.execution.v2.SplitBlobResponse
	43,  // 132: build.bazel.remote.execution.v2.ContentAddressableStorage.SpliceBlob:output_type -> build.bazel.remote.execution.v2.SpliceBlobResponse
	45,  // 133: build.bazel.remote.execution.v2.Capabilities.GetCapabilities:output_type -> build.bazel.remote.execution.v2.ServerCapabilities
	123, // [123:134] is the sub-list for method output_type
	112, // [112:123] is the sub-list for method input_type
	112, // [112:112] is the sub-list for extension type_name
	112, // [112:112] is the sub-list for extension extendee
	0,   // [0:112] is the sub-list for field type_name
}

func init() { file_build_bazel_remote_execution_v2_remote_execution_proto_init() }
func file_build_bazel_remote_execution_v2_remote_execution_proto_init() {
	if File_build_bazel_remote_execution_v2_remote_execution_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_build_bazel_remote_execution_v2_remote_execution_proto_rawDesc), len(file_build_bazel_remote_execution_v2_remote_execution_proto_rawDesc)),
			NumEnums:      6,
			NumMessages:   59,
			NumExtensions: 0,
			NumServices:   4,
		},
		GoTypes:           file_build_bazel_remote_execution_v2_remote_execution_proto_goTypes,
		DependencyIndexes: file_build_bazel_remote_execution_v2_remote_execution_proto_depIdxs,
		EnumInfos:         file_build_bazel_remote_execution_v2_remote_execution_proto_enumTypes,
		MessageInfos:      file_build_bazel_remote_execution_v2_remote_execution_proto_msgTypes,
	}.Build()
	File_build_bazel_remote_execution_v2_remote_execution_proto = out.File
	file_build_bazel_remote_execution_v2_remote_execution_proto_goTypes = nil
	file_build_bazel_remote_execution_v2_remote_execution_proto_depIdxs = nil
}
