google-api-client 0.31.0 → 0.32.0

data/generated/google/apis/remotebuildexecution_v1.rb

@@ -25,7 +25,7 @@ module Google
     # @see https://cloud.google.com/remote-build-execution/docs/
     module RemotebuildexecutionV1
       VERSION = 'V1'
-      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_v1/classes.rb

@@ -1596,12 +1596,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]
@@ -2008,938 +2008,23 @@ module Google
         # @return [String]
         attr_accessor :min_cpu_platform
       
-        # 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
-        # details.
-        # Corresponds to the JSON property `reserved`
-        # @return [Boolean]
-        attr_accessor :reserved
-        alias_method :reserved?, :reserved
-      
-        def initialize(**args)
-           update!(**args)
-        end
-      
-        # Update properties of this object
-        def update!(**args)
-          @accelerator = args[:accelerator] if args.key?(:accelerator)
-          @disk_size_gb = args[:disk_size_gb] if args.key?(:disk_size_gb)
-          @disk_type = args[:disk_type] if args.key?(:disk_type)
-          @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)
-          @reserved = args[:reserved] if args.key?(:reserved)
-        end
-      end
-      
-      # A worker pool resource in the Remote Build Execution API.
-      class GoogleDevtoolsRemotebuildexecutionAdminV1alphaWorkerPool
-        include Google::Apis::Core::Hashable
-      
-        # WorkerPool resource name formatted as:
-        # `projects/[PROJECT_ID]/instances/[INSTANCE_ID]/workerpools/[POOL_ID]`.
-        # name should not be populated when creating a worker pool since it is
-        # provided in the `poolId` field.
-        # Corresponds to the JSON property `name`
-        # @return [String]
-        attr_accessor :name
-      
-        # Output only. State of the worker pool.
-        # Corresponds to the JSON property `state`
-        # @return [String]
-        attr_accessor :state
-      
-        # Defines the configuration to be used for a creating workers in
-        # the worker pool.
-        # Corresponds to the JSON property `workerConfig`
-        # @return [Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemotebuildexecutionAdminV1alphaWorkerConfig]
-        attr_accessor :worker_config
-      
-        # The desired number of workers in the worker pool. Must be a value between
-        # 0 and 1000.
-        # Corresponds to the JSON property `workerCount`
-        # @return [Fixnum]
-        attr_accessor :worker_count
-      
-        def initialize(**args)
-           update!(**args)
-        end
-      
-        # Update properties of this object
-        def update!(**args)
-          @name = args[:name] if args.key?(:name)
-          @state = args[:state] if args.key?(:state)
-          @worker_config = args[:worker_config] if args.key?(:worker_config)
-          @worker_count = args[:worker_count] if args.key?(:worker_count)
-        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::RemotebuildexecutionV1::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::RemotebuildexecutionV1::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::RemotebuildexecutionV1::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::RemotebuildexecutionV1::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::RemotebuildexecutionV1::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::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDirectoryNode>]
-        attr_accessor :directories
-      
-        # The files in the directory.
-        # Corresponds to the JSON property `files`
-        # @return [Array<Google::Apis::RemotebuildexecutionV1::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::RemotebuildexecutionV1::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::RemotebuildexecutionV1::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::RemotebuildexecutionV1::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::RemotebuildexecutionV1::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::RemotebuildexecutionV1::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::RemotebuildexecutionV1::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::RemotebuildexecutionV1::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::RemotebuildexecutionV1::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::RemotebuildexecutionV1::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.
+        # 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 :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::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest]
-        attr_accessor :digest
+        attr_accessor :network_access
       
-        # True if file is executable, false otherwise.
-        # Corresponds to the JSON property `isExecutable`
+        # 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
+        # details.
+        # Corresponds to the JSON property `reserved`
         # @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::RemotebuildexecutionV1::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
+        attr_accessor :reserved
+        alias_method :reserved?, :reserved
       
         def initialize(**args)
            update!(**args)
@@ -2947,110 +2032,45 @@ module Google
       
         # 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)
+          @accelerator = args[:accelerator] if args.key?(:accelerator)
+          @disk_size_gb = args[:disk_size_gb] if args.key?(:disk_size_gb)
+          @disk_type = args[:disk_type] if args.key?(:disk_type)
+          @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
       
-      # Details for the tool used to call the API.
-      class GoogleDevtoolsRemoteexecutionV1testToolDetails
+      # A worker pool resource in the Remote Build Execution API.
+      class GoogleDevtoolsRemotebuildexecutionAdminV1alphaWorkerPool
         include Google::Apis::Core::Hashable
       
-        # Name of the tool, e.g. bazel.
-        # Corresponds to the JSON property `toolName`
+        # WorkerPool resource name formatted as:
+        # `projects/[PROJECT_ID]/instances/[INSTANCE_ID]/workerpools/[POOL_ID]`.
+        # name should not be populated when creating a worker pool since it is
+        # provided in the `poolId` field.
+        # Corresponds to the JSON property `name`
         # @return [String]
-        attr_accessor :tool_name
+        attr_accessor :name
       
-        # Version of the tool used for the request, e.g. 5.0.3.
-        # Corresponds to the JSON property `toolVersion`
+        # Output only. State of the worker pool.
+        # Corresponds to the JSON property `state`
         # @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
+        attr_accessor :state
       
-        # 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::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDirectory>]
-        attr_accessor :children
+        # Defines the configuration to be used for a creating workers in
+        # the worker pool.
+        # Corresponds to the JSON property `workerConfig`
+        # @return [Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemotebuildexecutionAdminV1alphaWorkerConfig]
+        attr_accessor :worker_config
       
-        # 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::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDirectory]
-        attr_accessor :root
+        # The desired number of workers in the worker pool. Must be a value between
+        # 0 and 1000.
+        # Corresponds to the JSON property `workerCount`
+        # @return [Fixnum]
+        attr_accessor :worker_count
       
         def initialize(**args)
            update!(**args)
@@ -3058,8 +2078,10 @@ module Google
       
         # Update properties of this object
         def update!(**args)
-          @children = args[:children] if args.key?(:children)
-          @root = args[:root] if args.key?(:root)
+          @name = args[:name] if args.key?(:name)
+          @state = args[:state] if args.key?(:state)
+          @worker_config = args[:worker_config] if args.key?(:worker_config)
+          @worker_count = args[:worker_count] if args.key?(:worker_count)
         end
       end
       
@@ -3782,79 +2804,6 @@ module Google
           @message = args[:message] if args.key?(:message)
         end
       end
-      
-      # A Change indicates the most recent state of an element.
-      class GoogleWatcherV1Change
-        include Google::Apis::Core::Hashable
-      
-        # If true, this Change is followed by more Changes that are in the same group
-        # as this Change.
-        # Corresponds to the JSON property `continued`
-        # @return [Boolean]
-        attr_accessor :continued
-        alias_method :continued?, :continued
-      
-        # The actual change data. This field is present only when `state() == EXISTS`
-        # or `state() == ERROR`. Please see google.protobuf.Any about how to use
-        # the Any type.
-        # Corresponds to the JSON property `data`
-        # @return [Hash<String,Object>]
-        attr_accessor :data
-      
-        # Name of the element, interpreted relative to the entity's actual
-        # name. "" refers to the entity itself. The element name is a valid
-        # UTF-8 string.
-        # Corresponds to the JSON property `element`
-        # @return [String]
-        attr_accessor :element
-      
-        # If present, provides a compact representation of all the messages that have
-        # been received by the caller for the given entity, e.g., it could be a
-        # sequence number or a multi-part timestamp/version vector. This marker can
-        # be provided in the Request message, allowing the caller to resume the
-        # stream watching at a specific point without fetching the initial state.
-        # Corresponds to the JSON property `resumeMarker`
-        # NOTE: Values are automatically base64 encoded/decoded in the client library.
-        # @return [String]
-        attr_accessor :resume_marker
-      
-        # The state of the `element`.
-        # Corresponds to the JSON property `state`
-        # @return [String]
-        attr_accessor :state
-      
-        def initialize(**args)
-           update!(**args)
-        end
-      
-        # Update properties of this object
-        def update!(**args)
-          @continued = args[:continued] if args.key?(:continued)
-          @data = args[:data] if args.key?(:data)
-          @element = args[:element] if args.key?(:element)
-          @resume_marker = args[:resume_marker] if args.key?(:resume_marker)
-          @state = args[:state] if args.key?(:state)
-        end
-      end
-      
-      # A batch of Change messages.
-      class GoogleWatcherV1ChangeBatch
-        include Google::Apis::Core::Hashable
-      
-        # A list of Change messages.
-        # Corresponds to the JSON property `changes`
-        # @return [Array<Google::Apis::RemotebuildexecutionV1::GoogleWatcherV1Change>]
-        attr_accessor :changes
-      
-        def initialize(**args)
-           update!(**args)
-        end
-      
-        # Update properties of this object
-        def update!(**args)
-          @changes = args[:changes] if args.key?(:changes)
-        end
-      end
     end
   end
 end