chore: Update discovery artifacts (#1291)
* chore: update docs/dyn/index.md
* chore(abusiveexperiencereport): update the api
* chore(acceleratedmobilepageurl): update the api
* chore(accessapproval): update the api
* chore(accesscontextmanager): update the api
* chore(adexchangebuyer2): update the api
* chore(adexperiencereport): update the api
* chore(admob): update the api
* chore(analytics): update the api
* chore(analyticsreporting): update the api
* chore(androiddeviceprovisioning): update the api
* chore(androidenterprise): update the api
* chore(androidpublisher): update the api
* chore(apigateway): update the api
* chore(artifactregistry): update the api
* chore(bigqueryconnection): update the api
* chore(bigquerydatatransfer): update the api
* chore(billingbudgets): update the api
* chore(binaryauthorization): update the api
* chore(blogger): update the api
* chore(books): update the api
* chore(calendar): update the api
* chore(chat): update the api
* chore(chromeuxreport): update the api
* chore(civicinfo): update the api
* chore(classroom): update the api
* chore(cloudbilling): update the api
* chore(cloudbuild): update the api
* chore(clouddebugger): update the api
* chore(clouderrorreporting): update the api
* chore(cloudfunctions): update the api
* chore(cloudidentity): update the api
* chore(cloudiot): update the api
* chore(cloudkms): update the api
* chore(cloudprofiler): update the api
* chore(cloudresourcemanager): update the api
* chore(cloudscheduler): update the api
* chore(cloudshell): update the api
* chore(cloudtasks): update the api
* chore(cloudtrace): update the api
* chore(composer): update the api
* chore(containeranalysis): update the api
* chore(content): update the api
* chore(customsearch): update the api
* chore(datacatalog): update the api
* chore(datafusion): update the api
* chore(datamigration): update the api
* chore(datastore): update the api
* chore(deploymentmanager): update the api
* chore(digitalassetlinks): update the api
* chore(displayvideo): update the api
* chore(dlp): update the api
* chore(dns): update the api
* chore(docs): update the api
* chore(domains): update the api
* chore(domainsrdap): update the api
* chore(doubleclickbidmanager): update the api
* chore(doubleclicksearch): update the api
* chore(drive): update the api
* chore(driveactivity): update the api
* chore(eventarc): update the api
* chore(factchecktools): update the api
* chore(fcm): update the api
* chore(file): update the api
* chore(firebase): update the api
* chore(firebasedatabase): update the api
* chore(firebasedynamiclinks): update the api
* chore(firebasehosting): update the api
* chore(firebaseml): update the api
* chore(firebaserules): update the api
* chore(firestore): update the api
* chore(fitness): update the api
* chore(gamesConfiguration): update the api
* chore(gamesManagement): update the api
* chore(gameservices): update the api
* chore(genomics): update the api
* chore(gmail): update the api
* chore(gmailpostmastertools): update the api
* chore(groupsmigration): update the api
* chore(groupssettings): update the api
* chore(healthcare): update the api
* chore(iam): update the api
* chore(iamcredentials): update the api
* chore(iap): update the api
* chore(identitytoolkit): update the api
* chore(indexing): update the api
* chore(jobs): update the api
* chore(kgsearch): update the api
* chore(language): update the api
* chore(libraryagent): update the api
* chore(licensing): update the api
* chore(lifesciences): update the api
* chore(logging): update the api
* chore(managedidentities): update the api
* chore(manufacturers): update the api
* chore(memcache): update the api
* chore(ml): update the api
* chore(monitoring): update the api
* chore(networkmanagement): update the api
* chore(osconfig): update the api
* chore(pagespeedonline): update the api
* chore(playablelocations): update the api
* chore(playcustomapp): update the api
* chore(policytroubleshooter): update the api
* chore(poly): update the api
* chore(privateca): update the api
* chore(prod_tt_sasportal): update the api
* chore(pubsub): update the api
* chore(pubsublite): update the api
* chore(realtimebidding): update the api
* chore(recommendationengine): update the api
* chore(recommender): update the api
* chore(redis): update the api
* chore(remotebuildexecution): update the api
* chore(reseller): update the api
* chore(runtimeconfig): update the api
* chore(safebrowsing): update the api
* chore(sasportal): update the api
* chore(script): update the api
* chore(searchconsole): update the api
* chore(secretmanager): update the api
* chore(servicecontrol): update the api
* chore(servicedirectory): update the api
* chore(siteVerification): update the api
* chore(slides): update the api
* chore(smartdevicemanagement): update the api
* chore(sourcerepo): update the api
* chore(sqladmin): update the api
* chore(storage): update the api
* chore(storagetransfer): update the api
* chore(streetviewpublish): update the api
* chore(sts): update the api
* chore(tagmanager): update the api
* chore(tasks): update the api
* chore(testing): update the api
* chore(texttospeech): update the api
* chore(toolresults): update the api
* chore(trafficdirector): update the api
* chore(transcoder): update the api
* chore(translate): update the api
* chore(vault): update the api
* chore(vectortile): update the api
* chore(verifiedaccess): update the api
* chore(videointelligence): update the api
* chore(vision): update the api
* chore(webfonts): update the api
* chore(webmasters): update the api
* chore(websecurityscanner): update the api
* chore(workflowexecutions): update the api
* chore(workflows): update the api
* chore(youtubeAnalytics): update the api
* chore(youtubereporting): update the api
* chore(docs): Add new discovery artifacts and reference documents
diff --git a/docs/dyn/compute_alpha.instances.html b/docs/dyn/compute_alpha.instances.html
index a62d5b6..38585e5 100644
--- a/docs/dyn/compute_alpha.instances.html
+++ b/docs/dyn/compute_alpha.instances.html
@@ -97,7 +97,7 @@
<p class="firstline">Close httplib2 connections.</p>
<p class="toc_element">
<code><a href="#delete">delete(project, zone, instance, requestId=None)</a></code></p>
-<p class="firstline">Deletes the specified Instance resource. For more information, see Stopping or Deleting an Instance.</p>
+<p class="firstline">Deletes the specified Instance resource. For more information, see Deleting an instance.</p>
<p class="toc_element">
<code><a href="#deleteAccessConfig">deleteAccessConfig(project, zone, instance, accessConfig, networkInterface, requestId=None)</a></code></p>
<p class="firstline">Deletes an access config from an instance's network interface.</p>
@@ -305,50 +305,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -437,50 +393,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -1254,50 +1166,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -1340,7 +1208,7 @@
{
"count": "A String", # The maximum number of instances to create.
- "instance": { # Represents an Instance resource. # The instance defining the VM instances to be created.
+ "instance": { # Represents an Instance resource. # DEPRECATED: Please use instance_properties instead.
#
# An instance is a virtual machine that is hosted on Google Cloud Platform. For more information, read Virtual Machine Instances. (== resource_for {$api_version}.instances ==)
"advancedMachineFeatures": { # Specifies options for controlling advanced machine features. Options that would traditionally be configured in a BIOS belong here. Features that require operating system support may have corresponding entries in the GuestOsFeatures of an Image (e.g., whether or not the OS in the Image supports nested virtualization being enabled or disabled). # Controls for advanced machine-related behavior features.
@@ -2136,21 +2004,21 @@
],
},
},
- "locationPolicy": { # Configuration for location policy among multiple possible locations (e.g. preferences for zone selection among zones in a single region).
- "locations": { # Location configurations mapped by location name. Currently only zone names are supported and must be represented as valid internal URLs, like: zones/us-central1-a.
+ "locationPolicy": { # Configuration for location policy among multiple possible locations (e.g. preferences for zone selection among zones in a single region). # Policy for chosing target zone.
+ "locations": { # Location configurations mapped by location name. Currently only zone names are supported and must be represented as valid internal URLs, such as zones/us-central1-a.
"a_key": {
- "preference": "A String",
+ "preference": "A String", # Preference for a given locaction: ALLOW or DENY.
},
},
},
- "minCount": "A String", # The minimum number of instances to create. If no min_count is specified then count is used as the default value. If min_count instances cannot be created, then no instances will be created.
- "namePattern": "A String", # The string pattern used for the names of the VMs. Either name_pattern or predefined_names must be set. The pattern should contain one consecutive sequence of placeholder hash characters (#) with each character corresponding to one digit of the generated instance name. Example: name_pattern of inst-#### will generate instance names like inst-0001, inst-0002, ... . If there already exist instance(s) whose names match the name pattern in the same project and zone, then the generated instance numbers will start after the biggest existing number. For example, if there exists an instance with name inst-0050, then instance names generated using the pattern inst-#### will be inst-0051, inst-0052, etc. The name pattern placeholder #...# can contain up to 18 characters.
+ "minCount": "A String", # The minimum number of instances to create. If no min_count is specified then count is used as the default value. If min_count instances cannot be created, then no instances will be created and instances already created will be deleted.
+ "namePattern": "A String", # The string pattern used for the names of the VMs. Either name_pattern or per_instance_properties must be set. The pattern should contain one continuous sequence of placeholder hash characters (#) with each character corresponding to one digit of the generated instance name. Example: name_pattern of inst-#### will generate instance names such as inst-0001, inst-0002, ... . If there already exist instance(s) whose names match the name pattern in the same project and zone, then the generated instance numbers will start after the biggest existing number. For example, if there exists an instance with name inst-0050, then instance names generated using the pattern inst-#### will be inst-0051, inst-0052, etc. The name pattern placeholder #...# can contain up to 18 characters.
"perInstanceProperties": { # Per-instance properties to be set on individual instances. Keys of this map specify requested instance names. Can be empty if name_pattern is used.
"a_key": { # Per-instance properties to be set on individual instances. To be extended in the future.
"name": "A String", # This field is only temporary. It will be removed. Do not use it.
},
},
- "predefinedNames": [ # List of predefined names. The number of names provided must be equal to count.
+ "predefinedNames": [ # DEPRECATED: Please use per_instance_properties instead.
"A String",
],
"sourceInstanceTemplate": "A String", # Specifies the instance template from which to create instances. You may combine sourceInstanceTemplate with instanceProperties to override specific values from an existing instance template. Bulk API follows the semantics of JSON Merge Patch described by RFC 7396.
@@ -2204,50 +2072,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -2285,7 +2109,7 @@
<div class="method">
<code class="details" id="delete">delete(project, zone, instance, requestId=None)</code>
- <pre>Deletes the specified Instance resource. For more information, see Stopping or Deleting an Instance.
+ <pre>Deletes the specified Instance resource. For more information, see Deleting an instance.
Args:
project: string, Project ID for this request. (required)
@@ -2332,50 +2156,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -2457,50 +2237,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -2581,50 +2317,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -3262,7 +2954,7 @@
"id": "A String", # The unique identifier for the security policy. This identifier is defined by the server.
"rules": [ # The rules that apply to the network.
{ # Represents a rule that describes one or more match conditions along with the action to be taken when traffic matches this condition (allow or deny).
- "action": "A String", # The Action to preform when the client connection triggers the rule. Can currently be either "allow" or "deny()" where valid values for status are 403, 404, and 502.
+ "action": "A String", # The Action to perform when the client connection triggers the rule. Can currently be either "allow" or "deny()" where valid values for status are 403, 404, and 502.
"description": "A String", # An optional description of this resource. Provide this property when you create the resource.
"direction": "A String", # The direction in which this rule applies. This field may only be specified when versioned_expr is set to FIREWALL.
"enableLogging": True or False, # Denotes whether to enable logging for a particular rule. If logging is enabled, logs will be exported to the configured export destination in Stackdriver. Logs may be exported to BigQuery or Pub/Sub. Note: you cannot enable logging on "goto_next" rules.
@@ -4211,50 +3903,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -4920,50 +4568,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -5043,50 +4647,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -5207,50 +4767,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -5342,50 +4858,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -5467,50 +4939,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -6046,50 +5474,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -6181,50 +5565,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -6311,50 +5651,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -6450,50 +5746,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -6580,50 +5832,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -6711,50 +5919,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -6862,50 +6026,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -6995,50 +6115,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -7125,50 +6201,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -7255,50 +6287,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -7390,50 +6378,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -7508,50 +6452,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -7631,50 +6531,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -7795,50 +6651,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -7919,50 +6731,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -8043,50 +6811,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -8657,50 +7381,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -8802,50 +7482,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -8932,50 +7568,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -9138,50 +7730,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -9270,50 +7818,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.
@@ -9402,50 +7906,6 @@
"id": "A String", # [Output Only] The unique identifier for the operation. This identifier is defined by the server.
"insertTime": "A String", # [Output Only] The time that this operation was requested. This value is in RFC3339 text format.
"kind": "compute#operation", # [Output Only] Type of the resource. Always `compute#operation` for Operation resources.
- "metadata": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # [Output Only] Service-specific metadata attached to this operation.
- #
- # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
- #
- # Example 1: Pack and unpack a message in C++.
- #
- # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
- #
- # Example 2: Pack and unpack a message in Java.
- #
- # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }
- #
- # Example 3: Pack and unpack a message in Python.
- #
- # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
- #
- # Example 4: Pack and unpack a message in Go
- #
- # foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
- #
- # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
- #
- #
- #
- # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:
- #
- # package google.profile; message Person { string first_name = 1; string last_name = 2; }
- #
- # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": }
- #
- # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):
- #
- # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
- "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted).
- #
- # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
- #
- # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
- #
- # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com.
- #
- # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
- "value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
- },
"name": "A String", # [Output Only] Name of the operation.
"operationGroupId": "A String", # [Output Only] An ID that represents a group of operations, such as when a group of operations results from a `bulkInsert` API request.
"operationType": "A String", # [Output Only] The type of operation, such as `insert`, `update`, or `delete`, and so on.