RubyGems - google-api-client - Versions diffs - 0.31.0 → 0.32.0 - Mend

google-api-client 0.31.0 → 0.32.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (295) hide show

data/generated/google/apis/remotebuildexecution_v1/representations.rb CHANGED

@@ -262,96 +262,6 @@ module Google
         include Google::Apis::Core::JsonObjectSupport
       end
-      class GoogleDevtoolsRemoteexecutionV1testActionResult
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
-      class GoogleDevtoolsRemoteexecutionV1testCommand
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
-      class GoogleDevtoolsRemoteexecutionV1testCommandEnvironmentVariable
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
-      class GoogleDevtoolsRemoteexecutionV1testDigest
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
-      class GoogleDevtoolsRemoteexecutionV1testDirectory
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
-      class GoogleDevtoolsRemoteexecutionV1testDirectoryNode
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
-      class GoogleDevtoolsRemoteexecutionV1testExecuteOperationMetadata
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
-      class GoogleDevtoolsRemoteexecutionV1testExecuteResponse
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
-      class GoogleDevtoolsRemoteexecutionV1testFileNode
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
-      class GoogleDevtoolsRemoteexecutionV1testLogFile
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
-      class GoogleDevtoolsRemoteexecutionV1testOutputDirectory
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
-      class GoogleDevtoolsRemoteexecutionV1testOutputFile
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
-      class GoogleDevtoolsRemoteexecutionV1testRequestMetadata
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
-      class GoogleDevtoolsRemoteexecutionV1testToolDetails
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
-      class GoogleDevtoolsRemoteexecutionV1testTree
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
       class GoogleDevtoolsRemoteworkersV1test2AdminTemp
         class Representation < Google::Apis::Core::JsonRepresentation; end
@@ -466,18 +376,6 @@ module Google
         include Google::Apis::Core::JsonObjectSupport
       end
-      class GoogleWatcherV1Change
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
-      class GoogleWatcherV1ChangeBatch
-        class Representation < Google::Apis::Core::JsonRepresentation; end
-        include Google::Apis::Core::JsonObjectSupport
-      end
       class BuildBazelRemoteExecutionV2Action
         # @private
         class Representation < Google::Apis::Core::JsonRepresentation
@@ -859,6 +757,7 @@ module Google
           hash :labels, as: 'labels'
           property :machine_type, as: 'machineType'
           property :min_cpu_platform, as: 'minCpuPlatform'
+          property :network_access, as: 'networkAccess'
           property :reserved, as: 'reserved'
         end
       end
@@ -874,161 +773,6 @@ module Google
         end
       end
-      class GoogleDevtoolsRemoteexecutionV1testActionResult
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          property :exit_code, as: 'exitCode'
-          collection :output_directories, as: 'outputDirectories', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testOutputDirectory, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testOutputDirectory::Representation
-          collection :output_files, as: 'outputFiles', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testOutputFile, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testOutputFile::Representation
-          property :stderr_digest, as: 'stderrDigest', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest::Representation
-          property :stderr_raw, :base64 => true, as: 'stderrRaw'
-          property :stdout_digest, as: 'stdoutDigest', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest::Representation
-          property :stdout_raw, :base64 => true, as: 'stdoutRaw'
-        end
-      end
-      class GoogleDevtoolsRemoteexecutionV1testCommand
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          collection :arguments, as: 'arguments'
-          collection :environment_variables, as: 'environmentVariables', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testCommandEnvironmentVariable, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testCommandEnvironmentVariable::Representation
-        end
-      end
-      class GoogleDevtoolsRemoteexecutionV1testCommandEnvironmentVariable
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          property :name, as: 'name'
-          property :value, as: 'value'
-        end
-      end
-      class GoogleDevtoolsRemoteexecutionV1testDigest
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          property :hash_prop, as: 'hash'
-          property :size_bytes, :numeric_string => true, as: 'sizeBytes'
-        end
-      end
-      class GoogleDevtoolsRemoteexecutionV1testDirectory
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          collection :directories, as: 'directories', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDirectoryNode, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDirectoryNode::Representation
-          collection :files, as: 'files', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testFileNode, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testFileNode::Representation
-        end
-      end
-      class GoogleDevtoolsRemoteexecutionV1testDirectoryNode
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          property :digest, as: 'digest', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest::Representation
-          property :name, as: 'name'
-        end
-      end
-      class GoogleDevtoolsRemoteexecutionV1testExecuteOperationMetadata
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          property :action_digest, as: 'actionDigest', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest::Representation
-          property :stage, as: 'stage'
-          property :stderr_stream_name, as: 'stderrStreamName'
-          property :stdout_stream_name, as: 'stdoutStreamName'
-        end
-      end
-      class GoogleDevtoolsRemoteexecutionV1testExecuteResponse
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          property :cached_result, as: 'cachedResult'
-          property :result, as: 'result', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testActionResult, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testActionResult::Representation
-          hash :server_logs, as: 'serverLogs', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testLogFile, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testLogFile::Representation
-          property :status, as: 'status', class: Google::Apis::RemotebuildexecutionV1::GoogleRpcStatus, decorator: Google::Apis::RemotebuildexecutionV1::GoogleRpcStatus::Representation
-        end
-      end
-      class GoogleDevtoolsRemoteexecutionV1testFileNode
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          property :digest, as: 'digest', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest::Representation
-          property :is_executable, as: 'isExecutable'
-          property :name, as: 'name'
-        end
-      end
-      class GoogleDevtoolsRemoteexecutionV1testLogFile
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          property :digest, as: 'digest', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest::Representation
-          property :human_readable, as: 'humanReadable'
-        end
-      end
-      class GoogleDevtoolsRemoteexecutionV1testOutputDirectory
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          property :digest, as: 'digest', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest::Representation
-          property :path, as: 'path'
-          property :tree_digest, as: 'treeDigest', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest::Representation
-        end
-      end
-      class GoogleDevtoolsRemoteexecutionV1testOutputFile
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          property :content, :base64 => true, as: 'content'
-          property :digest, as: 'digest', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest::Representation
-          property :is_executable, as: 'isExecutable'
-          property :path, as: 'path'
-        end
-      end
-      class GoogleDevtoolsRemoteexecutionV1testRequestMetadata
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          property :action_id, as: 'actionId'
-          property :correlated_invocations_id, as: 'correlatedInvocationsId'
-          property :tool_details, as: 'toolDetails', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testToolDetails, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testToolDetails::Representation
-          property :tool_invocation_id, as: 'toolInvocationId'
-        end
-      end
-      class GoogleDevtoolsRemoteexecutionV1testToolDetails
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          property :tool_name, as: 'toolName'
-          property :tool_version, as: 'toolVersion'
-        end
-      end
-      class GoogleDevtoolsRemoteexecutionV1testTree
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          collection :children, as: 'children', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDirectory, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDirectory::Representation
-          property :root, as: 'root', class: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDirectory, decorator: Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDirectory::Representation
-        end
-      end
       class GoogleDevtoolsRemoteworkersV1test2AdminTemp
         # @private
         class Representation < Google::Apis::Core::JsonRepresentation
@@ -1209,25 +953,6 @@ module Google
           property :message, as: 'message'
         end
       end
-      class GoogleWatcherV1Change
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          property :continued, as: 'continued'
-          hash :data, as: 'data'
-          property :element, as: 'element'
-          property :resume_marker, :base64 => true, as: 'resumeMarker'
-          property :state, as: 'state'
-        end
-      end
-      class GoogleWatcherV1ChangeBatch
-        # @private
-        class Representation < Google::Apis::Core::JsonRepresentation
-          collection :changes, as: 'changes', class: Google::Apis::RemotebuildexecutionV1::GoogleWatcherV1Change, decorator: Google::Apis::RemotebuildexecutionV1::GoogleWatcherV1Change::Representation
-        end
-      end
     end
   end
 end

data/generated/google/apis/remotebuildexecution_v1/service.rb CHANGED

@@ -284,83 +284,6 @@ module Google
           command.query['quotaUser'] = quota_user unless quota_user.nil?
           execute_or_queue_command(command, &block)
         end
-        # Start a streaming RPC to get watch information from the server.
-        # @param [String] resume_marker
-        #   The `resume_marker` specifies how much of the existing underlying state is
-        #   delivered to the client when the watch request is received by the
-        #   system. The client can set this marker in one of the following ways to get
-        #   different semantics:
-        #   *   Parameter is not specified or has the value "".
-        #   Semantics: Fetch initial state.
-        #   The client wants the entity's initial state to be delivered. See the
-        #   description in "Initial State".
-        #   *   Parameter is set to the string "now" (UTF-8 encoding).
-        #   Semantics: Fetch new changes only.
-        #   The client just wants to get the changes received by the system after
-        #   the watch point. The system may deliver changes from before the watch
-        #   point as well.
-        #   *   Parameter is set to a value received in an earlier
-        #   `Change.resume_marker` field while watching the same entity.
-        #   Semantics: Resume from a specific point.
-        #   The client wants to receive the changes from a specific point; this
-        #   value must correspond to a value received in the `Change.resume_marker`
-        #   field. The system may deliver changes from before the `resume_marker`
-        #   as well. If the system cannot resume the stream from this point (e.g.,
-        #   if it is too far behind in the stream), it can raise the
-        #   `FAILED_PRECONDITION` error.
-        #   An implementation MUST support an unspecified parameter and the
-        #   empty string "" marker (initial state fetching) and the "now" marker.
-        #   It need not support resuming from a specific point.
-        # @param [String] target
-        #   The `target` value **must** be a valid URL path pointing to an entity
-        #   to watch. Note that the service name **must** be
-        #   removed from the target field (e.g., the target field must say
-        #   "/foo/bar", not "myservice.googleapis.com/foo/bar"). A client is
-        #   also allowed to pass system-specific parameters in the URL that
-        #   are only obeyed by some implementations. Some parameters will be
-        #   implementation-specific. However, some have predefined meaning
-        #   and are listed here:
-        #   * recursive = true|false [default=false]
-        #   If set to true, indicates that the client wants to watch all elements
-        #   of entities in the subtree rooted at the entity's name in `target`. For
-        #   descendants that are not the immediate children of the target, the
-        #   `Change.element` will contain slashes.
-        #   Note that some namespaces and entities will not support recursive
-        #   watching. When watching such an entity, a client must not set recursive
-        #   to true. Otherwise, it will receive an `UNIMPLEMENTED` error.
-        #   Normal URL encoding must be used inside `target`.  For example, if a query
-        #   parameter name or value, or the non-query parameter portion of `target`
-        #   contains a special character, it must be %-encoded.  We recommend that
-        #   clients and servers use their runtime's URL library to produce and consume
-        #   target values.
-        # @param [String] fields
-        #   Selector specifying which fields to include in a partial response.
-        # @param [String] quota_user
-        #   Available to use for quota purposes for server-side applications. Can be any
-        #   arbitrary string assigned to a user, but should not exceed 40 characters.
-        # @param [Google::Apis::RequestOptions] options
-        #   Request-specific options
-        #
-        # @yield [result, err] Result & error if block supplied
-        # @yieldparam result [Google::Apis::RemotebuildexecutionV1::GoogleWatcherV1ChangeBatch] parsed result object
-        # @yieldparam err [StandardError] error object if request failed
-        #
-        # @return [Google::Apis::RemotebuildexecutionV1::GoogleWatcherV1ChangeBatch]
-        #
-        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
-        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
-        # @raise [Google::Apis::AuthorizationError] Authorization is required
-        def watch(resume_marker: nil, target: nil, fields: nil, quota_user: nil, options: nil, &block)
-          command = make_simple_command(:get, 'v1:watch', options)
-          command.response_representation = Google::Apis::RemotebuildexecutionV1::GoogleWatcherV1ChangeBatch::Representation
-          command.response_class = Google::Apis::RemotebuildexecutionV1::GoogleWatcherV1ChangeBatch
-          command.query['resumeMarker'] = resume_marker unless resume_marker.nil?
-          command.query['target'] = target unless target.nil?
-          command.query['fields'] = fields unless fields.nil?
-          command.query['quotaUser'] = quota_user unless quota_user.nil?
-          execute_or_queue_command(command, &block)
-        end
         protected

data/generated/google/apis/remotebuildexecution_v1alpha.rb CHANGED

@@ -25,7 +25,7 @@ module Google
     # @see https://cloud.google.com/remote-build-execution/docs/
     module RemotebuildexecutionV1alpha
       VERSION = 'V1alpha'
-      REVISION = '20190731'
+      REVISION = '20190924'
       # View and manage your data across Google Cloud Platform services
       AUTH_CLOUD_PLATFORM = 'https://www.googleapis.com/auth/cloud-platform'

data/generated/google/apis/remotebuildexecution_v1alpha/classes.rb CHANGED

@@ -1577,12 +1577,12 @@ module Google
       class GoogleDevtoolsRemotebuildexecutionAdminV1alphaAcceleratorConfig
         include Google::Apis::Core::Hashable
-        # The number of the guest accelerator cards exposed to this VM.
+        # The number of guest accelerator cards exposed to each VM.
         # Corresponds to the JSON property `acceleratorCount`
         # @return [Fixnum]
         attr_accessor :accelerator_count
-        # The type of accelerator to attach to this VM, e.g. "nvidia-tesla-k80" for
+        # The type of accelerator to attach to each VM, e.g. "nvidia-tesla-k80" for
         # nVidia Tesla K80.
         # Corresponds to the JSON property `acceleratorType`
         # @return [String]
@@ -1989,6 +1989,15 @@ module Google
         # @return [String]
         attr_accessor :min_cpu_platform
+        # Determines the type of network access granted to workers. Possible values:
+        # - "public": Workers can connect to the public internet.
+        # - "private": Workers can only connect to Google APIs and services.
+        # - "restricted-private": Workers can only connect to Google APIs that are
+        # reachable through `restricted.googleapis.com` (`199.36.153.4/30`).
+        # Corresponds to the JSON property `networkAccess`
+        # @return [String]
+        attr_accessor :network_access
         # Determines whether the worker is reserved (equivalent to a Compute Engine
         # on-demand VM and therefore won't be preempted).
         # See [Preemptible VMs](https://cloud.google.com/preemptible-vms/) for more
@@ -2010,6 +2019,7 @@ module Google
           @labels = args[:labels] if args.key?(:labels)
           @machine_type = args[:machine_type] if args.key?(:machine_type)
           @min_cpu_platform = args[:min_cpu_platform] if args.key?(:min_cpu_platform)
+          @network_access = args[:network_access] if args.key?(:network_access)
           @reserved = args[:reserved] if args.key?(:reserved)
         end
       end
@@ -2056,994 +2066,6 @@ module Google
         end
       end
-      # An ActionResult represents the result of an
-      # Action being run.
-      class GoogleDevtoolsRemoteexecutionV1testActionResult
-        include Google::Apis::Core::Hashable
-        # The exit code of the command.
-        # Corresponds to the JSON property `exitCode`
-        # @return [Fixnum]
-        attr_accessor :exit_code
-        # The output directories of the action. For each output directory requested
-        # in the `output_directories` 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 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
-        # `
-        # ]
-        # `
-        # `
-        # ```
-        # Corresponds to the JSON property `outputDirectories`
-        # @return [Array<Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testOutputDirectory>]
-        attr_accessor :output_directories
-        # The output files of the action. For each output file requested in the
-        # `output_files` field of the Action, if the corresponding file existed after
-        # the action completed, a single entry will be present in the output list.
-        # If the action does not produce the requested output, or produces a
-        # directory where a regular file is expected or vice versa, 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.
-        # Corresponds to the JSON property `outputFiles`
-        # @return [Array<Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testOutputFile>]
-        attr_accessor :output_files
-        # 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, but servers
-        # SHOULD use SHA-256.
-        # 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.
-        # Corresponds to the JSON property `stderrDigest`
-        # @return [Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testDigest]
-        attr_accessor :stderr_digest
-        # The standard error buffer of the action. The server will determine, based
-        # on the size of the buffer, whether to return it in raw form or to return
-        # a digest in `stderr_digest` that points to the buffer. If neither is set,
-        # then the buffer is empty. The client SHOULD NOT assume it will get one of
-        # the raw buffer or a digest on any given request and should be prepared to
-        # handle either.
-        # Corresponds to the JSON property `stderrRaw`
-        # NOTE: Values are automatically base64 encoded/decoded in the client library.
-        # @return [String]
-        attr_accessor :stderr_raw
-        # 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, but servers
-        # SHOULD use SHA-256.
-        # 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.
-        # Corresponds to the JSON property `stdoutDigest`
-        # @return [Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testDigest]
-        attr_accessor :stdout_digest
-        # The standard output buffer of the action. The server will determine, based
-        # on the size of the buffer, whether to return it in raw form or to return
-        # a digest in `stdout_digest` that points to the buffer. If neither is set,
-        # then the buffer is empty. The client SHOULD NOT assume it will get one of
-        # the raw buffer or a digest on any given request and should be prepared to
-        # handle either.
-        # Corresponds to the JSON property `stdoutRaw`
-        # NOTE: Values are automatically base64 encoded/decoded in the client library.
-        # @return [String]
-        attr_accessor :stdout_raw
-        def initialize(**args)
-           update!(**args)
-        end
-        # Update properties of this object
-        def update!(**args)
-          @exit_code = args[:exit_code] if args.key?(:exit_code)
-          @output_directories = args[:output_directories] if args.key?(:output_directories)
-          @output_files = args[:output_files] if args.key?(:output_files)
-          @stderr_digest = args[:stderr_digest] if args.key?(:stderr_digest)
-          @stderr_raw = args[:stderr_raw] if args.key?(:stderr_raw)
-          @stdout_digest = args[:stdout_digest] if args.key?(:stdout_digest)
-          @stdout_raw = args[:stdout_raw] if args.key?(:stdout_raw)
-        end
-      end
-      # A `Command` is the actual command executed by a worker running an
-      # Action.
-      # 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.
-      class GoogleDevtoolsRemoteexecutionV1testCommand
-        include Google::Apis::Core::Hashable
-        # The arguments to the command. The first argument must be the path to the
-        # executable, which must be either a relative path, in which case it is
-        # evaluated with respect to the input root, or an absolute path.
-        # The working directory will always be the input root.
-        # Corresponds to the JSON property `arguments`
-        # @return [Array<String>]
-        attr_accessor :arguments
-        # 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`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.
-        # Corresponds to the JSON property `environmentVariables`
-        # @return [Array<Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testCommandEnvironmentVariable>]
-        attr_accessor :environment_variables
-        def initialize(**args)
-           update!(**args)
-        end
-        # Update properties of this object
-        def update!(**args)
-          @arguments = args[:arguments] if args.key?(:arguments)
-          @environment_variables = args[:environment_variables] if args.key?(:environment_variables)
-        end
-      end
-      # An `EnvironmentVariable` is one variable to set in the running program's
-      # environment.
-      class GoogleDevtoolsRemoteexecutionV1testCommandEnvironmentVariable
-        include Google::Apis::Core::Hashable
-        # The variable name.
-        # Corresponds to the JSON property `name`
-        # @return [String]
-        attr_accessor :name
-        # The variable value.
-        # Corresponds to the JSON property `value`
-        # @return [String]
-        attr_accessor :value
-        def initialize(**args)
-           update!(**args)
-        end
-        # Update properties of this object
-        def update!(**args)
-          @name = args[:name] if args.key?(:name)
-          @value = args[:value] if args.key?(:value)
-        end
-      end
-      # 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, but servers
-      # SHOULD use SHA-256.
-      # 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.
-      class GoogleDevtoolsRemoteexecutionV1testDigest
-        include Google::Apis::Core::Hashable
-        # The hash. In the case of SHA-256, it will always be a lowercase hex string
-        # exactly 64 characters long.
-        # Corresponds to the JSON property `hash`
-        # @return [String]
-        attr_accessor :hash_prop
-        # The size of the blob, in bytes.
-        # Corresponds to the JSON property `sizeBytes`
-        # @return [Fixnum]
-        attr_accessor :size_bytes
-        def initialize(**args)
-           update!(**args)
-        end
-        # Update properties of this object
-        def update!(**args)
-          @hash_prop = args[:hash_prop] if args.key?(:hash_prop)
-          @size_bytes = args[:size_bytes] if args.key?(:size_bytes)
-        end
-      end
-      # A `Directory` represents a directory node in a file tree, containing zero or
-      # more children FileNodes
-      # and DirectoryNodes.
-      # Each `Node` contains its name in the directory, the digest of its content
-      # (either a file blob or a `Directory` proto), 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
-      # 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).
-      # - The files and directories 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.
-      # 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
-      # `
-      # `
-      # ],
-      # 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
-      # `
-      # ]
-      # `
-      # ```
-      class GoogleDevtoolsRemoteexecutionV1testDirectory
-        include Google::Apis::Core::Hashable
-        # The subdirectories in the directory.
-        # Corresponds to the JSON property `directories`
-        # @return [Array<Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testDirectoryNode>]
-        attr_accessor :directories
-        # The files in the directory.
-        # Corresponds to the JSON property `files`
-        # @return [Array<Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testFileNode>]
-        attr_accessor :files
-        def initialize(**args)
-           update!(**args)
-        end
-        # Update properties of this object
-        def update!(**args)
-          @directories = args[:directories] if args.key?(:directories)
-          @files = args[:files] if args.key?(:files)
-        end
-      end
-      # A `DirectoryNode` represents a child of a
-      # Directory which is itself
-      # a `Directory` and its associated metadata.
-      class GoogleDevtoolsRemoteexecutionV1testDirectoryNode
-        include Google::Apis::Core::Hashable
-        # 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, but servers
-        # SHOULD use SHA-256.
-        # 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.
-        # Corresponds to the JSON property `digest`
-        # @return [Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testDigest]
-        attr_accessor :digest
-        # The name of the directory.
-        # Corresponds to the JSON property `name`
-        # @return [String]
-        attr_accessor :name
-        def initialize(**args)
-           update!(**args)
-        end
-        # Update properties of this object
-        def update!(**args)
-          @digest = args[:digest] if args.key?(:digest)
-          @name = args[:name] if args.key?(:name)
-        end
-      end
-      # Metadata about an ongoing
-      # execution, which
-      # will be contained in the metadata
-      # field of the
-      # Operation.
-      class GoogleDevtoolsRemoteexecutionV1testExecuteOperationMetadata
-        include Google::Apis::Core::Hashable
-        # 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, but servers
-        # SHOULD use SHA-256.
-        # 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.
-        # Corresponds to the JSON property `actionDigest`
-        # @return [Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testDigest]
-        attr_accessor :action_digest
-        #
-        # Corresponds to the JSON property `stage`
-        # @return [String]
-        attr_accessor :stage
-        # If set, the client can use this name with
-        # ByteStream.Read to stream the
-        # standard error.
-        # Corresponds to the JSON property `stderrStreamName`
-        # @return [String]
-        attr_accessor :stderr_stream_name
-        # If set, the client can use this name with
-        # ByteStream.Read to stream the
-        # standard output.
-        # Corresponds to the JSON property `stdoutStreamName`
-        # @return [String]
-        attr_accessor :stdout_stream_name
-        def initialize(**args)
-           update!(**args)
-        end
-        # Update properties of this object
-        def update!(**args)
-          @action_digest = args[:action_digest] if args.key?(:action_digest)
-          @stage = args[:stage] if args.key?(:stage)
-          @stderr_stream_name = args[:stderr_stream_name] if args.key?(:stderr_stream_name)
-          @stdout_stream_name = args[:stdout_stream_name] if args.key?(:stdout_stream_name)
-        end
-      end
-      # The response message for
-      # Execution.Execute,
-      # which will be contained in the response
-      # field of the
-      # Operation.
-      class GoogleDevtoolsRemoteexecutionV1testExecuteResponse
-        include Google::Apis::Core::Hashable
-        # True if the result was served from cache, false if it was executed.
-        # Corresponds to the JSON property `cachedResult`
-        # @return [Boolean]
-        attr_accessor :cached_result
-        alias_method :cached_result?, :cached_result
-        # An ActionResult represents the result of an
-        # Action being run.
-        # Corresponds to the JSON property `result`
-        # @return [Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testActionResult]
-        attr_accessor :result
-        # 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.
-        # Corresponds to the JSON property `serverLogs`
-        # @return [Hash<String,Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testLogFile>]
-        attr_accessor :server_logs
-        # The `Status` type defines a logical error model that is suitable for
-        # different programming environments, including REST APIs and RPC APIs. It is
-        # used by [gRPC](https://github.com/grpc). Each `Status` message contains
-        # three pieces of data: error code, error message, and error details.
-        # You can find out more about this error model and how to work with it in the
-        # [API Design Guide](https://cloud.google.com/apis/design/errors).
-        # Corresponds to the JSON property `status`
-        # @return [Google::Apis::RemotebuildexecutionV1alpha::GoogleRpcStatus]
-        attr_accessor :status
-        def initialize(**args)
-           update!(**args)
-        end
-        # Update properties of this object
-        def update!(**args)
-          @cached_result = args[:cached_result] if args.key?(:cached_result)
-          @result = args[:result] if args.key?(:result)
-          @server_logs = args[:server_logs] if args.key?(:server_logs)
-          @status = args[:status] if args.key?(:status)
-        end
-      end
-      # A `FileNode` represents a single file and associated metadata.
-      class GoogleDevtoolsRemoteexecutionV1testFileNode
-        include Google::Apis::Core::Hashable
-        # 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, but servers
-        # SHOULD use SHA-256.
-        # 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.
-        # Corresponds to the JSON property `digest`
-        # @return [Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testDigest]
-        attr_accessor :digest
-        # True if file is executable, false otherwise.
-        # Corresponds to the JSON property `isExecutable`
-        # @return [Boolean]
-        attr_accessor :is_executable
-        alias_method :is_executable?, :is_executable
-        # The name of the file.
-        # Corresponds to the JSON property `name`
-        # @return [String]
-        attr_accessor :name
-        def initialize(**args)
-           update!(**args)
-        end
-        # Update properties of this object
-        def update!(**args)
-          @digest = args[:digest] if args.key?(:digest)
-          @is_executable = args[:is_executable] if args.key?(:is_executable)
-          @name = args[:name] if args.key?(:name)
-        end
-      end
-      # A `LogFile` is a log stored in the CAS.
-      class GoogleDevtoolsRemoteexecutionV1testLogFile
-        include Google::Apis::Core::Hashable
-        # 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, but servers
-        # SHOULD use SHA-256.
-        # 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.
-        # Corresponds to the JSON property `digest`
-        # @return [Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testDigest]
-        attr_accessor :digest
-        # 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.
-        # Corresponds to the JSON property `humanReadable`
-        # @return [Boolean]
-        attr_accessor :human_readable
-        alias_method :human_readable?, :human_readable
-        def initialize(**args)
-           update!(**args)
-        end
-        # Update properties of this object
-        def update!(**args)
-          @digest = args[:digest] if args.key?(:digest)
-          @human_readable = args[:human_readable] if args.key?(:human_readable)
-        end
-      end
-      # An `OutputDirectory` is the output in an `ActionResult` corresponding to a
-      # directory's full contents rather than a single file.
-      class GoogleDevtoolsRemoteexecutionV1testOutputDirectory
-        include Google::Apis::Core::Hashable
-        # 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, but servers
-        # SHOULD use SHA-256.
-        # 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.
-        # Corresponds to the JSON property `digest`
-        # @return [Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testDigest]
-        attr_accessor :digest
-        # 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.
-        # Corresponds to the JSON property `path`
-        # @return [String]
-        attr_accessor :path
-        # 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, but servers
-        # SHOULD use SHA-256.
-        # 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.
-        # Corresponds to the JSON property `treeDigest`
-        # @return [Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testDigest]
-        attr_accessor :tree_digest
-        def initialize(**args)
-           update!(**args)
-        end
-        # Update properties of this object
-        def update!(**args)
-          @digest = args[:digest] if args.key?(:digest)
-          @path = args[:path] if args.key?(:path)
-          @tree_digest = args[:tree_digest] if args.key?(:tree_digest)
-        end
-      end
-      # An `OutputFile` is similar to a
-      # FileNode, but it is
-      # tailored for output as part of an `ActionResult`. It allows a full file path
-      # rather than only a name, and allows the server to include content inline.
-      # `OutputFile` is binary-compatible with `FileNode`.
-      class GoogleDevtoolsRemoteexecutionV1testOutputFile
-        include Google::Apis::Core::Hashable
-        # The raw content of the file.
-        # This field may be used by the server to provide the content of a file
-        # inline in an
-        # ActionResult and
-        # avoid requiring that the client make a separate call to
-        # [ContentAddressableStorage.GetBlob] to retrieve it.
-        # The client SHOULD NOT assume that it will get raw content with any request,
-        # and always be prepared to retrieve it via `digest`.
-        # Corresponds to the JSON property `content`
-        # NOTE: Values are automatically base64 encoded/decoded in the client library.
-        # @return [String]
-        attr_accessor :content
-        # 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, but servers
-        # SHOULD use SHA-256.
-        # 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.
-        # Corresponds to the JSON property `digest`
-        # @return [Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testDigest]
-        attr_accessor :digest
-        # True if file is executable, false otherwise.
-        # Corresponds to the JSON property `isExecutable`
-        # @return [Boolean]
-        attr_accessor :is_executable
-        alias_method :is_executable?, :is_executable
-        # The full path of the file relative to the input root, 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.
-        # Corresponds to the JSON property `path`
-        # @return [String]
-        attr_accessor :path
-        def initialize(**args)
-           update!(**args)
-        end
-        # Update properties of this object
-        def update!(**args)
-          @content = args[:content] if args.key?(:content)
-          @digest = args[:digest] if args.key?(:digest)
-          @is_executable = args[:is_executable] if args.key?(:is_executable)
-          @path = args[:path] if args.key?(:path)
-        end
-      end
-      # 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: google.devtools.remoteexecution.v1test.requestmetadata-bin
-      # contents: the base64 encoded binary RequestMetadata message.
-      class GoogleDevtoolsRemoteexecutionV1testRequestMetadata
-        include Google::Apis::Core::Hashable
-        # 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.
-        # Corresponds to the JSON property `actionId`
-        # @return [String]
-        attr_accessor :action_id
-        # 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.
-        # Corresponds to the JSON property `correlatedInvocationsId`
-        # @return [String]
-        attr_accessor :correlated_invocations_id
-        # Details for the tool used to call the API.
-        # Corresponds to the JSON property `toolDetails`
-        # @return [Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testToolDetails]
-        attr_accessor :tool_details
-        # An identifier that ties multiple actions together to a final result.
-        # For example, multiple actions are required to build and run foo_test.
-        # Corresponds to the JSON property `toolInvocationId`
-        # @return [String]
-        attr_accessor :tool_invocation_id
-        def initialize(**args)
-           update!(**args)
-        end
-        # Update properties of this object
-        def update!(**args)
-          @action_id = args[:action_id] if args.key?(:action_id)
-          @correlated_invocations_id = args[:correlated_invocations_id] if args.key?(:correlated_invocations_id)
-          @tool_details = args[:tool_details] if args.key?(:tool_details)
-          @tool_invocation_id = args[:tool_invocation_id] if args.key?(:tool_invocation_id)
-        end
-      end
-      # Details for the tool used to call the API.
-      class GoogleDevtoolsRemoteexecutionV1testToolDetails
-        include Google::Apis::Core::Hashable
-        # Name of the tool, e.g. bazel.
-        # Corresponds to the JSON property `toolName`
-        # @return [String]
-        attr_accessor :tool_name
-        # Version of the tool used for the request, e.g. 5.0.3.
-        # Corresponds to the JSON property `toolVersion`
-        # @return [String]
-        attr_accessor :tool_version
-        def initialize(**args)
-           update!(**args)
-        end
-        # Update properties of this object
-        def update!(**args)
-          @tool_name = args[:tool_name] if args.key?(:tool_name)
-          @tool_version = args[:tool_version] if args.key?(:tool_version)
-        end
-      end
-      # A `Tree` contains all the
-      # Directory protos in a
-      # single directory Merkle tree, compressed into one message.
-      class GoogleDevtoolsRemoteexecutionV1testTree
-        include Google::Apis::Core::Hashable
-        # 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`.
-        # Corresponds to the JSON property `children`
-        # @return [Array<Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testDirectory>]
-        attr_accessor :children
-        # A `Directory` represents a directory node in a file tree, containing zero or
-        # more children FileNodes
-        # and DirectoryNodes.
-        # Each `Node` contains its name in the directory, the digest of its content
-        # (either a file blob or a `Directory` proto), 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
-        # 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).
-        # - The files and directories 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.
-        # 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
-        # `
-        # `
-        # ],
-        # 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
-        # `
-        # ]
-        # `
-        # ```
-        # Corresponds to the JSON property `root`
-        # @return [Google::Apis::RemotebuildexecutionV1alpha::GoogleDevtoolsRemoteexecutionV1testDirectory]
-        attr_accessor :root
-        def initialize(**args)
-           update!(**args)
-        end
-        # Update properties of this object
-        def update!(**args)
-          @children = args[:children] if args.key?(:children)
-          @root = args[:root] if args.key?(:root)
-        end
-      end
       # AdminTemp is a prelimiary set of administration tasks. It's called "Temp"
       # because we do not yet know the best way to represent admin tasks; it's
       # possible that this will be entirely replaced in later versions of this API.