@devvit/protos 0.11.17-next-2025-05-28-417d95f5a.0 → 0.11.17-next-2025-05-29-91b3cf49f.0

package/schema/.snootobuf/deps/google/api/endpoint.proto

@@ -1,4 +1,4 @@
-// Copyright 2024 Google LLC
+// Copyright 2018 Google LLC.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -16,47 +16,49 @@ syntax = "proto3";
 
 package google.api;
 
+import "google/api/annotations.proto";
+
 option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig";
 option java_multiple_files = true;
 option java_outer_classname = "EndpointProto";
 option java_package = "com.google.api";
 option objc_class_prefix = "GAPI";
 
-// `Endpoint` describes a network address of a service that serves a set of
-// APIs. It is commonly known as a service endpoint. A service may expose
-// any number of service endpoints, and all service endpoints share the same
-// service definition, such as quota limits and monitoring metrics.
+
+// `Endpoint` describes a network endpoint that serves a set of APIs.
+// A service may expose any number of endpoints, and all endpoints share the
+// same service configuration, such as quota configuration and monitoring
+// configuration.
 //
-// Example:
+// Example service configuration:
 //
-//     type: google.api.Service
 //     name: library-example.googleapis.com
 //     endpoints:
-//       # Declares network address `https://library-example.googleapis.com`
-//       # for service `library-example.googleapis.com`. The `https` scheme
-//       # is implicit for all service endpoints. Other schemes may be
-//       # supported in the future.
+//       # Below entry makes 'google.example.library.v1.Library'
+//       # API be served from endpoint address library-example.googleapis.com.
+//       # It also allows HTTP OPTIONS calls to be passed to the backend, for
+//       # it to decide whether the subsequent cross-origin request is
+//       # allowed to proceed.
 //     - name: library-example.googleapis.com
-//       allow_cors: false
-//     - name: content-staging-library-example.googleapis.com
-//       # Allows HTTP OPTIONS calls to be passed to the API frontend, for it
-//       # to decide whether the subsequent cross-origin request is allowed
-//       # to proceed.
 //       allow_cors: true
 message Endpoint {
   // The canonical name of this endpoint.
   string name = 1;
 
-  // Aliases for this endpoint, these will be served by the same UrlMap as the
-  // parent endpoint, and will be provisioned in the GCP stack for the Regional
-  // Endpoints.
+  // DEPRECATED: This field is no longer supported. Instead of using aliases,
+  // please specify multiple [google.api.Endpoint][google.api.Endpoint] for each of the intended
+  // aliases.
+  //
+  // Additional names that this endpoint will be hosted on.
   repeated string aliases = 2;
 
+  // The list of features enabled on this endpoint.
+  repeated string features = 4;
+
   // The specification of an Internet routable address of API frontend that will
-  // handle requests to this [API
-  // Endpoint](https://cloud.google.com/apis/design/glossary). It should be
-  // either a valid IPv4 address or a fully-qualified domain name. For example,
-  // "8.8.8.8" or "myservice.appspot.com".
+  // handle requests to this [API Endpoint](https://cloud.google.com/apis/design/glossary).
+  // It should be either a valid IPv4 address or a fully-qualified domain name.
+  // For example, "8.8.8.8" or "myservice.appspot.com".
   string target = 101;
 
   // Allowing

package/schema/.snootobuf/deps/google/api/field_behavior.proto

@@ -1,4 +1,4 @@
-// Copyright 2024 Google LLC
+// Copyright 2020 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -37,7 +37,7 @@ extend google.protobuf.FieldOptions {
   //   google.protobuf.Timestamp expire_time = 1
   //     [(google.api.field_behavior) = OUTPUT_ONLY,
   //      (google.api.field_behavior) = IMMUTABLE];
-  repeated google.api.FieldBehavior field_behavior = 1052 [packed = false];
+  repeated google.api.FieldBehavior field_behavior = 1052;
 }
 
 // An indicator of the behavior of a given field (for example, that a field
@@ -78,27 +78,7 @@ enum FieldBehavior {
 
   // Denotes that a (repeated) field is an unordered list.
   // This indicates that the service may provide the elements of the list
-  // in any arbitrary  order, rather than the order the user originally
+  // in any arbitrary order, rather than the order the user originally
   // provided. Additionally, the list's order may or may not be stable.
   UNORDERED_LIST = 6;
-
-  // Denotes that this field returns a non-empty default value if not set.
-  // This indicates that if the user provides the empty value in a request,
-  // a non-empty value will be returned. The user will not be aware of what
-  // non-empty value to expect.
-  NON_EMPTY_DEFAULT = 7;
-
-  // Denotes that the field in a resource (a message annotated with
-  // google.api.resource) is used in the resource name to uniquely identify the
-  // resource. For AIP-compliant APIs, this should only be applied to the
-  // `name` field on the resource.
-  //
-  // This behavior should not be applied to references to other resources within
-  // the message.
-  //
-  // The identifier field of resources often have different field behavior
-  // depending on the request it is embedded in (e.g. for Create methods name
-  // is optional and unused, while for Update methods it is required). Instead
-  // of method-specific annotations, only `IDENTIFIER` is required.
-  IDENTIFIER = 8;
 }

package/schema/.snootobuf/deps/google/api/http.proto

@@ -1,4 +1,4 @@
-// Copyright 2024 Google LLC
+// Copyright 2018 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -23,6 +23,7 @@ option java_outer_classname = "HttpProto";
 option java_package = "com.google.api";
 option objc_class_prefix = "GAPI";
 
+
 // Defines the HTTP configuration for an API service. It contains a list of
 // [HttpRule][google.api.HttpRule], each specifying the mapping of an RPC method
 // to one or more HTTP REST API methods.
@@ -32,7 +33,7 @@ message Http {
   // **NOTE:** All service configuration rules follow "last one wins" order.
   repeated HttpRule rules = 1;
 
-  // When set to true, URL path parameters will be fully URI-decoded except in
+  // When set to true, URL path parmeters will be fully URI-decoded except in
   // cases of single segment matches in reserved expansion, where "%2F" will be
   // left encoded.
   //
@@ -41,91 +42,94 @@ message Http {
   bool fully_decode_reserved_expansion = 2;
 }
 
-// gRPC Transcoding
-//
-// gRPC Transcoding is a feature for mapping between a gRPC method and one or
-// more HTTP REST endpoints. It allows developers to build a single API service
-// that supports both gRPC APIs and REST APIs. Many systems, including [Google
-// APIs](https://github.com/googleapis/googleapis),
-// [Cloud Endpoints](https://cloud.google.com/endpoints), [gRPC
-// Gateway](https://github.com/grpc-ecosystem/grpc-gateway),
-// and [Envoy](https://github.com/envoyproxy/envoy) proxy support this feature
-// and use it for large scale production services.
-//
-// `HttpRule` defines the schema of the gRPC/REST mapping. The mapping specifies
-// how different portions of the gRPC request message are mapped to the URL
-// path, URL query parameters, and HTTP request body. It also controls how the
-// gRPC response message is mapped to the HTTP response body. `HttpRule` is
-// typically specified as an `google.api.http` annotation on the gRPC method.
-//
-// Each mapping specifies a URL path template and an HTTP method. The path
-// template may refer to one or more fields in the gRPC request message, as long
-// as each field is a non-repeated field with a primitive (non-message) type.
-// The path template controls how fields of the request message are mapped to
-// the URL path.
-//
-// Example:
+// `HttpRule` defines the mapping of an RPC method to one or more HTTP
+// REST API methods. The mapping specifies how different portions of the RPC
+// request message are mapped to URL path, URL query parameters, and
+// HTTP request body. The mapping is typically specified as an
+// `google.api.http` annotation on the RPC method,
+// see "google/api/annotations.proto" for details.
+//
+// The mapping consists of a field specifying the path template and
+// method kind.  The path template can refer to fields in the request
+// message, as in the example below which describes a REST GET
+// operation on a resource collection of messages:
+//
 //
 //     service Messaging {
 //       rpc GetMessage(GetMessageRequest) returns (Message) {
-//         option (google.api.http) = {
-//             get: "/v1/{name=messages/*}"
-//         };
+//         option (google.api.http).get = "/v1/messages/{message_id}/{sub.subfield}";
 //       }
 //     }
 //     message GetMessageRequest {
-//       string name = 1; // Mapped to URL path.
+//       message SubMessage {
+//         string subfield = 1;
+//       }
+//       string message_id = 1; // mapped to the URL
+//       SubMessage sub = 2;    // `sub.subfield` is url-mapped
 //     }
 //     message Message {
-//       string text = 1; // The resource content.
+//       string text = 1; // content of the resource
 //     }
 //
-// This enables an HTTP REST to gRPC mapping as below:
+// The same http annotation can alternatively be expressed inside the
+// `GRPC API Configuration` YAML file.
 //
-// - HTTP: `GET /v1/messages/123456`
-// - gRPC: `GetMessage(name: "messages/123456")`
+//     http:
+//       rules:
+//         - selector: <proto_package_name>.Messaging.GetMessage
+//           get: /v1/messages/{message_id}/{sub.subfield}
+//
+// This definition enables an automatic, bidrectional mapping of HTTP
+// JSON to RPC. Example:
+//
+// HTTP | RPC
+// -----|-----
+// `GET /v1/messages/123456/foo`  | `GetMessage(message_id: "123456" sub: SubMessage(subfield: "foo"))`
+//
+// In general, not only fields but also field paths can be referenced
+// from a path pattern. Fields mapped to the path pattern cannot be
+// repeated and must have a primitive (non-message) type.
+//
+// Any fields in the request message which are not bound by the path
+// pattern automatically become (optional) HTTP query
+// parameters. Assume the following definition of the request message:
 //
-// Any fields in the request message which are not bound by the path template
-// automatically become HTTP query parameters if there is no HTTP request body.
-// For example:
 //
 //     service Messaging {
 //       rpc GetMessage(GetMessageRequest) returns (Message) {
-//         option (google.api.http) = {
-//             get:"/v1/messages/{message_id}"
-//         };
+//         option (google.api.http).get = "/v1/messages/{message_id}";
 //       }
 //     }
 //     message GetMessageRequest {
 //       message SubMessage {
 //         string subfield = 1;
 //       }
-//       string message_id = 1; // Mapped to URL path.
-//       int64 revision = 2;    // Mapped to URL query parameter `revision`.
-//       SubMessage sub = 3;    // Mapped to URL query parameter `sub.subfield`.
+//       string message_id = 1; // mapped to the URL
+//       int64 revision = 2;    // becomes a parameter
+//       SubMessage sub = 3;    // `sub.subfield` becomes a parameter
 //     }
 //
+//
 // This enables a HTTP JSON to RPC mapping as below:
 //
-// - HTTP: `GET /v1/messages/123456?revision=2&sub.subfield=foo`
-// - gRPC: `GetMessage(message_id: "123456" revision: 2 sub:
-// SubMessage(subfield: "foo"))`
+// HTTP | RPC
+// -----|-----
+// `GET /v1/messages/123456?revision=2&sub.subfield=foo` | `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield: "foo"))`
 //
-// Note that fields which are mapped to URL query parameters must have a
-// primitive type or a repeated primitive type or a non-repeated message type.
-// In the case of a repeated type, the parameter can be repeated in the URL
-// as `...?param=A&param=B`. In the case of a message type, each field of the
-// message is mapped to a separate parameter, such as
-// `...?foo.a=A&foo.b=B&foo.c=C`.
+// Note that fields which are mapped to HTTP parameters must have a
+// primitive type or a repeated primitive type. Message types are not
+// allowed. In the case of a repeated type, the parameter can be
+// repeated in the URL, as in `...?param=A&param=B`.
 //
-// For HTTP methods that allow a request body, the `body` field
+// For HTTP method kinds which allow a request body, the `body` field
 // specifies the mapping. Consider a REST update method on the
 // message resource collection:
 //
+//
 //     service Messaging {
 //       rpc UpdateMessage(UpdateMessageRequest) returns (Message) {
 //         option (google.api.http) = {
-//           patch: "/v1/messages/{message_id}"
+//           put: "/v1/messages/{message_id}"
 //           body: "message"
 //         };
 //       }
@@ -135,12 +139,14 @@ message Http {
 //       Message message = 2;   // mapped to the body
 //     }
 //
+//
 // The following HTTP JSON to RPC mapping is enabled, where the
 // representation of the JSON in the request body is determined by
 // protos JSON encoding:
 //
-// - HTTP: `PATCH /v1/messages/123456 { "text": "Hi!" }`
-// - gRPC: `UpdateMessage(message_id: "123456" message { text: "Hi!" })`
+// HTTP | RPC
+// -----|-----
+// `PUT /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: "123456" message { text: "Hi!" })`
 //
 // The special name `*` can be used in the body mapping to define that
 // every field not bound by the path template should be mapped to the
@@ -150,7 +156,7 @@ message Http {
 //     service Messaging {
 //       rpc UpdateMessage(Message) returns (Message) {
 //         option (google.api.http) = {
-//           patch: "/v1/messages/{message_id}"
+//           put: "/v1/messages/{message_id}"
 //           body: "*"
 //         };
 //       }
@@ -163,12 +169,13 @@ message Http {
 //
 // The following HTTP JSON to RPC mapping is enabled:
 //
-// - HTTP: `PATCH /v1/messages/123456 { "text": "Hi!" }`
-// - gRPC: `UpdateMessage(message_id: "123456" text: "Hi!")`
+// HTTP | RPC
+// -----|-----
+// `PUT /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: "123456" text: "Hi!")`
 //
 // Note that when using `*` in the body mapping, it is not possible to
 // have HTTP parameters, as all fields not bound by the path end in
-// the body. This makes this option more rarely used in practice when
+// the body. This makes this option more rarely used in practice of
 // defining REST APIs. The common usage of `*` is in custom methods
 // which don't use the URL at all for transferring data.
 //
@@ -190,34 +197,32 @@ message Http {
 //       string user_id = 2;
 //     }
 //
-// This enables the following two alternative HTTP JSON to RPC mappings:
 //
-// - HTTP: `GET /v1/messages/123456`
-// - gRPC: `GetMessage(message_id: "123456")`
+// This enables the following two alternative HTTP JSON to RPC
+// mappings:
+//
+// HTTP | RPC
+// -----|-----
+// `GET /v1/messages/123456` | `GetMessage(message_id: "123456")`
+// `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id: "123456")`
 //
-// - HTTP: `GET /v1/users/me/messages/123456`
-// - gRPC: `GetMessage(user_id: "me" message_id: "123456")`
+// # Rules for HTTP mapping
 //
-// Rules for HTTP mapping
+// The rules for mapping HTTP path, query parameters, and body fields
+// to the request message are as follows:
 //
-// 1. Leaf request fields (recursive expansion nested messages in the request
-//    message) are classified into three categories:
-//    - Fields referred by the path template. They are passed via the URL path.
-//    - Fields referred by the [HttpRule.body][google.api.HttpRule.body]. They
-//    are passed via the HTTP
-//      request body.
-//    - All other fields are passed via the URL query parameters, and the
-//      parameter name is the field path in the request message. A repeated
-//      field can be represented as multiple query parameters under the same
-//      name.
-//  2. If [HttpRule.body][google.api.HttpRule.body] is "*", there is no URL
-//  query parameter, all fields
-//     are passed via URL path and HTTP request body.
-//  3. If [HttpRule.body][google.api.HttpRule.body] is omitted, there is no HTTP
-//  request body, all
-//     fields are passed via URL path and URL query parameters.
+// 1. The `body` field specifies either `*` or a field path, or is
+//    omitted. If omitted, it indicates there is no HTTP request body.
+// 2. Leaf fields (recursive expansion of nested messages in the
+//    request) can be classified into three types:
+//     (a) Matched in the URL template.
+//     (b) Covered by body (if body is `*`, everything except (a) fields;
+//         else everything under the body field)
+//     (c) All other fields.
+// 3. URL query parameters found in the HTTP request are mapped to (c) fields.
+// 4. Any body sent with an HTTP request can contain only (b) fields.
 //
-// Path template syntax
+// The syntax of the path template is as follows:
 //
 //     Template = "/" Segments [ Verb ] ;
 //     Segments = Segment { "/" Segment } ;
@@ -226,110 +231,57 @@ message Http {
 //     FieldPath = IDENT { "." IDENT } ;
 //     Verb     = ":" LITERAL ;
 //
-// The syntax `*` matches a single URL path segment. The syntax `**` matches
-// zero or more URL path segments, which must be the last part of the URL path
-// except the `Verb`.
+// The syntax `*` matches a single path segment. The syntax `**` matches zero
+// or more path segments, which must be the last part of the path except the
+// `Verb`. The syntax `LITERAL` matches literal text in the path.
 //
 // The syntax `Variable` matches part of the URL path as specified by its
 // template. A variable template must not contain other variables. If a variable
 // matches a single path segment, its template may be omitted, e.g. `{var}`
 // is equivalent to `{var=*}`.
 //
-// The syntax `LITERAL` matches literal text in the URL path. If the `LITERAL`
-// contains any reserved character, such characters should be percent-encoded
-// before the matching.
-//
 // If a variable contains exactly one path segment, such as `"{var}"` or
-// `"{var=*}"`, when such a variable is expanded into a URL path on the client
-// side, all characters except `[-_.~0-9a-zA-Z]` are percent-encoded. The
-// server side does the reverse decoding. Such variables show up in the
-// [Discovery
-// Document](https://developers.google.com/discovery/v1/reference/apis) as
-// `{var}`.
-//
-// If a variable contains multiple path segments, such as `"{var=foo/*}"`
-// or `"{var=**}"`, when such a variable is expanded into a URL path on the
-// client side, all characters except `[-_.~/0-9a-zA-Z]` are percent-encoded.
-// The server side does the reverse decoding, except "%2F" and "%2f" are left
-// unchanged. Such variables show up in the
-// [Discovery
-// Document](https://developers.google.com/discovery/v1/reference/apis) as
-// `{+var}`.
-//
-// Using gRPC API Service Configuration
-//
-// gRPC API Service Configuration (service config) is a configuration language
-// for configuring a gRPC service to become a user-facing product. The
-// service config is simply the YAML representation of the `google.api.Service`
-// proto message.
-//
-// As an alternative to annotating your proto file, you can configure gRPC
-// transcoding in your service config YAML files. You do this by specifying a
-// `HttpRule` that maps the gRPC method to a REST endpoint, achieving the same
-// effect as the proto annotation. This can be particularly useful if you
-// have a proto that is reused in multiple services. Note that any transcoding
-// specified in the service config will override any matching transcoding
-// configuration in the proto.
-//
-// The following example selects a gRPC method and applies an `HttpRule` to it:
-//
-//     http:
-//       rules:
-//         - selector: example.v1.Messaging.GetMessage
-//           get: /v1/messages/{message_id}/{sub.subfield}
-//
-// Special notes
-//
-// When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the
-// proto to JSON conversion must follow the [proto3
-// specification](https://developers.google.com/protocol-buffers/docs/proto3#json).
-//
-// While the single segment variable follows the semantics of
-// [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple String
-// Expansion, the multi segment variable **does not** follow RFC 6570 Section
-// 3.2.3 Reserved Expansion. The reason is that the Reserved Expansion
+// `"{var=*}"`, when such a variable is expanded into a URL path, all characters
+// except `[-_.~0-9a-zA-Z]` are percent-encoded. Such variables show up in the
+// Discovery Document as `{var}`.
+//
+// If a variable contains one or more path segments, such as `"{var=foo/*}"`
+// or `"{var=**}"`, when such a variable is expanded into a URL path, all
+// characters except `[-_.~/0-9a-zA-Z]` are percent-encoded. Such variables
+// show up in the Discovery Document as `{+var}`.
+//
+// NOTE: While the single segment variable matches the semantics of
+// [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2
+// Simple String Expansion, the multi segment variable **does not** match
+// RFC 6570 Reserved Expansion. The reason is that the Reserved Expansion
 // does not expand special characters like `?` and `#`, which would lead
-// to invalid URLs. As the result, gRPC Transcoding uses a custom encoding
-// for multi segment variables.
-//
-// The path variables **must not** refer to any repeated or mapped field,
-// because client libraries are not capable of handling such variable expansion.
+// to invalid URLs.
 //
-// The path variables **must not** capture the leading "/" character. The reason
-// is that the most common use case "{var}" does not capture the leading "/"
-// character. For consistency, all path variables must share the same behavior.
-//
-// Repeated message fields must not be mapped to URL query parameters, because
-// no client library can support such complicated mapping.
-//
-// If an API needs to use a JSON array for request or response body, it can map
-// the request or response body to a repeated field. However, some gRPC
-// Transcoding implementations may not support this feature.
+// NOTE: the field paths in variables and in the `body` must not refer to
+// repeated fields or map fields.
 message HttpRule {
-  // Selects a method to which this rule applies.
+  // Selects methods to which this rule applies.
   //
-  // Refer to [selector][google.api.DocumentationRule.selector] for syntax
-  // details.
+  // Refer to [selector][google.api.DocumentationRule.selector] for syntax details.
   string selector = 1;
 
   // Determines the URL pattern is matched by this rules. This pattern can be
   // used with any of the {get|put|post|delete|patch} methods. A custom method
   // can be defined using the 'custom' field.
   oneof pattern {
-    // Maps to HTTP GET. Used for listing and getting information about
-    // resources.
+    // Used for listing and getting information about resources.
     string get = 2;
 
-    // Maps to HTTP PUT. Used for replacing a resource.
+    // Used for updating a resource.
     string put = 3;
 
-    // Maps to HTTP POST. Used for creating a resource or performing an action.
+    // Used for creating a resource.
     string post = 4;
 
-    // Maps to HTTP DELETE. Used for deleting a resource.
+    // Used for deleting a resource.
     string delete = 5;
 
-    // Maps to HTTP PATCH. Used for updating a resource.
+    // Used for updating a resource.
     string patch = 6;
 
     // The custom pattern is used for specifying an HTTP method that is not
@@ -339,20 +291,15 @@ message HttpRule {
     CustomHttpPattern custom = 8;
   }
 
-  // The name of the request field whose value is mapped to the HTTP request
-  // body, or `*` for mapping all request fields not captured by the path
-  // pattern to the HTTP body, or omitted for not having any HTTP request body.
-  //
-  // NOTE: the referred field must be present at the top-level of the request
-  // message type.
+  // The name of the request field whose value is mapped to the HTTP body, or
+  // `*` for mapping all fields not captured by the path pattern to the HTTP
+  // body. NOTE: the referred field must not be a repeated field and must be
+  // present at the top-level of request message type.
   string body = 7;
 
   // Optional. The name of the response field whose value is mapped to the HTTP
-  // response body. When omitted, the entire response message will be used
-  // as the HTTP response body.
-  //
-  // NOTE: The referred field must be present at the top-level of the response
-  // message type.
+  // body of response. Other response fields are ignored. When
+  // not set, the response message will be used as HTTP body of response.
   string response_body = 12;
 
   // Additional HTTP bindings for the selector. Nested bindings must

package/schema/.snootobuf/deps/google/api/httpbody.proto

@@ -1,4 +1,4 @@
-// Copyright 2024 Google LLC
+// Copyright 2018 Google LLC.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -18,13 +18,13 @@ package google.api;
 
 import "google/protobuf/any.proto";
 
-option cc_enable_arenas = true;
 option go_package = "google.golang.org/genproto/googleapis/api/httpbody;httpbody";
 option java_multiple_files = true;
 option java_outer_classname = "HttpBodyProto";
 option java_package = "com.google.api";
 option objc_class_prefix = "GAPI";
 
+
 // Message that represents an arbitrary HTTP body. It should only be used for
 // payload formats that can't be represented as JSON, such as raw binary or
 // an HTML page.
@@ -45,15 +45,11 @@ option objc_class_prefix = "GAPI";
 //
 //       // The raw HTTP body is bound to this field.
 //       google.api.HttpBody http_body = 2;
-//
 //     }
 //
 //     service ResourceService {
-//       rpc GetResource(GetResourceRequest)
-//         returns (google.api.HttpBody);
-//       rpc UpdateResource(google.api.HttpBody)
-//         returns (google.protobuf.Empty);
-//
+//       rpc GetResource(GetResourceRequest) returns (google.api.HttpBody);
+//       rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty);
 //     }
 //
 // Example with streaming methods:
@@ -63,16 +59,15 @@ option objc_class_prefix = "GAPI";
 //         returns (stream google.api.HttpBody);
 //       rpc UpdateCalendar(stream google.api.HttpBody)
 //         returns (stream google.api.HttpBody);
-//
 //     }
 //
 // Use of this type only changes how the request and response bodies are
 // handled, all other features will continue to work unchanged.
 message HttpBody {
-  // The HTTP Content-Type header value specifying the content type of the body.
+  // The HTTP Content-Type string representing the content type of the body.
   string content_type = 1;
 
-  // The HTTP request/response body as raw binary.
+  // HTTP body binary data.
   bytes data = 2;
 
   // Application specific response metadata. Must be set in the first response

package/schema/.snootobuf/deps/google/api/label.proto

@@ -1,4 +1,4 @@
-// Copyright 2024 Google LLC
+// Copyright 2018 Google LLC.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -23,6 +23,7 @@ option java_outer_classname = "LabelProto";
 option java_package = "com.google.api";
 option objc_class_prefix = "GAPI";
 
+
 // A description of a label.
 message LabelDescriptor {
   // Value types that can be used as label values.