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

google-api-client 0.31.0 → 0.32.0

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.