remoteexecution

type Action struct {

	// 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"`
	// contains filtered or unexported fields
}

type ActionCacheClient interface {
	// Retrieve a cached execution result.
	//
	// Implementations SHOULD ensure that any blobs referenced from the
	// [ContentAddressableStorage][build.bazel.remote.execution.v2.ContentAddressableStorage]
	// are available at the time of returning the
	// [ActionResult][build.bazel.remote.execution.v2.ActionResult] and will be
	// for some period of time afterwards. The lifetimes of the referenced blobs SHOULD be increased
	// if necessary and applicable.
	//
	// Errors:
	//
	// * `NOT_FOUND`: The requested `ActionResult` is not in the cache.
	GetActionResult(ctx context.Context, in *GetActionResultRequest, opts ...grpc.CallOption) (*ActionResult, error)
	// Upload a new execution result.
	//
	// In order to allow the server to perform access control based on the type of
	// action, and to assist with client debugging, the client MUST first upload
	// the [Action][build.bazel.remote.execution.v2.Execution] that produced the
	// result, along with its
	// [Command][build.bazel.remote.execution.v2.Command], into the
	// `ContentAddressableStorage`.
	//
	// Server implementations MAY modify the
	// `UpdateActionResultRequest.action_result` and return an equivalent value.
	//
	// Errors:
	//
	//   - `INVALID_ARGUMENT`: One or more arguments are invalid.
	//   - `FAILED_PRECONDITION`: One or more errors occurred in updating the
	//     action result, such as a missing command or action.
	//   - `RESOURCE_EXHAUSTED`: There is insufficient storage space to add the
	//     entry to the cache.
	UpdateActionResult(ctx context.Context, in *UpdateActionResultRequest, opts ...grpc.CallOption) (*ActionResult, error)
}

type ActionCacheServer interface {
	// Retrieve a cached execution result.
	//
	// Implementations SHOULD ensure that any blobs referenced from the
	// [ContentAddressableStorage][build.bazel.remote.execution.v2.ContentAddressableStorage]
	// are available at the time of returning the
	// [ActionResult][build.bazel.remote.execution.v2.ActionResult] and will be
	// for some period of time afterwards. The lifetimes of the referenced blobs SHOULD be increased
	// if necessary and applicable.
	//
	// Errors:
	//
	// * `NOT_FOUND`: The requested `ActionResult` is not in the cache.
	GetActionResult(context.Context, *GetActionResultRequest) (*ActionResult, error)
	// Upload a new execution result.
	//
	// In order to allow the server to perform access control based on the type of
	// action, and to assist with client debugging, the client MUST first upload
	// the [Action][build.bazel.remote.execution.v2.Execution] that produced the
	// result, along with its
	// [Command][build.bazel.remote.execution.v2.Command], into the
	// `ContentAddressableStorage`.
	//
	// Server implementations MAY modify the
	// `UpdateActionResultRequest.action_result` and return an equivalent value.
	//
	// Errors:
	//
	//   - `INVALID_ARGUMENT`: One or more arguments are invalid.
	//   - `FAILED_PRECONDITION`: One or more errors occurred in updating the
	//     action result, such as a missing command or action.
	//   - `RESOURCE_EXHAUSTED`: There is insufficient storage space to add the
	//     entry to the cache.
	UpdateActionResult(context.Context, *UpdateActionResultRequest) (*ActionResult, error)
}

type ActionCacheUpdateCapabilities struct {
	UpdateEnabled bool `protobuf:"varint,1,opt,name=update_enabled,json=updateEnabled,proto3" json:"update_enabled,omitempty"`
	// contains filtered or unexported fields
}

type ActionResult struct {

	// 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 `` /* 133-byte string literal not displayed */
	// 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"`
	// contains filtered or unexported fields
}

type BatchReadBlobsRequest struct {

	// 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 `` /* 186-byte string literal not displayed */
	// 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 `` /* 162-byte string literal not displayed */
	// contains filtered or unexported fields
}

type BatchReadBlobsResponse struct {

	// The responses to the requests.
	Responses []*BatchReadBlobsResponse_Response `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"`
	// contains filtered or unexported fields
}

type BatchReadBlobsResponse_Response struct {

	// 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 `` /* 128-byte string literal not displayed */
	// The result of attempting to download that blob.
	Status *status.Status `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

type BatchUpdateBlobsRequest struct {

	// 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 `` /* 162-byte string literal not displayed */
	// contains filtered or unexported fields
}

type BatchUpdateBlobsRequest_Request struct {

	// 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_compressors][build.bazel.remote.execution.v2.CacheCapabilities.supported_batch_compressors]
	// field.
	Compressor Compressor_Value `` /* 128-byte string literal not displayed */
	// contains filtered or unexported fields
}

type BatchUpdateBlobsResponse struct {

	// The responses to the requests.
	Responses []*BatchUpdateBlobsResponse_Response `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"`
	// contains filtered or unexported fields
}

type BatchUpdateBlobsResponse_Response struct {

	// 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"`
	// contains filtered or unexported fields
}

type CacheCapabilities struct {

	// All the digest functions supported by the remote cache.
	// Remote cache may support multiple digest functions simultaneously.
	DigestFunctions []DigestFunction_Value `` /* 172-byte string literal not displayed */
	// Capabilities for updating the action cache.
	ActionCacheUpdateCapabilities *ActionCacheUpdateCapabilities `` /* 152-byte string literal not displayed */
	// Supported cache priority range for both CAS and ActionCache.
	CachePriorityCapabilities *PriorityCapabilities `` /* 138-byte string literal not displayed */
	// 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 `` /* 134-byte string literal not displayed */
	// Whether absolute symlink targets are supported.
	SymlinkAbsolutePathStrategy SymlinkAbsolutePathStrategy_Value `` /* 218-byte string literal not displayed */
	// 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 `` /* 183-byte string literal not displayed */
	// Compressors supported for inlined data in
	// [BatchUpdateBlobs][build.bazel.remote.execution.v2.ContentAddressableStorage.BatchUpdateBlobs]
	// requests.
	SupportedBatchUpdateCompressors []Compressor_Value `` /* 220-byte string literal not displayed */
	// contains filtered or unexported fields
}

type CapabilitiesClient interface {
	// GetCapabilities returns the server capabilities configuration of the
	// remote endpoint.
	// Only the capabilities of the services supported by the endpoint will
	// be returned:
	//   - Execution + CAS + Action Cache endpoints should return both
	//     CacheCapabilities and ExecutionCapabilities.
	//   - Execution only endpoints should return ExecutionCapabilities.
	//   - CAS + Action Cache only endpoints should return CacheCapabilities.
	//
	// There are no method-specific errors.
	GetCapabilities(ctx context.Context, in *GetCapabilitiesRequest, opts ...grpc.CallOption) (*ServerCapabilities, error)
}

type CapabilitiesServer interface {
	// GetCapabilities returns the server capabilities configuration of the
	// remote endpoint.
	// Only the capabilities of the services supported by the endpoint will
	// be returned:
	//   - Execution + CAS + Action Cache endpoints should return both
	//     CacheCapabilities and ExecutionCapabilities.
	//   - Execution only endpoints should return ExecutionCapabilities.
	//   - CAS + Action Cache only endpoints should return CacheCapabilities.
	//
	// There are no method-specific errors.
	GetCapabilities(context.Context, *GetCapabilitiesRequest) (*ServerCapabilities, error)
}

type Command struct {

	// 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 `` /* 194-byte string literal not displayed */
	// contains filtered or unexported fields
}

type Command_EnvironmentVariable struct {

	// 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"`
	// contains filtered or unexported fields
}

type Command_OutputDirectoryFormat int32

type Compressor struct {
	// contains filtered or unexported fields
}

type Compressor_Value int32

type ContentAddressableStorageClient interface {
	// Determine if blobs are present in the CAS.
	//
	// Clients can use this API before uploading blobs to determine which ones are
	// already present in the CAS and do not need to be uploaded again.
	//
	// Servers SHOULD increase the lifetimes of the referenced blobs if necessary and
	// applicable.
	//
	// There are no method-specific errors.
	FindMissingBlobs(ctx context.Context, in *FindMissingBlobsRequest, opts ...grpc.CallOption) (*FindMissingBlobsResponse, error)
	// Upload many blobs at once.
	//
	// The server may enforce a limit of the combined total size of blobs
	// to be uploaded using this API. This limit may be obtained using the
	// [Capabilities][build.bazel.remote.execution.v2.Capabilities] API.
	// Requests exceeding the limit should either be split into smaller
	// chunks or uploaded using the
	// [ByteStream API][google.bytestream.ByteStream], as appropriate.
	//
	// This request is equivalent to calling a Bytestream `Write` request
	// on each individual blob, in parallel. The requests may succeed or fail
	// independently.
	//
	// Errors:
	//
	//   - `INVALID_ARGUMENT`: The client attempted to upload more than the
	//     server supported limit.
	//
	// Individual requests may return the following errors, additionally:
	//
	// * `RESOURCE_EXHAUSTED`: There is insufficient disk quota to store the blob.
	// * `INVALID_ARGUMENT`: The
	// [Digest][build.bazel.remote.execution.v2.Digest] does not match the
	// provided data.
	BatchUpdateBlobs(ctx context.Context, in *BatchUpdateBlobsRequest, opts ...grpc.CallOption) (*BatchUpdateBlobsResponse, error)
	// Download many blobs at once.
	//
	// The server may enforce a limit of the combined total size of blobs
	// to be downloaded using this API. This limit may be obtained using the
	// [Capabilities][build.bazel.remote.execution.v2.Capabilities] API.
	// Requests exceeding the limit should either be split into smaller
	// chunks or downloaded using the
	// [ByteStream API][google.bytestream.ByteStream], as appropriate.
	//
	// This request is equivalent to calling a Bytestream `Read` request
	// on each individual blob, in parallel. The requests may succeed or fail
	// independently.
	//
	// Errors:
	//
	//   - `INVALID_ARGUMENT`: The client attempted to read more than the
	//     server supported limit.
	//
	// Every error on individual read will be returned in the corresponding digest
	// status.
	BatchReadBlobs(ctx context.Context, in *BatchReadBlobsRequest, opts ...grpc.CallOption) (*BatchReadBlobsResponse, error)
	// Fetch the entire directory tree rooted at a node.
	//
	// This request must be targeted at a
	// [Directory][build.bazel.remote.execution.v2.Directory] stored in the
	// [ContentAddressableStorage][build.bazel.remote.execution.v2.ContentAddressableStorage]
	// (CAS). The server will enumerate the `Directory` tree recursively and
	// return every node descended from the root.
	//
	// The GetTreeRequest.page_token parameter can be used to skip ahead in
	// the stream (e.g. when retrying a partially completed and aborted request),
	// by setting it to a value taken from GetTreeResponse.next_page_token of the
	// last successfully processed GetTreeResponse).
	//
	// The exact traversal order is unspecified and, unless retrieving subsequent
	// pages from an earlier request, is not guaranteed to be stable across
	// multiple invocations of `GetTree`.
	//
	// If part of the tree is missing from the CAS, the server will return the
	// portion present and omit the rest.
	//
	// Errors:
	//
	// * `NOT_FOUND`: The requested tree root is not present in the CAS.
	GetTree(ctx context.Context, in *GetTreeRequest, opts ...grpc.CallOption) (ContentAddressableStorage_GetTreeClient, error)
}

type ContentAddressableStorageServer interface {
	// Determine if blobs are present in the CAS.
	//
	// Clients can use this API before uploading blobs to determine which ones are
	// already present in the CAS and do not need to be uploaded again.
	//
	// Servers SHOULD increase the lifetimes of the referenced blobs if necessary and
	// applicable.
	//
	// There are no method-specific errors.
	FindMissingBlobs(context.Context, *FindMissingBlobsRequest) (*FindMissingBlobsResponse, error)
	// Upload many blobs at once.
	//
	// The server may enforce a limit of the combined total size of blobs
	// to be uploaded using this API. This limit may be obtained using the
	// [Capabilities][build.bazel.remote.execution.v2.Capabilities] API.
	// Requests exceeding the limit should either be split into smaller
	// chunks or uploaded using the
	// [ByteStream API][google.bytestream.ByteStream], as appropriate.
	//
	// This request is equivalent to calling a Bytestream `Write` request
	// on each individual blob, in parallel. The requests may succeed or fail
	// independently.
	//
	// Errors:
	//
	//   - `INVALID_ARGUMENT`: The client attempted to upload more than the
	//     server supported limit.
	//
	// Individual requests may return the following errors, additionally:
	//
	// * `RESOURCE_EXHAUSTED`: There is insufficient disk quota to store the blob.
	// * `INVALID_ARGUMENT`: The
	// [Digest][build.bazel.remote.execution.v2.Digest] does not match the
	// provided data.
	BatchUpdateBlobs(context.Context, *BatchUpdateBlobsRequest) (*BatchUpdateBlobsResponse, error)
	// Download many blobs at once.
	//
	// The server may enforce a limit of the combined total size of blobs
	// to be downloaded using this API. This limit may be obtained using the
	// [Capabilities][build.bazel.remote.execution.v2.Capabilities] API.
	// Requests exceeding the limit should either be split into smaller
	// chunks or downloaded using the
	// [ByteStream API][google.bytestream.ByteStream], as appropriate.
	//
	// This request is equivalent to calling a Bytestream `Read` request
	// on each individual blob, in parallel. The requests may succeed or fail
	// independently.
	//
	// Errors:
	//
	//   - `INVALID_ARGUMENT`: The client attempted to read more than the
	//     server supported limit.
	//
	// Every error on individual read will be returned in the corresponding digest
	// status.
	BatchReadBlobs(context.Context, *BatchReadBlobsRequest) (*BatchReadBlobsResponse, error)
	// Fetch the entire directory tree rooted at a node.
	//
	// This request must be targeted at a
	// [Directory][build.bazel.remote.execution.v2.Directory] stored in the
	// [ContentAddressableStorage][build.bazel.remote.execution.v2.ContentAddressableStorage]
	// (CAS). The server will enumerate the `Directory` tree recursively and
	// return every node descended from the root.
	//
	// The GetTreeRequest.page_token parameter can be used to skip ahead in
	// the stream (e.g. when retrying a partially completed and aborted request),
	// by setting it to a value taken from GetTreeResponse.next_page_token of the
	// last successfully processed GetTreeResponse).
	//
	// The exact traversal order is unspecified and, unless retrieving subsequent
	// pages from an earlier request, is not guaranteed to be stable across
	// multiple invocations of `GetTree`.
	//
	// If part of the tree is missing from the CAS, the server will return the
	// portion present and omit the rest.
	//
	// Errors:
	//
	// * `NOT_FOUND`: The requested tree root is not present in the CAS.
	GetTree(*GetTreeRequest, ContentAddressableStorage_GetTreeServer) error
}

type ContentAddressableStorage_GetTreeClient interface {
	Recv() (*GetTreeResponse, error)
	grpc.ClientStream
}

type ContentAddressableStorage_GetTreeServer interface {
	Send(*GetTreeResponse) error
	grpc.ServerStream
}

type Digest struct {

	// The hash. In the case of SHA-256, it will always be a lowercase hex string
	// exactly 64 characters long.
	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"`
	// contains filtered or unexported fields
}

type DigestFunction struct {
	// contains filtered or unexported fields
}

type DigestFunction_Value int32

type Directory struct {

	// 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"`
	// contains filtered or unexported fields
}

type DirectoryNode struct {

	// 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"`
	// contains filtered or unexported fields
}

type ExecuteOperationMetadata struct {

	// 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 `` /* 135-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ExecuteRequest struct {

	// 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 `` /* 162-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ExecuteResponse struct {

	// 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 `` /* 179-byte string literal not displayed */
	// 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"`
	// contains filtered or unexported fields
}

type ExecutedActionMetadata struct {

	// 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 `` /* 135-byte string literal not displayed */
	// When the worker started fetching action inputs.
	InputFetchStartTimestamp *timestamppb.Timestamp `` /* 137-byte string literal not displayed */
	// When the worker finished fetching action inputs.
	InputFetchCompletedTimestamp *timestamppb.Timestamp `` /* 149-byte string literal not displayed */
	// When the worker started executing the action command.
	ExecutionStartTimestamp *timestamppb.Timestamp `` /* 132-byte string literal not displayed */
	// When the worker completed executing the action command.
	ExecutionCompletedTimestamp *timestamppb.Timestamp `` /* 144-byte string literal not displayed */
	// 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 `` /* 136-byte string literal not displayed */
	// When the worker started uploading action outputs.
	OutputUploadStartTimestamp *timestamppb.Timestamp `` /* 143-byte string literal not displayed */
	// When the worker finished uploading action outputs.
	OutputUploadCompletedTimestamp *timestamppb.Timestamp `` /* 156-byte string literal not displayed */
	// 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"`
	// contains filtered or unexported fields
}

type ExecutionCapabilities struct {

	// 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 `` /* 162-byte string literal not displayed */
	// 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 `` /* 150-byte string literal not displayed */
	// Supported node properties.
	SupportedNodeProperties []string `` /* 132-byte string literal not displayed */
	// 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 `` /* 172-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ExecutionClient interface {
	// Execute an action remotely.
	//
	// In order to execute an action, the client must first upload all of the
	// inputs, the
	// [Command][build.bazel.remote.execution.v2.Command] to run, and the
	// [Action][build.bazel.remote.execution.v2.Action] into the
	// [ContentAddressableStorage][build.bazel.remote.execution.v2.ContentAddressableStorage].
	// It then calls `Execute` with an `action_digest` referring to them. The
	// server will run the action and eventually return the result.
	//
	// The input `Action`'s fields MUST meet the various canonicalization
	// requirements specified in the documentation for their types so that it has
	// the same digest as other logically equivalent `Action`s. The server MAY
	// enforce the requirements and return errors if a non-canonical input is
	// received. It MAY also proceed without verifying some or all of the
	// requirements, such as for performance reasons. If the server does not
	// verify the requirement, then it will treat the `Action` as distinct from
	// another logically equivalent action if they hash differently.
	//
	// Returns a stream of
	// [google.longrunning.Operation][google.longrunning.Operation] messages
	// describing the resulting execution, with eventual `response`
	// [ExecuteResponse][build.bazel.remote.execution.v2.ExecuteResponse]. The
	// `metadata` on the operation is of type
	// [ExecuteOperationMetadata][build.bazel.remote.execution.v2.ExecuteOperationMetadata].
	//
	// If the client remains connected after the first response is returned after
	// the server, then updates are streamed as if the client had called
	// [WaitExecution][build.bazel.remote.execution.v2.Execution.WaitExecution]
	// until the execution completes or the request reaches an error. The
	// operation can also be queried using [Operations
	// API][google.longrunning.Operations.GetOperation].
	//
	// The server NEED NOT implement other methods or functionality of the
	// Operations API.
	//
	// Errors discovered during creation of the `Operation` will be reported
	// as gRPC Status errors, while errors that occurred while running the
	// action will be reported in the `status` field of the `ExecuteResponse`. The
	// server MUST NOT set the `error` field of the `Operation` proto.
	// The possible errors include:
	//
	//   - `INVALID_ARGUMENT`: One or more arguments are invalid.
	//   - `FAILED_PRECONDITION`: One or more errors occurred in setting up the
	//     action requested, such as a missing input or command or no worker being
	//     available. The client may be able to fix the errors and retry.
	//   - `RESOURCE_EXHAUSTED`: There is insufficient quota of some resource to run
	//     the action.
	//   - `UNAVAILABLE`: Due to a transient condition, such as all workers being
	//     occupied (and the server does not support a queue), the action could not
	//     be started. The client should retry.
	//   - `INTERNAL`: An internal error occurred in the execution engine or the
	//     worker.
	//   - `DEADLINE_EXCEEDED`: The execution timed out.
	//   - `CANCELLED`: The operation was cancelled by the client. This status is
	//     only possible if the server implements the Operations API CancelOperation
	//     method, and it was called for the current execution.
	//
	// In the case of a missing input or command, the server SHOULD additionally
	// send a [PreconditionFailure][google.rpc.PreconditionFailure] error detail
	// where, for each requested blob not present in the CAS, there is a
	// `Violation` with a `type` of `MISSING` and a `subject` of
	// `"blobs/{digest_function/}{hash}/{size}"` indicating the digest of the
	// missing blob. The `subject` is formatted the same way as the
	// `resource_name` provided to
	// [ByteStream.Read][google.bytestream.ByteStream.Read], with the leading
	// instance name omitted. `digest_function` MUST thus be omitted if its value
	// is one of MD5, MURMUR3, SHA1, SHA256, SHA384, SHA512, or VSO.
	//
	// The server does not need to guarantee that a call to this method leads to
	// at most one execution of the action. The server MAY execute the action
	// multiple times, potentially in parallel. These redundant executions MAY
	// continue to run, even if the operation is completed.
	Execute(ctx context.Context, in *ExecuteRequest, opts ...grpc.CallOption) (Execution_ExecuteClient, error)
	// Wait for an execution operation to complete. When the client initially
	// makes the request, the server immediately responds with the current status
	// of the execution. The server will leave the request stream open until the
	// operation completes, and then respond with the completed operation. The
	// server MAY choose to stream additional updates as execution progresses,
	// such as to provide an update as to the state of the execution.
	//
	// In addition to the cases describe for Execute, the WaitExecution method
	// may fail as follows:
	//
	//   - `NOT_FOUND`: The operation no longer exists due to any of a transient
	//     condition, an unknown operation name, or if the server implements the
	//     Operations API DeleteOperation method and it was called for the current
	//     execution. The client should call `Execute` to retry.
	WaitExecution(ctx context.Context, in *WaitExecutionRequest, opts ...grpc.CallOption) (Execution_WaitExecutionClient, error)
}

type ExecutionPolicy struct {

	// 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"`
	// contains filtered or unexported fields
}

type ExecutionServer interface {
	// Execute an action remotely.
	//
	// In order to execute an action, the client must first upload all of the
	// inputs, the
	// [Command][build.bazel.remote.execution.v2.Command] to run, and the
	// [Action][build.bazel.remote.execution.v2.Action] into the
	// [ContentAddressableStorage][build.bazel.remote.execution.v2.ContentAddressableStorage].
	// It then calls `Execute` with an `action_digest` referring to them. The
	// server will run the action and eventually return the result.
	//
	// The input `Action`'s fields MUST meet the various canonicalization
	// requirements specified in the documentation for their types so that it has
	// the same digest as other logically equivalent `Action`s. The server MAY
	// enforce the requirements and return errors if a non-canonical input is
	// received. It MAY also proceed without verifying some or all of the
	// requirements, such as for performance reasons. If the server does not
	// verify the requirement, then it will treat the `Action` as distinct from
	// another logically equivalent action if they hash differently.
	//
	// Returns a stream of
	// [google.longrunning.Operation][google.longrunning.Operation] messages
	// describing the resulting execution, with eventual `response`
	// [ExecuteResponse][build.bazel.remote.execution.v2.ExecuteResponse]. The
	// `metadata` on the operation is of type
	// [ExecuteOperationMetadata][build.bazel.remote.execution.v2.ExecuteOperationMetadata].
	//
	// If the client remains connected after the first response is returned after
	// the server, then updates are streamed as if the client had called
	// [WaitExecution][build.bazel.remote.execution.v2.Execution.WaitExecution]
	// until the execution completes or the request reaches an error. The
	// operation can also be queried using [Operations
	// API][google.longrunning.Operations.GetOperation].
	//
	// The server NEED NOT implement other methods or functionality of the
	// Operations API.
	//
	// Errors discovered during creation of the `Operation` will be reported
	// as gRPC Status errors, while errors that occurred while running the
	// action will be reported in the `status` field of the `ExecuteResponse`. The
	// server MUST NOT set the `error` field of the `Operation` proto.
	// The possible errors include:
	//
	//   - `INVALID_ARGUMENT`: One or more arguments are invalid.
	//   - `FAILED_PRECONDITION`: One or more errors occurred in setting up the
	//     action requested, such as a missing input or command or no worker being
	//     available. The client may be able to fix the errors and retry.
	//   - `RESOURCE_EXHAUSTED`: There is insufficient quota of some resource to run
	//     the action.
	//   - `UNAVAILABLE`: Due to a transient condition, such as all workers being
	//     occupied (and the server does not support a queue), the action could not
	//     be started. The client should retry.
	//   - `INTERNAL`: An internal error occurred in the execution engine or the
	//     worker.
	//   - `DEADLINE_EXCEEDED`: The execution timed out.
	//   - `CANCELLED`: The operation was cancelled by the client. This status is
	//     only possible if the server implements the Operations API CancelOperation
	//     method, and it was called for the current execution.
	//
	// In the case of a missing input or command, the server SHOULD additionally
	// send a [PreconditionFailure][google.rpc.PreconditionFailure] error detail
	// where, for each requested blob not present in the CAS, there is a
	// `Violation` with a `type` of `MISSING` and a `subject` of
	// `"blobs/{digest_function/}{hash}/{size}"` indicating the digest of the
	// missing blob. The `subject` is formatted the same way as the
	// `resource_name` provided to
	// [ByteStream.Read][google.bytestream.ByteStream.Read], with the leading
	// instance name omitted. `digest_function` MUST thus be omitted if its value
	// is one of MD5, MURMUR3, SHA1, SHA256, SHA384, SHA512, or VSO.
	//
	// The server does not need to guarantee that a call to this method leads to
	// at most one execution of the action. The server MAY execute the action
	// multiple times, potentially in parallel. These redundant executions MAY
	// continue to run, even if the operation is completed.
	Execute(*ExecuteRequest, Execution_ExecuteServer) error
	// Wait for an execution operation to complete. When the client initially
	// makes the request, the server immediately responds with the current status
	// of the execution. The server will leave the request stream open until the
	// operation completes, and then respond with the completed operation. The
	// server MAY choose to stream additional updates as execution progresses,
	// such as to provide an update as to the state of the execution.
	//
	// In addition to the cases describe for Execute, the WaitExecution method
	// may fail as follows:
	//
	//   - `NOT_FOUND`: The operation no longer exists due to any of a transient
	//     condition, an unknown operation name, or if the server implements the
	//     Operations API DeleteOperation method and it was called for the current
	//     execution. The client should call `Execute` to retry.
	WaitExecution(*WaitExecutionRequest, Execution_WaitExecutionServer) error
}

type ExecutionStage struct {
	// contains filtered or unexported fields
}

type ExecutionStage_Value int32

type Execution_ExecuteClient interface {
	Recv() (*longrunning.Operation, error)
	grpc.ClientStream
}

type Execution_ExecuteServer interface {
	Send(*longrunning.Operation) error
	grpc.ServerStream
}

type Execution_WaitExecutionClient interface {
	Recv() (*longrunning.Operation, error)
	grpc.ClientStream
}

type Execution_WaitExecutionServer interface {
	Send(*longrunning.Operation) error
	grpc.ServerStream
}

type FileNode struct {

	// 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"`
	// contains filtered or unexported fields
}

type FindMissingBlobsRequest struct {

	// 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 `` /* 162-byte string literal not displayed */
	// contains filtered or unexported fields
}

type FindMissingBlobsResponse struct {

	// 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"`
	// contains filtered or unexported fields
}

type GetActionResultRequest struct {

	// 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 `` /* 162-byte string literal not displayed */
	// contains filtered or unexported fields
}

type GetCapabilitiesRequest struct {

	// 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"`
	// contains filtered or unexported fields
}

type GetTreeRequest struct {

	// 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 `` /* 162-byte string literal not displayed */
	// contains filtered or unexported fields
}

type GetTreeResponse struct {

	// 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"`
	// contains filtered or unexported fields
}

type LogFile struct {

	// 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"`
	// contains filtered or unexported fields
}

type NodeProperties struct {

	// 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"`
	// contains filtered or unexported fields
}

type NodeProperty struct {

	// 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"`
	// contains filtered or unexported fields
}

type OutputDirectory struct {

	// 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 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 `` /* 127-byte string literal not displayed */
	// The digest of the encoded
	// [Directory][build.bazel.remote.execution.v2.Directory] proto
	// containing the contents 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"`
	// contains filtered or unexported fields
}

type OutputFile struct {

	// 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"`
	// contains filtered or unexported fields
}

type OutputSymlink struct {

	// 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"`
	// contains filtered or unexported fields
}

type Platform struct {

	// 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"`
	// contains filtered or unexported fields
}

type Platform_Property struct {

	// 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"`
	// contains filtered or unexported fields
}

type PriorityCapabilities struct {
	Priorities []*PriorityCapabilities_PriorityRange `protobuf:"bytes,1,rep,name=priorities,proto3" json:"priorities,omitempty"`
	// contains filtered or unexported fields
}

type PriorityCapabilities_PriorityRange struct {

	// 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"`
	// contains filtered or unexported fields
}

type RequestMetadata struct {

	// 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 `` /* 132-byte string literal not displayed */
	// 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"`
	// contains filtered or unexported fields
}