From f88953d031198c7945450c5cca1f1144fd149bf7 Mon Sep 17 00:00:00 2001 From: ci core model Date: Fri, 16 Jan 2026 10:20:08 +0000 Subject: [PATCH] Latest generation --- google/api/field_behavior.ts | 39 +- google/api/http.ts | 62 +- google/api/httpbody.ts | 12 +- google/protobuf/any.ts | 15 +- google/protobuf/api.ts | 59 +- google/protobuf/compiler/plugin.ts | 136 ++- google/protobuf/descriptor.ts | 1603 ++++++++++++++++++++++++++-- google/protobuf/duration.ts | 1 - google/protobuf/empty.ts | 1 - google/protobuf/struct.ts | 6 +- google/protobuf/timestamp.ts | 29 +- google/protobuf/type.ts | 64 +- google/protobuf/wrappers.ts | 41 +- openapiv2.ts | 457 +++++++- package.json | 2 +- 15 files changed, 2349 insertions(+), 178 deletions(-) diff --git a/google/api/field_behavior.ts b/google/api/field_behavior.ts index e795a67..4e9aedb 100644 --- a/google/api/field_behavior.ts +++ b/google/api/field_behavior.ts @@ -2,7 +2,7 @@ // @generated from protobuf file "google/api/field_behavior.proto" (package "google.api", syntax proto3) // tslint:disable // -// Copyright 2020 Google LLC +// Copyright 2025 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -73,5 +73,40 @@ export enum FieldBehavior { * * @generated from protobuf enum value: IMMUTABLE = 5; */ - IMMUTABLE = 5 + IMMUTABLE = 5, + /** + * 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 + * provided. Additionally, the list's order may or may not be stable. + * + * @generated from protobuf enum value: UNORDERED_LIST = 6; + */ + 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. + * + * @generated from protobuf enum value: NON_EMPTY_DEFAULT = 7; + */ + 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. + * + * @generated from protobuf enum value: IDENTIFIER = 8; + */ + IDENTIFIER = 8 } diff --git a/google/api/http.ts b/google/api/http.ts index 0410689..45cfa59 100644 --- a/google/api/http.ts +++ b/google/api/http.ts @@ -2,7 +2,7 @@ // @generated from protobuf file "google/api/http.proto" (package "google.api", syntax proto3) // tslint:disable // -// Copyright 2020 Google LLC +// Copyright 2025 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -54,7 +54,7 @@ export interface Http { fully_decode_reserved_expansion: boolean; } /** - * # gRPC Transcoding + * 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 @@ -95,9 +95,8 @@ export interface Http { * * This enables an HTTP REST to gRPC mapping as below: * - * HTTP | gRPC - * -----|----- - * `GET /v1/messages/123456` | `GetMessage(name: "messages/123456")` + * - HTTP: `GET /v1/messages/123456` + * - gRPC: `GetMessage(name: "messages/123456")` * * 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. @@ -121,11 +120,9 @@ export interface Http { * * This enables a HTTP JSON to RPC mapping as below: * - * HTTP | gRPC - * -----|----- - * `GET /v1/messages/123456?revision=2&sub.subfield=foo` | - * `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield: - * "foo"))` + * - HTTP: `GET /v1/messages/123456?revision=2&sub.subfield=foo` + * - gRPC: `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. @@ -155,10 +152,8 @@ export interface Http { * representation of the JSON in the request body is determined by * protos JSON encoding: * - * HTTP | gRPC - * -----|----- - * `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: - * "123456" message { text: "Hi!" })` + * - HTTP: `PATCH /v1/messages/123456 { "text": "Hi!" }` + * - gRPC: `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 @@ -181,10 +176,8 @@ export interface Http { * * The following HTTP JSON to RPC mapping is enabled: * - * HTTP | gRPC - * -----|----- - * `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: - * "123456" text: "Hi!")` + * - HTTP: `PATCH /v1/messages/123456 { "text": "Hi!" }` + * - gRPC: `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 @@ -212,29 +205,32 @@ export interface Http { * * This enables the following two alternative HTTP JSON to RPC mappings: * - * HTTP | gRPC - * -----|----- - * `GET /v1/messages/123456` | `GetMessage(message_id: "123456")` - * `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id: - * "123456")` + * - HTTP: `GET /v1/messages/123456` + * - gRPC: `GetMessage(message_id: "123456")` * - * ## Rules for HTTP mapping + * - HTTP: `GET /v1/users/me/messages/123456` + * - gRPC: `GetMessage(user_id: "me" message_id: "123456")` + * + * Rules for HTTP mapping * * 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 + * - 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 + * 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 + * 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. * - * ### Path template syntax + * Path template syntax * * Template = "/" Segments [ Verb ] ; * Segments = Segment { "/" Segment } ; @@ -273,7 +269,7 @@ export interface Http { * Document](https://developers.google.com/discovery/v1/reference/apis) as * `{+var}`. * - * ## Using gRPC API Service Configuration + * 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 @@ -288,15 +284,14 @@ export interface Http { * specified in the service config will override any matching transcoding * configuration in the proto. * - * Example: + * The following example selects a gRPC method and applies an `HttpRule` to it: * * http: * rules: - * # Selects a gRPC method and applies HttpRule to it. * - selector: example.v1.Messaging.GetMessage * get: /v1/messages/{message_id}/{sub.subfield} * - * ## Special notes + * Special notes * * When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the * proto to JSON conversion must follow the [proto3 @@ -330,7 +325,8 @@ export interface HttpRule { /** * Selects a method 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. * * @generated from protobuf field: string selector = 1 */ diff --git a/google/api/httpbody.ts b/google/api/httpbody.ts index a760f1f..061aa8c 100644 --- a/google/api/httpbody.ts +++ b/google/api/httpbody.ts @@ -2,7 +2,7 @@ // @generated from protobuf file "google/api/httpbody.proto" (package "google.api", syntax proto3) // tslint:disable // -// Copyright 2020 Google LLC +// Copyright 2025 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -47,12 +47,15 @@ import { Any } from "../protobuf/any"; * * // 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: @@ -62,6 +65,7 @@ import { Any } from "../protobuf/any"; * 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 diff --git a/google/protobuf/any.ts b/google/protobuf/any.ts index 344b0cd..b45a45e 100644 --- a/google/protobuf/any.ts +++ b/google/protobuf/any.ts @@ -73,6 +73,10 @@ import { MessageType } from "@protobuf-ts/runtime"; * if (any.is(Foo.class)) { * foo = any.unpack(Foo.class); * } + * // or ... + * if (any.isSameTypeAs(Foo.getDefaultInstance())) { + * foo = any.unpack(Foo.getDefaultInstance()); + * } * * Example 3: Pack and unpack a message in Python. * @@ -87,10 +91,13 @@ import { MessageType } from "@protobuf-ts/runtime"; * Example 4: Pack and unpack a message in Go * * foo := &pb.Foo{...} - * any, err := ptypes.MarshalAny(foo) + * any, err := anypb.New(foo) + * if err != nil { + * ... + * } * ... * foo := &pb.Foo{} - * if err := ptypes.UnmarshalAny(any, foo); err != nil { + * if err := any.UnmarshalTo(foo); err != nil { * ... * } * @@ -100,7 +107,6 @@ import { MessageType } from "@protobuf-ts/runtime"; * 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 @@ -157,7 +163,8 @@ export interface Any { * * 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. + * type.googleapis.com. As of May 2023, there are no widely used type server + * implementations and no plans to implement one. * * Schemes other than `http`, `https` (or the empty scheme) might be * used with implementation specific semantics. diff --git a/google/protobuf/api.ts b/google/protobuf/api.ts index 9f7fb39..c993abc 100644 --- a/google/protobuf/api.ts +++ b/google/protobuf/api.ts @@ -55,6 +55,11 @@ import { Option } from "./type"; * this message itself. See https://cloud.google.com/apis/design/glossary for * detailed terminology. * + * New usages of this message as an alternative to ServiceDescriptorProto are + * strongly discouraged. This message does not reliability preserve all + * information necessary to model the schema and preserve semantics. Instead + * make use of FileDescriptorSet which preserves the necessary information. + * * @generated from protobuf message google.protobuf.Api */ export interface Api { @@ -99,7 +104,6 @@ export interface Api { * experimental, non-GA interfaces. * * - * * @generated from protobuf field: string version = 4 */ version: string; @@ -122,10 +126,21 @@ export interface Api { * @generated from protobuf field: google.protobuf.Syntax syntax = 7 */ syntax: Syntax; + /** + * The source edition string, only valid when syntax is SYNTAX_EDITIONS. + * + * @generated from protobuf field: string edition = 8 + */ + edition: string; } /** * Method represents a method of an API interface. * + * New usages of this message as an alternative to MethodDescriptorProto are + * strongly discouraged. This message does not reliability preserve all + * information necessary to model the schema and preserve semantics. Instead + * make use of FileDescriptorSet which preserves the necessary information. + * * @generated from protobuf message google.protobuf.Method */ export interface Method { @@ -168,9 +183,23 @@ export interface Method { /** * The source syntax of this method. * - * @generated from protobuf field: google.protobuf.Syntax syntax = 7 + * This field should be ignored, instead the syntax should be inherited from + * Api. This is similar to Field and EnumValue. + * + * @deprecated + * @generated from protobuf field: google.protobuf.Syntax syntax = 7 [deprecated = true] */ syntax: Syntax; + /** + * The source edition string, only valid when syntax is SYNTAX_EDITIONS. + * + * This field should be ignored, instead the edition should be inherited from + * Api. This is similar to Field and EnumValue. + * + * @deprecated + * @generated from protobuf field: string edition = 8 [deprecated = true] + */ + edition: string; } /** * Declares an API Interface to be included in this interface. The including @@ -220,7 +249,7 @@ export interface Method { * The mixin construct implies that all methods in `AccessControl` are * also declared with same name and request/response types in * `Storage`. A documentation generator or annotation processor will - * see the effective `Storage.GetAcl` method after inherting + * see the effective `Storage.GetAcl` method after inheriting * documentation and annotations as follows: * * service Storage { @@ -279,7 +308,8 @@ class Api$Type extends MessageType { { no: 4, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, { no: 5, name: "source_context", kind: "message", localName: "source_context", T: () => SourceContext }, { no: 6, name: "mixins", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Mixin }, - { no: 7, name: "syntax", kind: "enum", T: () => ["google.protobuf.Syntax", Syntax] } + { no: 7, name: "syntax", kind: "enum", T: () => ["google.protobuf.Syntax", Syntax] }, + { no: 8, name: "edition", kind: "scalar", T: 9 /*ScalarType.STRING*/ } ]); } create(value?: PartialMessage): Api { @@ -290,6 +320,7 @@ class Api$Type extends MessageType { message.version = ""; message.mixins = []; message.syntax = 0; + message.edition = ""; if (value !== undefined) reflectionMergePartial(this, message, value); return message; @@ -320,6 +351,9 @@ class Api$Type extends MessageType { case /* google.protobuf.Syntax syntax */ 7: message.syntax = reader.int32(); break; + case /* string edition */ 8: + message.edition = reader.string(); + break; default: let u = options.readUnknownField; if (u === "throw") @@ -353,6 +387,9 @@ class Api$Type extends MessageType { /* google.protobuf.Syntax syntax = 7; */ if (message.syntax !== 0) writer.tag(7, WireType.Varint).int32(message.syntax); + /* string edition = 8; */ + if (message.edition !== "") + writer.tag(8, WireType.LengthDelimited).string(message.edition); let u = options.writeUnknownFields; if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); @@ -373,7 +410,8 @@ class Method$Type extends MessageType { { no: 4, name: "response_type_url", kind: "scalar", localName: "response_type_url", T: 9 /*ScalarType.STRING*/ }, { no: 5, name: "response_streaming", kind: "scalar", localName: "response_streaming", T: 8 /*ScalarType.BOOL*/ }, { no: 6, name: "options", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Option }, - { no: 7, name: "syntax", kind: "enum", T: () => ["google.protobuf.Syntax", Syntax] } + { no: 7, name: "syntax", kind: "enum", T: () => ["google.protobuf.Syntax", Syntax] }, + { no: 8, name: "edition", kind: "scalar", T: 9 /*ScalarType.STRING*/ } ]); } create(value?: PartialMessage): Method { @@ -385,6 +423,7 @@ class Method$Type extends MessageType { message.response_streaming = false; message.options = []; message.syntax = 0; + message.edition = ""; if (value !== undefined) reflectionMergePartial(this, message, value); return message; @@ -412,9 +451,12 @@ class Method$Type extends MessageType { case /* repeated google.protobuf.Option options */ 6: message.options.push(Option.internalBinaryRead(reader, reader.uint32(), options)); break; - case /* google.protobuf.Syntax syntax */ 7: + case /* google.protobuf.Syntax syntax = 7 [deprecated = true] */ 7: message.syntax = reader.int32(); break; + case /* string edition = 8 [deprecated = true] */ 8: + message.edition = reader.string(); + break; default: let u = options.readUnknownField; if (u === "throw") @@ -445,9 +487,12 @@ class Method$Type extends MessageType { /* repeated google.protobuf.Option options = 6; */ for (let i = 0; i < message.options.length; i++) Option.internalBinaryWrite(message.options[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join(); - /* google.protobuf.Syntax syntax = 7; */ + /* google.protobuf.Syntax syntax = 7 [deprecated = true]; */ if (message.syntax !== 0) writer.tag(7, WireType.Varint).int32(message.syntax); + /* string edition = 8 [deprecated = true]; */ + if (message.edition !== "") + writer.tag(8, WireType.LengthDelimited).string(message.edition); let u = options.writeUnknownFields; if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); diff --git a/google/protobuf/compiler/plugin.ts b/google/protobuf/compiler/plugin.ts index a798141..34ba128 100644 --- a/google/protobuf/compiler/plugin.ts +++ b/google/protobuf/compiler/plugin.ts @@ -4,40 +4,14 @@ // // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // // // Author: kenton@google.com (Kenton Varda) // -// WARNING: The plugin interface is currently EXPERIMENTAL and is subject to -// change. -// // protoc (aka the Protocol Compiler) can be extended via plugins. A plugin is // just a program that reads a CodeGeneratorRequest from stdin and writes a // CodeGeneratorResponse to stdout. @@ -58,6 +32,7 @@ import { UnknownFieldHandler } from "@protobuf-ts/runtime"; import type { PartialMessage } from "@protobuf-ts/runtime"; import { reflectionMergePartial } from "@protobuf-ts/runtime"; import { MessageType } from "@protobuf-ts/runtime"; +import { GeneratedCodeInfo } from "../descriptor"; import { FileDescriptorProto } from "../descriptor"; /** * The version number of protocol compiler. @@ -110,6 +85,11 @@ export interface CodeGeneratorRequest { * they import. The files will appear in topological order, so each file * appears before any file that imports it. * + * Note: the files listed in files_to_generate will include runtime-retention + * options only, but all other files will include source-retention options. + * The source_file_descriptors field below is available in case you need + * source-retention options for files_to_generate. + * * protoc guarantees that all proto_files will be written after * the fields above, even though this is not technically guaranteed by the * protobuf wire format. This theoretically could allow a plugin to stream @@ -124,6 +104,14 @@ export interface CodeGeneratorRequest { * @generated from protobuf field: repeated google.protobuf.FileDescriptorProto proto_file = 15 */ proto_file: FileDescriptorProto[]; + /** + * File descriptors with all options, including source-retention options. + * These descriptors are only provided for the files listed in + * files_to_generate. + * + * @generated from protobuf field: repeated google.protobuf.FileDescriptorProto source_file_descriptors = 17 + */ + source_file_descriptors: FileDescriptorProto[]; /** * The version number of protocol compiler. * @@ -150,6 +138,31 @@ export interface CodeGeneratorResponse { * @generated from protobuf field: optional string error = 1 */ error?: string; + /** + * A bitmask of supported features that the code generator supports. + * This is a bitwise "or" of values from the Feature enum. + * + * @generated from protobuf field: optional uint64 supported_features = 2 + */ + supported_features?: bigint; + /** + * The minimum edition this plugin supports. This will be treated as an + * Edition enum, but we want to allow unknown values. It should be specified + * according the edition enum value, *not* the edition number. Only takes + * effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + * + * @generated from protobuf field: optional int32 minimum_edition = 3 + */ + minimum_edition?: number; + /** + * The maximum edition this plugin supports. This will be treated as an + * Edition enum, but we want to allow unknown values. It should be specified + * according the edition enum value, *not* the edition number. Only takes + * effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + * + * @generated from protobuf field: optional int32 maximum_edition = 4 + */ + maximum_edition?: number; /** * @generated from protobuf field: repeated google.protobuf.compiler.CodeGeneratorResponse.File file = 15 */ @@ -225,6 +238,33 @@ export interface CodeGeneratorResponse_File { * @generated from protobuf field: optional string content = 15 */ content?: string; + /** + * Information describing the file content being inserted. If an insertion + * point is used, this information will be appropriately offset and inserted + * into the code generation metadata for the generated files. + * + * @generated from protobuf field: optional google.protobuf.GeneratedCodeInfo generated_code_info = 16 + */ + generated_code_info?: GeneratedCodeInfo; +} +/** + * Sync with code_generator.h. + * + * @generated from protobuf enum google.protobuf.compiler.CodeGeneratorResponse.Feature + */ +export enum CodeGeneratorResponse_Feature { + /** + * @generated from protobuf enum value: FEATURE_NONE = 0; + */ + FEATURE_NONE = 0, + /** + * @generated from protobuf enum value: FEATURE_PROTO3_OPTIONAL = 1; + */ + FEATURE_PROTO3_OPTIONAL = 1, + /** + * @generated from protobuf enum value: FEATURE_SUPPORTS_EDITIONS = 2; + */ + FEATURE_SUPPORTS_EDITIONS = 2 } // @generated message type with reflection information, may provide speed optimized methods class Version$Type extends MessageType { @@ -300,6 +340,7 @@ class CodeGeneratorRequest$Type extends MessageType { { no: 1, name: "file_to_generate", kind: "scalar", localName: "file_to_generate", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }, { no: 2, name: "parameter", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, { no: 15, name: "proto_file", kind: "message", localName: "proto_file", repeat: 2 /*RepeatType.UNPACKED*/, T: () => FileDescriptorProto }, + { no: 17, name: "source_file_descriptors", kind: "message", localName: "source_file_descriptors", repeat: 2 /*RepeatType.UNPACKED*/, T: () => FileDescriptorProto }, { no: 3, name: "compiler_version", kind: "message", localName: "compiler_version", T: () => Version } ]); } @@ -307,6 +348,7 @@ class CodeGeneratorRequest$Type extends MessageType { const message = globalThis.Object.create((this.messagePrototype!)); message.file_to_generate = []; message.proto_file = []; + message.source_file_descriptors = []; if (value !== undefined) reflectionMergePartial(this, message, value); return message; @@ -325,6 +367,9 @@ class CodeGeneratorRequest$Type extends MessageType { case /* repeated google.protobuf.FileDescriptorProto proto_file */ 15: message.proto_file.push(FileDescriptorProto.internalBinaryRead(reader, reader.uint32(), options)); break; + case /* repeated google.protobuf.FileDescriptorProto source_file_descriptors */ 17: + message.source_file_descriptors.push(FileDescriptorProto.internalBinaryRead(reader, reader.uint32(), options)); + break; case /* optional google.protobuf.compiler.Version compiler_version */ 3: message.compiler_version = Version.internalBinaryRead(reader, reader.uint32(), options, message.compiler_version); break; @@ -352,6 +397,9 @@ class CodeGeneratorRequest$Type extends MessageType { /* repeated google.protobuf.FileDescriptorProto proto_file = 15; */ for (let i = 0; i < message.proto_file.length; i++) FileDescriptorProto.internalBinaryWrite(message.proto_file[i], writer.tag(15, WireType.LengthDelimited).fork(), options).join(); + /* repeated google.protobuf.FileDescriptorProto source_file_descriptors = 17; */ + for (let i = 0; i < message.source_file_descriptors.length; i++) + FileDescriptorProto.internalBinaryWrite(message.source_file_descriptors[i], writer.tag(17, WireType.LengthDelimited).fork(), options).join(); let u = options.writeUnknownFields; if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); @@ -367,6 +415,9 @@ class CodeGeneratorResponse$Type extends MessageType { constructor() { super("google.protobuf.compiler.CodeGeneratorResponse", [ { no: 1, name: "error", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "supported_features", kind: "scalar", localName: "supported_features", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }, + { no: 3, name: "minimum_edition", kind: "scalar", localName: "minimum_edition", opt: true, T: 5 /*ScalarType.INT32*/ }, + { no: 4, name: "maximum_edition", kind: "scalar", localName: "maximum_edition", opt: true, T: 5 /*ScalarType.INT32*/ }, { no: 15, name: "file", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => CodeGeneratorResponse_File } ]); } @@ -385,6 +436,15 @@ class CodeGeneratorResponse$Type extends MessageType { case /* optional string error */ 1: message.error = reader.string(); break; + case /* optional uint64 supported_features */ 2: + message.supported_features = reader.uint64().toBigInt(); + break; + case /* optional int32 minimum_edition */ 3: + message.minimum_edition = reader.int32(); + break; + case /* optional int32 maximum_edition */ 4: + message.maximum_edition = reader.int32(); + break; case /* repeated google.protobuf.compiler.CodeGeneratorResponse.File file */ 15: message.file.push(CodeGeneratorResponse_File.internalBinaryRead(reader, reader.uint32(), options)); break; @@ -403,6 +463,15 @@ class CodeGeneratorResponse$Type extends MessageType { /* optional string error = 1; */ if (message.error !== undefined) writer.tag(1, WireType.LengthDelimited).string(message.error); + /* optional uint64 supported_features = 2; */ + if (message.supported_features !== undefined) + writer.tag(2, WireType.Varint).uint64(message.supported_features); + /* optional int32 minimum_edition = 3; */ + if (message.minimum_edition !== undefined) + writer.tag(3, WireType.Varint).int32(message.minimum_edition); + /* optional int32 maximum_edition = 4; */ + if (message.maximum_edition !== undefined) + writer.tag(4, WireType.Varint).int32(message.maximum_edition); /* repeated google.protobuf.compiler.CodeGeneratorResponse.File file = 15; */ for (let i = 0; i < message.file.length; i++) CodeGeneratorResponse_File.internalBinaryWrite(message.file[i], writer.tag(15, WireType.LengthDelimited).fork(), options).join(); @@ -422,7 +491,8 @@ class CodeGeneratorResponse_File$Type extends MessageType GeneratedCodeInfo } ]); } create(value?: PartialMessage): CodeGeneratorResponse_File { @@ -445,6 +515,9 @@ class CodeGeneratorResponse_File$Type extends MessageType= 128 are escaped. - * TODO(kenton): Base-64 encode? * * @generated from protobuf field: optional string default_value = 7 */ @@ -301,6 +407,32 @@ export interface FieldDescriptorProto { * @generated from protobuf field: optional google.protobuf.FieldOptions options = 8 */ options?: FieldOptions; + /** + * If true, this is a proto3 "optional". When a proto3 field is optional, it + * tracks presence regardless of field type. + * + * When proto3_optional is true, this field must belong to a oneof to signal + * to old proto3 clients that presence is tracked for this field. This oneof + * is known as a "synthetic" oneof, and this field must be its sole member + * (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs + * exist in the descriptor only, and do not generate any API. Synthetic oneofs + * must be ordered after all "real" oneofs. + * + * For message fields, proto3_optional doesn't create any semantic change, + * since non-repeated message fields always track presence. However it still + * indicates the semantic detail of whether the user wrote "optional" or not. + * This can be useful for round-tripping the .proto file. For consistency we + * give message fields a synthetic oneof also, even though it is not required + * to track presence. This is especially important because the parser can't + * tell if a field is a message or an enum, so it must always create a + * synthetic oneof. + * + * Proto2 optional fields do not set this flag, because they already indicate + * optional with `LABEL_OPTIONAL`. + * + * @generated from protobuf field: optional bool proto3_optional = 17 + */ + proto3_optional?: boolean; } /** * @generated from protobuf enum google.protobuf.FieldDescriptorProto.Type @@ -357,9 +489,10 @@ export enum FieldDescriptorProto_Type { TYPE_STRING = 9, /** * Tag-delimited aggregate. - * Group type is deprecated and not supported in proto3. However, Proto3 + * Group type is deprecated and not supported after google.protobuf. However, Proto3 * implementations should still be able to parse the group wire format and - * treat group fields as unknown fields. + * treat group fields as unknown fields. In Editions, the group wire format + * can be enabled via the `message_encoding` feature. * * @generated from protobuf enum value: TYPE_GROUP = 10; */ @@ -419,14 +552,18 @@ export enum FieldDescriptorProto_Label { * @generated from protobuf enum value: LABEL_OPTIONAL = 1; */ LABEL_OPTIONAL = 1, - /** - * @generated from protobuf enum value: LABEL_REQUIRED = 2; - */ - LABEL_REQUIRED = 2, /** * @generated from protobuf enum value: LABEL_REPEATED = 3; */ - LABEL_REPEATED = 3 + LABEL_REPEATED = 3, + /** + * The required label is only allowed in google.protobuf. In proto3 and Editions + * it's explicitly prohibited. In Editions, the `field_presence` feature + * can be used to get this behavior. + * + * @generated from protobuf enum value: LABEL_REQUIRED = 2; + */ + LABEL_REQUIRED = 2 } /** * Describes a oneof. @@ -476,6 +613,12 @@ export interface EnumDescriptorProto { * @generated from protobuf field: repeated string reserved_name = 5 */ reserved_name: string[]; + /** + * Support for `export` and `local` keywords on enums. + * + * @generated from protobuf field: optional google.protobuf.SymbolVisibility visibility = 6 + */ + visibility?: SymbolVisibility; } /** * Range of reserved numeric values. Reserved values may not be used by @@ -619,20 +762,20 @@ export interface FileOptions { */ java_package?: string; /** - * If set, all the classes from the .proto file are wrapped in a single - * outer class with the given name. This applies to both Proto1 - * (equivalent to the old "--one_java_file" option) and Proto2 (where - * a .proto always translates to a single class, but you may want to - * explicitly choose the class name). + * Controls the name of the wrapper Java class generated for the .proto file. + * That class will always contain the .proto file's getDescriptor() method as + * well as any top-level extensions defined in the .proto file. + * If java_multiple_files is disabled, then all the other classes from the + * .proto file will be nested inside the single wrapper outer class. * * @generated from protobuf field: optional string java_outer_classname = 8 */ java_outer_classname?: string; /** - * If set true, then the Java code generator will generate a separate .java + * If enabled, then the Java code generator will generate a separate .java * file for each top-level message, enum, and service defined in the .proto - * file. Thus, these types will *not* be nested inside the outer class - * named by java_outer_classname. However, the outer class will still be + * file. Thus, these types will *not* be nested inside the wrapper class + * named by java_outer_classname. However, the wrapper class will still be * generated to contain the file's getDescriptor() method as well as any * top-level extensions defined in the file. * @@ -647,12 +790,16 @@ export interface FileOptions { */ java_generate_equals_and_hash?: boolean; /** - * If set true, then the Java2 code generator will generate code that - * throws an exception whenever an attempt is made to assign a non-UTF-8 - * byte sequence to a string field. - * Message reflection will do the same. - * However, an extension field still accepts non-UTF-8 byte sequences. - * This option has no effect on when used with the lite runtime. + * A proto2 file can set this to true to opt in to UTF-8 checking for Java, + * which will throw an exception if invalid UTF-8 is parsed from the wire or + * assigned to a string field. + * + * TODO: clarify exactly what kinds of field types this option + * applies to, and update these docs accordingly. + * + * Proto3 files already perform these checks. Setting the option explicitly to + * false has no effect: it cannot be used to opt proto3 files out of UTF-8 + * checks. * * @generated from protobuf field: optional bool java_string_check_utf8 = 27 [default = false] */ @@ -694,10 +841,6 @@ export interface FileOptions { * @generated from protobuf field: optional bool py_generic_services = 18 [default = false] */ py_generic_services?: boolean; - /** - * @generated from protobuf field: optional bool php_generic_services = 42 [default = false] - */ - php_generic_services?: boolean; /** * Is this file deprecated? * Depending on the target platform, this can emit Deprecated annotations @@ -711,7 +854,7 @@ export interface FileOptions { * Enables the use of arenas for the proto messages in this file. This applies * only to generated classes for C++. * - * @generated from protobuf field: optional bool cc_enable_arenas = 31 [default = false] + * @generated from protobuf field: optional bool cc_enable_arenas = 31 [default = true] */ cc_enable_arenas?: boolean; /** @@ -767,6 +910,15 @@ export interface FileOptions { * @generated from protobuf field: optional string ruby_package = 45 */ ruby_package?: string; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from protobuf field: optional google.protobuf.FeatureSet features = 50 + */ + features?: FeatureSet; /** * The parser stores options it doesn't recognize here. * See the documentation for the "Options" section above. @@ -876,6 +1028,31 @@ export interface MessageOptions { * @generated from protobuf field: optional bool map_entry = 7 */ map_entry?: boolean; + /** + * Enable the legacy handling of JSON field name conflicts. This lowercases + * and strips underscored from the fields before comparison in proto3 only. + * The new behavior takes `json_name` into account and applies to proto2 as + * well. + * + * This should only be used as a temporary measure against broken builds due + * to the change in behavior for JSON field name conflicts. + * + * TODO This is legacy behavior we plan to remove once downstream + * teams have had time to migrate. + * + * @deprecated + * @generated from protobuf field: optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true] + */ + deprecated_legacy_json_field_conflicts?: boolean; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from protobuf field: optional google.protobuf.FeatureSet features = 12 + */ + features?: FeatureSet; /** * The parser stores options it doesn't recognize here. See above. * @@ -888,10 +1065,13 @@ export interface MessageOptions { */ export interface FieldOptions { /** + * NOTE: ctype is deprecated. Use `features.(pb.cpp).string_type` instead. * The ctype option instructs the C++ code generator to use a different * representation of the field than it normally would. See the specific - * options below. This option is not yet implemented in the open source - * release -- sorry, we'll try to include it in a future version! + * options below. This option is only implemented to support use of + * [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of + * type "bytes" in the open source release. + * TODO: make ctype actually deprecated. * * @generated from protobuf field: optional google.protobuf.FieldOptions.CType ctype = 1 [default = STRING] */ @@ -901,7 +1081,9 @@ export interface FieldOptions { * a more efficient representation on the wire. Rather than repeatedly * writing the tag and type for each element, the entire array is encoded as * a single length-delimited blob. In proto3, only explicit setting it to - * false will avoid using packed encoding. + * false will avoid using packed encoding. This option is prohibited in + * Editions, but the `repeated_field_encoding` feature can be used to control + * the behavior. * * @generated from protobuf field: optional bool packed = 2 */ @@ -940,21 +1122,23 @@ export interface FieldOptions { * call from multiple threads concurrently, while non-const methods continue * to require exclusive access. * - * - * Note that implementations may choose not to check required fields within - * a lazy sub-message. That is, calling IsInitialized() on the outer message - * may return true even if the inner message has missing required fields. - * This is necessary because otherwise the inner message would have to be - * parsed in order to perform the check, defeating the purpose of lazy - * parsing. An implementation which chooses not to check required fields - * must be consistent about it. That is, for any particular sub-message, the - * implementation must either *always* check its required fields, or *never* - * check its required fields, regardless of whether or not the message has - * been parsed. + * Note that lazy message fields are still eagerly verified to check + * ill-formed wireformat or missing required fields. Calling IsInitialized() + * on the outer message would fail if the inner message has missing required + * fields. Failed verification would result in parsing failure (except when + * uninitialized messages are acceptable). * * @generated from protobuf field: optional bool lazy = 5 [default = false] */ lazy?: boolean; + /** + * unverified_lazy does no correctness checks on the byte stream. This should + * only be used where lazy with verification is prohibitive for performance + * reasons. + * + * @generated from protobuf field: optional bool unverified_lazy = 15 [default = false] + */ + unverified_lazy?: boolean; /** * Is this field deprecated? * Depending on the target platform, this can emit Deprecated annotations @@ -965,11 +1149,45 @@ export interface FieldOptions { */ deprecated?: boolean; /** + * DEPRECATED. DO NOT USE! * For Google-internal migration only. Do not use. * - * @generated from protobuf field: optional bool weak = 10 [default = false] + * @deprecated + * @generated from protobuf field: optional bool weak = 10 [default = false, deprecated = true] */ weak?: boolean; + /** + * Indicate that the field value should not be printed out when using debug + * formats, e.g. when the field contains sensitive credentials. + * + * @generated from protobuf field: optional bool debug_redact = 16 [default = false] + */ + debug_redact?: boolean; + /** + * @generated from protobuf field: optional google.protobuf.FieldOptions.OptionRetention retention = 17 + */ + retention?: FieldOptions_OptionRetention; + /** + * @generated from protobuf field: repeated google.protobuf.FieldOptions.OptionTargetType targets = 19 + */ + targets: FieldOptions_OptionTargetType[]; + /** + * @generated from protobuf field: repeated google.protobuf.FieldOptions.EditionDefault edition_defaults = 20 + */ + edition_defaults: FieldOptions_EditionDefault[]; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from protobuf field: optional google.protobuf.FeatureSet features = 21 + */ + features?: FeatureSet; + /** + * @generated from protobuf field: optional google.protobuf.FieldOptions.FeatureSupport feature_support = 22 + */ + feature_support?: FieldOptions_FeatureSupport; /** * The parser stores options it doesn't recognize here. See above. * @@ -977,6 +1195,63 @@ export interface FieldOptions { */ uninterpreted_option: UninterpretedOption[]; } +/** + * @generated from protobuf message google.protobuf.FieldOptions.EditionDefault + */ +export interface FieldOptions_EditionDefault { + /** + * @generated from protobuf field: optional google.protobuf.Edition edition = 3 + */ + edition?: Edition; + /** + * @generated from protobuf field: optional string value = 2 + */ + value?: string; // Textproto value. +} +/** + * Information about the support window of a feature. + * + * @generated from protobuf message google.protobuf.FieldOptions.FeatureSupport + */ +export interface FieldOptions_FeatureSupport { + /** + * The edition that this feature was first available in. In editions + * earlier than this one, the default assigned to EDITION_LEGACY will be + * used, and proto files will not be able to override it. + * + * @generated from protobuf field: optional google.protobuf.Edition edition_introduced = 1 + */ + edition_introduced?: Edition; + /** + * The edition this feature becomes deprecated in. Using this after this + * edition may trigger warnings. + * + * @generated from protobuf field: optional google.protobuf.Edition edition_deprecated = 2 + */ + edition_deprecated?: Edition; + /** + * The deprecation warning text if this feature is used after the edition it + * was marked deprecated in. + * + * @generated from protobuf field: optional string deprecation_warning = 3 + */ + deprecation_warning?: string; + /** + * The edition this feature is no longer available in. In editions after + * this one, the last default assigned will be used, and proto files will + * not be able to override it. + * + * @generated from protobuf field: optional google.protobuf.Edition edition_removed = 4 + */ + edition_removed?: Edition; + /** + * The removal error text if this feature is used after the edition it was + * removed in. + * + * @generated from protobuf field: optional string removal_error = 5 + */ + removal_error?: string; +} /** * @generated from protobuf enum google.protobuf.FieldOptions.CType */ @@ -988,6 +1263,13 @@ export enum FieldOptions_CType { */ STRING = 0, /** + * The option [ctype=CORD] may be applied to a non-repeated field of type + * "bytes". It indicates that in C++, the data should be stored in a Cord + * instead of a string. For very large strings, this may reduce memory + * fragmentation. It may also allow better performance when parsing from a + * Cord, or when parsing with aliasing enabled, as the parsed Cord may then + * alias the original buffer. + * * @generated from protobuf enum value: CORD = 1; */ CORD = 1, @@ -1019,10 +1301,87 @@ export enum FieldOptions_JSType { */ JS_NUMBER = 2 } +/** + * If set to RETENTION_SOURCE, the option will be omitted from the binary. + * + * @generated from protobuf enum google.protobuf.FieldOptions.OptionRetention + */ +export enum FieldOptions_OptionRetention { + /** + * @generated from protobuf enum value: RETENTION_UNKNOWN = 0; + */ + RETENTION_UNKNOWN = 0, + /** + * @generated from protobuf enum value: RETENTION_RUNTIME = 1; + */ + RETENTION_RUNTIME = 1, + /** + * @generated from protobuf enum value: RETENTION_SOURCE = 2; + */ + RETENTION_SOURCE = 2 +} +/** + * This indicates the types of entities that the field may apply to when used + * as an option. If it is unset, then the field may be freely used as an + * option on any kind of entity. + * + * @generated from protobuf enum google.protobuf.FieldOptions.OptionTargetType + */ +export enum FieldOptions_OptionTargetType { + /** + * @generated from protobuf enum value: TARGET_TYPE_UNKNOWN = 0; + */ + TARGET_TYPE_UNKNOWN = 0, + /** + * @generated from protobuf enum value: TARGET_TYPE_FILE = 1; + */ + TARGET_TYPE_FILE = 1, + /** + * @generated from protobuf enum value: TARGET_TYPE_EXTENSION_RANGE = 2; + */ + TARGET_TYPE_EXTENSION_RANGE = 2, + /** + * @generated from protobuf enum value: TARGET_TYPE_MESSAGE = 3; + */ + TARGET_TYPE_MESSAGE = 3, + /** + * @generated from protobuf enum value: TARGET_TYPE_FIELD = 4; + */ + TARGET_TYPE_FIELD = 4, + /** + * @generated from protobuf enum value: TARGET_TYPE_ONEOF = 5; + */ + TARGET_TYPE_ONEOF = 5, + /** + * @generated from protobuf enum value: TARGET_TYPE_ENUM = 6; + */ + TARGET_TYPE_ENUM = 6, + /** + * @generated from protobuf enum value: TARGET_TYPE_ENUM_ENTRY = 7; + */ + TARGET_TYPE_ENUM_ENTRY = 7, + /** + * @generated from protobuf enum value: TARGET_TYPE_SERVICE = 8; + */ + TARGET_TYPE_SERVICE = 8, + /** + * @generated from protobuf enum value: TARGET_TYPE_METHOD = 9; + */ + TARGET_TYPE_METHOD = 9 +} /** * @generated from protobuf message google.protobuf.OneofOptions */ export interface OneofOptions { + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from protobuf field: optional google.protobuf.FeatureSet features = 1 + */ + features?: FeatureSet; /** * The parser stores options it doesn't recognize here. See above. * @@ -1050,6 +1409,27 @@ export interface EnumOptions { * @generated from protobuf field: optional bool deprecated = 3 [default = false] */ deprecated?: boolean; + /** + * Enable the legacy handling of JSON field name conflicts. This lowercases + * and strips underscored from the fields before comparison in proto3 only. + * The new behavior takes `json_name` into account and applies to proto2 as + * well. + * TODO Remove this legacy behavior once downstream teams have + * had time to migrate. + * + * @deprecated + * @generated from protobuf field: optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true] + */ + deprecated_legacy_json_field_conflicts?: boolean; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from protobuf field: optional google.protobuf.FeatureSet features = 7 + */ + features?: FeatureSet; /** * The parser stores options it doesn't recognize here. See above. * @@ -1070,6 +1450,29 @@ export interface EnumValueOptions { * @generated from protobuf field: optional bool deprecated = 1 [default = false] */ deprecated?: boolean; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from protobuf field: optional google.protobuf.FeatureSet features = 2 + */ + features?: FeatureSet; + /** + * Indicate that fields annotated with this enum value should not be printed + * out when using debug formats, e.g. when the field contains sensitive + * credentials. + * + * @generated from protobuf field: optional bool debug_redact = 3 [default = false] + */ + debug_redact?: boolean; + /** + * Information about the support window of a feature value. + * + * @generated from protobuf field: optional google.protobuf.FieldOptions.FeatureSupport feature_support = 4 + */ + feature_support?: FieldOptions_FeatureSupport; /** * The parser stores options it doesn't recognize here. See above. * @@ -1081,6 +1484,15 @@ export interface EnumValueOptions { * @generated from protobuf message google.protobuf.ServiceOptions */ export interface ServiceOptions { + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from protobuf field: optional google.protobuf.FeatureSet features = 34 + */ + features?: FeatureSet; // Note: Field numbers 1 through 32 are reserved for Google's internal RPC // framework. We apologize for hoarding these numbers to ourselves, but // we were already using them long before we decided to release Protocol @@ -1124,6 +1536,15 @@ export interface MethodOptions { * @generated from protobuf field: optional google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN] */ idempotency_level?: MethodOptions_IdempotencyLevel; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from protobuf field: optional google.protobuf.FeatureSet features = 35 + */ + features?: FeatureSet; /** * The parser stores options it doesn't recognize here. See above. * @@ -1203,8 +1624,8 @@ export interface UninterpretedOption { * The name of the uninterpreted option. Each string represents a segment in * a dot-separated name. is_extension is true iff a segment represents an * extension (denoted with parentheses in options specs in .proto files). - * E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents - * "foo.(bar.baz).qux". + * E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents + * "foo.(bar.baz).moo". * * @generated from protobuf message google.protobuf.UninterpretedOption.NamePart */ @@ -1219,6 +1640,270 @@ export interface UninterpretedOption_NamePart { is_extension: boolean; } // =================================================================== +// Features + +/** + * TODO Enums in C++ gencode (and potentially other languages) are + * not well scoped. This means that each of the feature enums below can clash + * with each other. The short names we've chosen maximize call-site + * readability, but leave us very open to this scenario. A future feature will + * be designed and implemented to handle this, hopefully before we ever hit a + * conflict here. + * + * @generated from protobuf message google.protobuf.FeatureSet + */ +export interface FeatureSet { + /** + * @generated from protobuf field: optional google.protobuf.FeatureSet.FieldPresence field_presence = 1 + */ + field_presence?: FeatureSet_FieldPresence; + /** + * @generated from protobuf field: optional google.protobuf.FeatureSet.EnumType enum_type = 2 + */ + enum_type?: FeatureSet_EnumType; + /** + * @generated from protobuf field: optional google.protobuf.FeatureSet.RepeatedFieldEncoding repeated_field_encoding = 3 + */ + repeated_field_encoding?: FeatureSet_RepeatedFieldEncoding; + /** + * @generated from protobuf field: optional google.protobuf.FeatureSet.Utf8Validation utf8_validation = 4 + */ + utf8_validation?: FeatureSet_Utf8Validation; + /** + * @generated from protobuf field: optional google.protobuf.FeatureSet.MessageEncoding message_encoding = 5 + */ + message_encoding?: FeatureSet_MessageEncoding; + /** + * @generated from protobuf field: optional google.protobuf.FeatureSet.JsonFormat json_format = 6 + */ + json_format?: FeatureSet_JsonFormat; + /** + * @generated from protobuf field: optional google.protobuf.FeatureSet.EnforceNamingStyle enforce_naming_style = 7 + */ + enforce_naming_style?: FeatureSet_EnforceNamingStyle; + /** + * @generated from protobuf field: optional google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility default_symbol_visibility = 8 + */ + default_symbol_visibility?: FeatureSet_VisibilityFeature_DefaultSymbolVisibility; +} +/** + * @generated from protobuf message google.protobuf.FeatureSet.VisibilityFeature + */ +export interface FeatureSet_VisibilityFeature { +} +/** + * @generated from protobuf enum google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility + */ +export enum FeatureSet_VisibilityFeature_DefaultSymbolVisibility { + /** + * @generated from protobuf enum value: DEFAULT_SYMBOL_VISIBILITY_UNKNOWN = 0; + */ + DEFAULT_SYMBOL_VISIBILITY_UNKNOWN = 0, + /** + * Default pre-EDITION_2024, all UNSET visibility are export. + * + * @generated from protobuf enum value: EXPORT_ALL = 1; + */ + EXPORT_ALL = 1, + /** + * All top-level symbols default to export, nested default to local. + * + * @generated from protobuf enum value: EXPORT_TOP_LEVEL = 2; + */ + EXPORT_TOP_LEVEL = 2, + /** + * All symbols default to local. + * + * @generated from protobuf enum value: LOCAL_ALL = 3; + */ + LOCAL_ALL = 3, + /** + * All symbols local by default. Nested types cannot be exported. + * With special case caveat for message { enum {} reserved 1 to max; } + * This is the recommended setting for new protos. + * + * @generated from protobuf enum value: STRICT = 4; + */ + STRICT = 4 +} +/** + * @generated from protobuf enum google.protobuf.FeatureSet.FieldPresence + */ +export enum FeatureSet_FieldPresence { + /** + * @generated from protobuf enum value: FIELD_PRESENCE_UNKNOWN = 0; + */ + FIELD_PRESENCE_UNKNOWN = 0, + /** + * @generated from protobuf enum value: EXPLICIT = 1; + */ + EXPLICIT = 1, + /** + * @generated from protobuf enum value: IMPLICIT = 2; + */ + IMPLICIT = 2, + /** + * @generated from protobuf enum value: LEGACY_REQUIRED = 3; + */ + LEGACY_REQUIRED = 3 +} +/** + * @generated from protobuf enum google.protobuf.FeatureSet.EnumType + */ +export enum FeatureSet_EnumType { + /** + * @generated from protobuf enum value: ENUM_TYPE_UNKNOWN = 0; + */ + ENUM_TYPE_UNKNOWN = 0, + /** + * @generated from protobuf enum value: OPEN = 1; + */ + OPEN = 1, + /** + * @generated from protobuf enum value: CLOSED = 2; + */ + CLOSED = 2 +} +/** + * @generated from protobuf enum google.protobuf.FeatureSet.RepeatedFieldEncoding + */ +export enum FeatureSet_RepeatedFieldEncoding { + /** + * @generated from protobuf enum value: REPEATED_FIELD_ENCODING_UNKNOWN = 0; + */ + REPEATED_FIELD_ENCODING_UNKNOWN = 0, + /** + * @generated from protobuf enum value: PACKED = 1; + */ + PACKED = 1, + /** + * @generated from protobuf enum value: EXPANDED = 2; + */ + EXPANDED = 2 +} +/** + * @generated from protobuf enum google.protobuf.FeatureSet.Utf8Validation + */ +export enum FeatureSet_Utf8Validation { + /** + * @generated from protobuf enum value: UTF8_VALIDATION_UNKNOWN = 0; + */ + UTF8_VALIDATION_UNKNOWN = 0, + /** + * @generated from protobuf enum value: VERIFY = 2; + */ + VERIFY = 2, + /** + * @generated from protobuf enum value: NONE = 3; + */ + NONE = 3 +} +/** + * @generated from protobuf enum google.protobuf.FeatureSet.MessageEncoding + */ +export enum FeatureSet_MessageEncoding { + /** + * @generated from protobuf enum value: MESSAGE_ENCODING_UNKNOWN = 0; + */ + MESSAGE_ENCODING_UNKNOWN = 0, + /** + * @generated from protobuf enum value: LENGTH_PREFIXED = 1; + */ + LENGTH_PREFIXED = 1, + /** + * @generated from protobuf enum value: DELIMITED = 2; + */ + DELIMITED = 2 +} +/** + * @generated from protobuf enum google.protobuf.FeatureSet.JsonFormat + */ +export enum FeatureSet_JsonFormat { + /** + * @generated from protobuf enum value: JSON_FORMAT_UNKNOWN = 0; + */ + JSON_FORMAT_UNKNOWN = 0, + /** + * @generated from protobuf enum value: ALLOW = 1; + */ + ALLOW = 1, + /** + * @generated from protobuf enum value: LEGACY_BEST_EFFORT = 2; + */ + LEGACY_BEST_EFFORT = 2 +} +/** + * @generated from protobuf enum google.protobuf.FeatureSet.EnforceNamingStyle + */ +export enum FeatureSet_EnforceNamingStyle { + /** + * @generated from protobuf enum value: ENFORCE_NAMING_STYLE_UNKNOWN = 0; + */ + ENFORCE_NAMING_STYLE_UNKNOWN = 0, + /** + * @generated from protobuf enum value: STYLE2024 = 1; + */ + STYLE2024 = 1, + /** + * @generated from protobuf enum value: STYLE_LEGACY = 2; + */ + STYLE_LEGACY = 2 +} +/** + * A compiled specification for the defaults of a set of features. These + * messages are generated from FeatureSet extensions and can be used to seed + * feature resolution. The resolution with this object becomes a simple search + * for the closest matching edition, followed by proto merges. + * + * @generated from protobuf message google.protobuf.FeatureSetDefaults + */ +export interface FeatureSetDefaults { + /** + * @generated from protobuf field: repeated google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults = 1 + */ + defaults: FeatureSetDefaults_FeatureSetEditionDefault[]; + /** + * The minimum supported edition (inclusive) when this was constructed. + * Editions before this will not have defaults. + * + * @generated from protobuf field: optional google.protobuf.Edition minimum_edition = 4 + */ + minimum_edition?: Edition; + /** + * The maximum known edition (inclusive) when this was constructed. Editions + * after this will not have reliable defaults. + * + * @generated from protobuf field: optional google.protobuf.Edition maximum_edition = 5 + */ + maximum_edition?: Edition; +} +/** + * A map from every known edition with a unique set of defaults to its + * defaults. Not all editions may be contained here. For a given edition, + * the defaults at the closest matching edition ordered at or before it should + * be used. This field must be in strict ascending order by edition. + * + * @generated from protobuf message google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault + */ +export interface FeatureSetDefaults_FeatureSetEditionDefault { + /** + * @generated from protobuf field: optional google.protobuf.Edition edition = 3 + */ + edition?: Edition; + /** + * Defaults of features that can be overridden in this edition. + * + * @generated from protobuf field: optional google.protobuf.FeatureSet overridable_features = 4 + */ + overridable_features?: FeatureSet; + /** + * Defaults of features that can't be overridden in this edition. + * + * @generated from protobuf field: optional google.protobuf.FeatureSet fixed_features = 5 + */ + fixed_features?: FeatureSet; +} +// =================================================================== // Optional source code info /** @@ -1286,8 +1971,8 @@ export interface SourceCodeInfo_Location { * location. * * Each element is a field number or an index. They form a path from - * the root FileDescriptorProto to the place where the definition. For - * example, this path: + * the root FileDescriptorProto to the place where the definition appears. + * For example, this path: * [ 4, 3, 2, 7, 1 ] * refers to: * file.message_type(3) // 4, 3 @@ -1347,13 +2032,13 @@ export interface SourceCodeInfo_Location { * // Comment attached to baz. * // Another line attached to baz. * - * // Comment attached to qux. + * // Comment attached to moo. * // - * // Another line attached to qux. - * optional double qux = 4; + * // Another line attached to moo. + * optional double moo = 4; * * // Detached comment for corge. This is not leading or trailing comments - * // to qux or corge because there are blank lines separating it from + * // to moo or corge because there are blank lines separating it from * // both. * * // Detached comment for corge paragraph 2. @@ -1422,12 +2107,147 @@ export interface GeneratedCodeInfo_Annotation { begin?: number; /** * Identifies the ending offset in bytes in the generated code that - * relates to the identified offset. The end offset should be one past + * relates to the identified object. The end offset should be one past * the last relevant byte (so the length of the text = end - begin). * * @generated from protobuf field: optional int32 end = 4 */ end?: number; + /** + * @generated from protobuf field: optional google.protobuf.GeneratedCodeInfo.Annotation.Semantic semantic = 5 + */ + semantic?: GeneratedCodeInfo_Annotation_Semantic; +} +/** + * Represents the identified object's effect on the element in the original + * .proto file. + * + * @generated from protobuf enum google.protobuf.GeneratedCodeInfo.Annotation.Semantic + */ +export enum GeneratedCodeInfo_Annotation_Semantic { + /** + * There is no effect or the effect is indescribable. + * + * @generated from protobuf enum value: NONE = 0; + */ + NONE = 0, + /** + * The element is set or otherwise mutated. + * + * @generated from protobuf enum value: SET = 1; + */ + SET = 1, + /** + * An alias to the element is returned. + * + * @generated from protobuf enum value: ALIAS = 2; + */ + ALIAS = 2 +} +/** + * The full set of known editions. + * + * @generated from protobuf enum google.protobuf.Edition + */ +export enum Edition { + /** + * A placeholder for an unknown edition value. + * + * @generated from protobuf enum value: EDITION_UNKNOWN = 0; + */ + EDITION_UNKNOWN = 0, + /** + * A placeholder edition for specifying default behaviors *before* a feature + * was first introduced. This is effectively an "infinite past". + * + * @generated from protobuf enum value: EDITION_LEGACY = 900; + */ + EDITION_LEGACY = 900, + /** + * Legacy syntax "editions". These pre-date editions, but behave much like + * distinct editions. These can't be used to specify the edition of proto + * files, but feature definitions must supply proto2/proto3 defaults for + * backwards compatibility. + * + * @generated from protobuf enum value: EDITION_PROTO2 = 998; + */ + EDITION_PROTO2 = 998, + /** + * @generated from protobuf enum value: EDITION_PROTO3 = 999; + */ + EDITION_PROTO3 = 999, + /** + * Editions that have been released. The specific values are arbitrary and + * should not be depended on, but they will always be time-ordered for easy + * comparison. + * + * @generated from protobuf enum value: EDITION_2023 = 1000; + */ + EDITION_2023 = 1000, + /** + * @generated from protobuf enum value: EDITION_2024 = 1001; + */ + EDITION_2024 = 1001, + /** + * A placeholder edition for developing and testing unscheduled features. + * + * @generated from protobuf enum value: EDITION_UNSTABLE = 9999; + */ + EDITION_UNSTABLE = 9999, + /** + * Placeholder editions for testing feature resolution. These should not be + * used or relied on outside of tests. + * + * @generated from protobuf enum value: EDITION_1_TEST_ONLY = 1; + */ + EDITION_1_TEST_ONLY = 1, + /** + * @generated from protobuf enum value: EDITION_2_TEST_ONLY = 2; + */ + EDITION_2_TEST_ONLY = 2, + /** + * @generated from protobuf enum value: EDITION_99997_TEST_ONLY = 99997; + */ + EDITION_99997_TEST_ONLY = 99997, + /** + * @generated from protobuf enum value: EDITION_99998_TEST_ONLY = 99998; + */ + EDITION_99998_TEST_ONLY = 99998, + /** + * @generated from protobuf enum value: EDITION_99999_TEST_ONLY = 99999; + */ + EDITION_99999_TEST_ONLY = 99999, + /** + * Placeholder for specifying unbounded edition support. This should only + * ever be used by plugins that can expect to never require any changes to + * support a new edition. + * + * @generated from protobuf enum value: EDITION_MAX = 2147483647; + */ + EDITION_MAX = 2147483647 +} +/** + * Describes the 'visibility' of a symbol with respect to the proto import + * system. Symbols can only be imported when the visibility rules do not prevent + * it (ex: local symbols cannot be imported). Visibility modifiers can only set + * on `message` and `enum` as they are the only types available to be referenced + * from other files. + * + * @generated from protobuf enum google.protobuf.SymbolVisibility + */ +export enum SymbolVisibility { + /** + * @generated from protobuf enum value: VISIBILITY_UNSET = 0; + */ + VISIBILITY_UNSET = 0, + /** + * @generated from protobuf enum value: VISIBILITY_LOCAL = 1; + */ + VISIBILITY_LOCAL = 1, + /** + * @generated from protobuf enum value: VISIBILITY_EXPORT = 2; + */ + VISIBILITY_EXPORT = 2 } // @generated message type with reflection information, may provide speed optimized methods class FileDescriptorSet$Type extends MessageType { @@ -1485,13 +2305,15 @@ class FileDescriptorProto$Type extends MessageType { { no: 3, name: "dependency", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }, { no: 10, name: "public_dependency", kind: "scalar", localName: "public_dependency", repeat: 2 /*RepeatType.UNPACKED*/, T: 5 /*ScalarType.INT32*/ }, { no: 11, name: "weak_dependency", kind: "scalar", localName: "weak_dependency", repeat: 2 /*RepeatType.UNPACKED*/, T: 5 /*ScalarType.INT32*/ }, + { no: 15, name: "option_dependency", kind: "scalar", localName: "option_dependency", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }, { no: 4, name: "message_type", kind: "message", localName: "message_type", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DescriptorProto }, { no: 5, name: "enum_type", kind: "message", localName: "enum_type", repeat: 2 /*RepeatType.UNPACKED*/, T: () => EnumDescriptorProto }, { no: 6, name: "service", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ServiceDescriptorProto }, { no: 7, name: "extension", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => FieldDescriptorProto }, { no: 8, name: "options", kind: "message", T: () => FileOptions }, { no: 9, name: "source_code_info", kind: "message", localName: "source_code_info", T: () => SourceCodeInfo }, - { no: 12, name: "syntax", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ } + { no: 12, name: "syntax", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, + { no: 14, name: "edition", kind: "enum", opt: true, T: () => ["google.protobuf.Edition", Edition] } ]); } create(value?: PartialMessage): FileDescriptorProto { @@ -1499,6 +2321,7 @@ class FileDescriptorProto$Type extends MessageType { message.dependency = []; message.public_dependency = []; message.weak_dependency = []; + message.option_dependency = []; message.message_type = []; message.enum_type = []; message.service = []; @@ -1535,6 +2358,9 @@ class FileDescriptorProto$Type extends MessageType { else message.weak_dependency.push(reader.int32()); break; + case /* repeated string option_dependency */ 15: + message.option_dependency.push(reader.string()); + break; case /* repeated google.protobuf.DescriptorProto message_type */ 4: message.message_type.push(DescriptorProto.internalBinaryRead(reader, reader.uint32(), options)); break; @@ -1556,6 +2382,9 @@ class FileDescriptorProto$Type extends MessageType { case /* optional string syntax */ 12: message.syntax = reader.string(); break; + case /* optional google.protobuf.Edition edition */ 14: + message.edition = reader.int32(); + break; default: let u = options.readUnknownField; if (u === "throw") @@ -1604,6 +2433,12 @@ class FileDescriptorProto$Type extends MessageType { /* optional string syntax = 12; */ if (message.syntax !== undefined) writer.tag(12, WireType.LengthDelimited).string(message.syntax); + /* optional google.protobuf.Edition edition = 14; */ + if (message.edition !== undefined) + writer.tag(14, WireType.Varint).int32(message.edition); + /* repeated string option_dependency = 15; */ + for (let i = 0; i < message.option_dependency.length; i++) + writer.tag(15, WireType.LengthDelimited).string(message.option_dependency[i]); let u = options.writeUnknownFields; if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); @@ -1627,7 +2462,8 @@ class DescriptorProto$Type extends MessageType { { no: 8, name: "oneof_decl", kind: "message", localName: "oneof_decl", repeat: 2 /*RepeatType.UNPACKED*/, T: () => OneofDescriptorProto }, { no: 7, name: "options", kind: "message", T: () => MessageOptions }, { no: 9, name: "reserved_range", kind: "message", localName: "reserved_range", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DescriptorProto_ReservedRange }, - { no: 10, name: "reserved_name", kind: "scalar", localName: "reserved_name", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ } + { no: 10, name: "reserved_name", kind: "scalar", localName: "reserved_name", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }, + { no: 11, name: "visibility", kind: "enum", opt: true, T: () => ["google.protobuf.SymbolVisibility", SymbolVisibility] } ]); } create(value?: PartialMessage): DescriptorProto { @@ -1679,6 +2515,9 @@ class DescriptorProto$Type extends MessageType { case /* repeated string reserved_name */ 10: message.reserved_name.push(reader.string()); break; + case /* optional google.protobuf.SymbolVisibility visibility */ 11: + message.visibility = reader.int32(); + break; default: let u = options.readUnknownField; if (u === "throw") @@ -1721,6 +2560,9 @@ class DescriptorProto$Type extends MessageType { /* repeated string reserved_name = 10; */ for (let i = 0; i < message.reserved_name.length; i++) writer.tag(10, WireType.LengthDelimited).string(message.reserved_name[i]); + /* optional google.protobuf.SymbolVisibility visibility = 11; */ + if (message.visibility !== undefined) + writer.tag(11, WireType.Varint).int32(message.visibility); let u = options.writeUnknownFields; if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); @@ -1848,12 +2690,16 @@ export const DescriptorProto_ReservedRange = new DescriptorProto_ReservedRange$T class ExtensionRangeOptions$Type extends MessageType { constructor() { super("google.protobuf.ExtensionRangeOptions", [ - { no: 999, name: "uninterpreted_option", kind: "message", localName: "uninterpreted_option", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } + { no: 999, name: "uninterpreted_option", kind: "message", localName: "uninterpreted_option", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption }, + { no: 2, name: "declaration", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ExtensionRangeOptions_Declaration }, + { no: 50, name: "features", kind: "message", T: () => FeatureSet }, + { no: 3, name: "verification", kind: "enum", opt: true, T: () => ["google.protobuf.ExtensionRangeOptions.VerificationState", ExtensionRangeOptions_VerificationState] } ]); } create(value?: PartialMessage): ExtensionRangeOptions { const message = globalThis.Object.create((this.messagePrototype!)); message.uninterpreted_option = []; + message.declaration = []; if (value !== undefined) reflectionMergePartial(this, message, value); return message; @@ -1866,6 +2712,15 @@ class ExtensionRangeOptions$Type extends MessageType { case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: message.uninterpreted_option.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); break; + case /* repeated google.protobuf.ExtensionRangeOptions.Declaration declaration */ 2: + message.declaration.push(ExtensionRangeOptions_Declaration.internalBinaryRead(reader, reader.uint32(), options)); + break; + case /* optional google.protobuf.FeatureSet features */ 50: + message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); + break; + case /* optional google.protobuf.ExtensionRangeOptions.VerificationState verification = 3 [default = UNVERIFIED] */ 3: + message.verification = reader.int32(); + break; default: let u = options.readUnknownField; if (u === "throw") @@ -1878,6 +2733,15 @@ class ExtensionRangeOptions$Type extends MessageType { return message; } internalBinaryWrite(message: ExtensionRangeOptions, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* repeated google.protobuf.ExtensionRangeOptions.Declaration declaration = 2; */ + for (let i = 0; i < message.declaration.length; i++) + ExtensionRangeOptions_Declaration.internalBinaryWrite(message.declaration[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + /* optional google.protobuf.ExtensionRangeOptions.VerificationState verification = 3 [default = UNVERIFIED]; */ + if (message.verification !== undefined) + writer.tag(3, WireType.Varint).int32(message.verification); + /* optional google.protobuf.FeatureSet features = 50; */ + if (message.features) + FeatureSet.internalBinaryWrite(message.features, writer.tag(50, WireType.LengthDelimited).fork(), options).join(); /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ for (let i = 0; i < message.uninterpreted_option.length; i++) UninterpretedOption.internalBinaryWrite(message.uninterpreted_option[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); @@ -1892,6 +2756,80 @@ class ExtensionRangeOptions$Type extends MessageType { */ export const ExtensionRangeOptions = new ExtensionRangeOptions$Type(); // @generated message type with reflection information, may provide speed optimized methods +class ExtensionRangeOptions_Declaration$Type extends MessageType { + constructor() { + super("google.protobuf.ExtensionRangeOptions.Declaration", [ + { no: 1, name: "number", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ }, + { no: 2, name: "full_name", kind: "scalar", localName: "full_name", opt: true, T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "type", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, + { no: 5, name: "reserved", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, + { no: 6, name: "repeated", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ } + ]); + } + create(value?: PartialMessage): ExtensionRangeOptions_Declaration { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExtensionRangeOptions_Declaration): ExtensionRangeOptions_Declaration { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* optional int32 number */ 1: + message.number = reader.int32(); + break; + case /* optional string full_name */ 2: + message.full_name = reader.string(); + break; + case /* optional string type */ 3: + message.type = reader.string(); + break; + case /* optional bool reserved */ 5: + message.reserved = reader.bool(); + break; + case /* optional bool repeated */ 6: + message.repeated = reader.bool(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: ExtensionRangeOptions_Declaration, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* optional int32 number = 1; */ + if (message.number !== undefined) + writer.tag(1, WireType.Varint).int32(message.number); + /* optional string full_name = 2; */ + if (message.full_name !== undefined) + writer.tag(2, WireType.LengthDelimited).string(message.full_name); + /* optional string type = 3; */ + if (message.type !== undefined) + writer.tag(3, WireType.LengthDelimited).string(message.type); + /* optional bool reserved = 5; */ + if (message.reserved !== undefined) + writer.tag(5, WireType.Varint).bool(message.reserved); + /* optional bool repeated = 6; */ + if (message.repeated !== undefined) + writer.tag(6, WireType.Varint).bool(message.repeated); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message google.protobuf.ExtensionRangeOptions.Declaration + */ +export const ExtensionRangeOptions_Declaration = new ExtensionRangeOptions_Declaration$Type(); +// @generated message type with reflection information, may provide speed optimized methods class FieldDescriptorProto$Type extends MessageType { constructor() { super("google.protobuf.FieldDescriptorProto", [ @@ -1904,7 +2842,8 @@ class FieldDescriptorProto$Type extends MessageType { { no: 7, name: "default_value", kind: "scalar", localName: "default_value", opt: true, T: 9 /*ScalarType.STRING*/ }, { no: 9, name: "oneof_index", kind: "scalar", localName: "oneof_index", opt: true, T: 5 /*ScalarType.INT32*/ }, { no: 10, name: "json_name", kind: "scalar", localName: "json_name", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 8, name: "options", kind: "message", T: () => FieldOptions } + { no: 8, name: "options", kind: "message", T: () => FieldOptions }, + { no: 17, name: "proto3_optional", kind: "scalar", localName: "proto3_optional", opt: true, T: 8 /*ScalarType.BOOL*/ } ]); } create(value?: PartialMessage): FieldDescriptorProto { @@ -1948,6 +2887,9 @@ class FieldDescriptorProto$Type extends MessageType { case /* optional google.protobuf.FieldOptions options */ 8: message.options = FieldOptions.internalBinaryRead(reader, reader.uint32(), options, message.options); break; + case /* optional bool proto3_optional */ 17: + message.proto3_optional = reader.bool(); + break; default: let u = options.readUnknownField; if (u === "throw") @@ -1990,6 +2932,9 @@ class FieldDescriptorProto$Type extends MessageType { /* optional string json_name = 10; */ if (message.json_name !== undefined) writer.tag(10, WireType.LengthDelimited).string(message.json_name); + /* optional bool proto3_optional = 17; */ + if (message.proto3_optional !== undefined) + writer.tag(17, WireType.Varint).bool(message.proto3_optional); let u = options.writeUnknownFields; if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); @@ -2061,7 +3006,8 @@ class EnumDescriptorProto$Type extends MessageType { { no: 2, name: "value", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => EnumValueDescriptorProto }, { no: 3, name: "options", kind: "message", T: () => EnumOptions }, { no: 4, name: "reserved_range", kind: "message", localName: "reserved_range", repeat: 2 /*RepeatType.UNPACKED*/, T: () => EnumDescriptorProto_EnumReservedRange }, - { no: 5, name: "reserved_name", kind: "scalar", localName: "reserved_name", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ } + { no: 5, name: "reserved_name", kind: "scalar", localName: "reserved_name", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }, + { no: 6, name: "visibility", kind: "enum", opt: true, T: () => ["google.protobuf.SymbolVisibility", SymbolVisibility] } ]); } create(value?: PartialMessage): EnumDescriptorProto { @@ -2093,6 +3039,9 @@ class EnumDescriptorProto$Type extends MessageType { case /* repeated string reserved_name */ 5: message.reserved_name.push(reader.string()); break; + case /* optional google.protobuf.SymbolVisibility visibility */ 6: + message.visibility = reader.int32(); + break; default: let u = options.readUnknownField; if (u === "throw") @@ -2120,6 +3069,9 @@ class EnumDescriptorProto$Type extends MessageType { /* repeated string reserved_name = 5; */ for (let i = 0; i < message.reserved_name.length; i++) writer.tag(5, WireType.LengthDelimited).string(message.reserved_name[i]); + /* optional google.protobuf.SymbolVisibility visibility = 6; */ + if (message.visibility !== undefined) + writer.tag(6, WireType.Varint).int32(message.visibility); let u = options.writeUnknownFields; if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); @@ -2399,7 +3351,6 @@ class FileOptions$Type extends MessageType { { no: 16, name: "cc_generic_services", kind: "scalar", localName: "cc_generic_services", opt: true, T: 8 /*ScalarType.BOOL*/ }, { no: 17, name: "java_generic_services", kind: "scalar", localName: "java_generic_services", opt: true, T: 8 /*ScalarType.BOOL*/ }, { no: 18, name: "py_generic_services", kind: "scalar", localName: "py_generic_services", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 42, name: "php_generic_services", kind: "scalar", localName: "php_generic_services", opt: true, T: 8 /*ScalarType.BOOL*/ }, { no: 23, name: "deprecated", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, { no: 31, name: "cc_enable_arenas", kind: "scalar", localName: "cc_enable_arenas", opt: true, T: 8 /*ScalarType.BOOL*/ }, { no: 36, name: "objc_class_prefix", kind: "scalar", localName: "objc_class_prefix", opt: true, T: 9 /*ScalarType.STRING*/ }, @@ -2409,6 +3360,7 @@ class FileOptions$Type extends MessageType { { no: 41, name: "php_namespace", kind: "scalar", localName: "php_namespace", opt: true, T: 9 /*ScalarType.STRING*/ }, { no: 44, name: "php_metadata_namespace", kind: "scalar", localName: "php_metadata_namespace", opt: true, T: 9 /*ScalarType.STRING*/ }, { no: 45, name: "ruby_package", kind: "scalar", localName: "ruby_package", opt: true, T: 9 /*ScalarType.STRING*/ }, + { no: 50, name: "features", kind: "message", T: () => FeatureSet }, { no: 999, name: "uninterpreted_option", kind: "message", localName: "uninterpreted_option", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } ]); } @@ -2454,13 +3406,10 @@ class FileOptions$Type extends MessageType { case /* optional bool py_generic_services = 18 [default = false] */ 18: message.py_generic_services = reader.bool(); break; - case /* optional bool php_generic_services = 42 [default = false] */ 42: - message.php_generic_services = reader.bool(); - break; case /* optional bool deprecated = 23 [default = false] */ 23: message.deprecated = reader.bool(); break; - case /* optional bool cc_enable_arenas = 31 [default = false] */ 31: + case /* optional bool cc_enable_arenas = 31 [default = true] */ 31: message.cc_enable_arenas = reader.bool(); break; case /* optional string objc_class_prefix */ 36: @@ -2484,6 +3433,9 @@ class FileOptions$Type extends MessageType { case /* optional string ruby_package */ 45: message.ruby_package = reader.string(); break; + case /* optional google.protobuf.FeatureSet features */ 50: + message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); + break; case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: message.uninterpreted_option.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); break; @@ -2532,7 +3484,7 @@ class FileOptions$Type extends MessageType { /* optional bool java_string_check_utf8 = 27 [default = false]; */ if (message.java_string_check_utf8 !== undefined) writer.tag(27, WireType.Varint).bool(message.java_string_check_utf8); - /* optional bool cc_enable_arenas = 31 [default = false]; */ + /* optional bool cc_enable_arenas = 31 [default = true]; */ if (message.cc_enable_arenas !== undefined) writer.tag(31, WireType.Varint).bool(message.cc_enable_arenas); /* optional string objc_class_prefix = 36; */ @@ -2550,15 +3502,15 @@ class FileOptions$Type extends MessageType { /* optional string php_namespace = 41; */ if (message.php_namespace !== undefined) writer.tag(41, WireType.LengthDelimited).string(message.php_namespace); - /* optional bool php_generic_services = 42 [default = false]; */ - if (message.php_generic_services !== undefined) - writer.tag(42, WireType.Varint).bool(message.php_generic_services); /* optional string php_metadata_namespace = 44; */ if (message.php_metadata_namespace !== undefined) writer.tag(44, WireType.LengthDelimited).string(message.php_metadata_namespace); /* optional string ruby_package = 45; */ if (message.ruby_package !== undefined) writer.tag(45, WireType.LengthDelimited).string(message.ruby_package); + /* optional google.protobuf.FeatureSet features = 50; */ + if (message.features) + FeatureSet.internalBinaryWrite(message.features, writer.tag(50, WireType.LengthDelimited).fork(), options).join(); /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ for (let i = 0; i < message.uninterpreted_option.length; i++) UninterpretedOption.internalBinaryWrite(message.uninterpreted_option[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); @@ -2580,6 +3532,8 @@ class MessageOptions$Type extends MessageType { { no: 2, name: "no_standard_descriptor_accessor", kind: "scalar", localName: "no_standard_descriptor_accessor", opt: true, T: 8 /*ScalarType.BOOL*/ }, { no: 3, name: "deprecated", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, { no: 7, name: "map_entry", kind: "scalar", localName: "map_entry", opt: true, T: 8 /*ScalarType.BOOL*/ }, + { no: 11, name: "deprecated_legacy_json_field_conflicts", kind: "scalar", localName: "deprecated_legacy_json_field_conflicts", opt: true, T: 8 /*ScalarType.BOOL*/ }, + { no: 12, name: "features", kind: "message", T: () => FeatureSet }, { no: 999, name: "uninterpreted_option", kind: "message", localName: "uninterpreted_option", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } ]); } @@ -2607,6 +3561,12 @@ class MessageOptions$Type extends MessageType { case /* optional bool map_entry */ 7: message.map_entry = reader.bool(); break; + case /* optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true] */ 11: + message.deprecated_legacy_json_field_conflicts = reader.bool(); + break; + case /* optional google.protobuf.FeatureSet features */ 12: + message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); + break; case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: message.uninterpreted_option.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); break; @@ -2634,6 +3594,12 @@ class MessageOptions$Type extends MessageType { /* optional bool map_entry = 7; */ if (message.map_entry !== undefined) writer.tag(7, WireType.Varint).bool(message.map_entry); + /* optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true]; */ + if (message.deprecated_legacy_json_field_conflicts !== undefined) + writer.tag(11, WireType.Varint).bool(message.deprecated_legacy_json_field_conflicts); + /* optional google.protobuf.FeatureSet features = 12; */ + if (message.features) + FeatureSet.internalBinaryWrite(message.features, writer.tag(12, WireType.LengthDelimited).fork(), options).join(); /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ for (let i = 0; i < message.uninterpreted_option.length; i++) UninterpretedOption.internalBinaryWrite(message.uninterpreted_option[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); @@ -2655,13 +3621,22 @@ class FieldOptions$Type extends MessageType { { no: 2, name: "packed", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, { no: 6, name: "jstype", kind: "enum", opt: true, T: () => ["google.protobuf.FieldOptions.JSType", FieldOptions_JSType] }, { no: 5, name: "lazy", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, + { no: 15, name: "unverified_lazy", kind: "scalar", localName: "unverified_lazy", opt: true, T: 8 /*ScalarType.BOOL*/ }, { no: 3, name: "deprecated", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, { no: 10, name: "weak", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, + { no: 16, name: "debug_redact", kind: "scalar", localName: "debug_redact", opt: true, T: 8 /*ScalarType.BOOL*/ }, + { no: 17, name: "retention", kind: "enum", opt: true, T: () => ["google.protobuf.FieldOptions.OptionRetention", FieldOptions_OptionRetention] }, + { no: 19, name: "targets", kind: "enum", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ["google.protobuf.FieldOptions.OptionTargetType", FieldOptions_OptionTargetType] }, + { no: 20, name: "edition_defaults", kind: "message", localName: "edition_defaults", repeat: 2 /*RepeatType.UNPACKED*/, T: () => FieldOptions_EditionDefault }, + { no: 21, name: "features", kind: "message", T: () => FeatureSet }, + { no: 22, name: "feature_support", kind: "message", localName: "feature_support", T: () => FieldOptions_FeatureSupport }, { no: 999, name: "uninterpreted_option", kind: "message", localName: "uninterpreted_option", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } ]); } create(value?: PartialMessage): FieldOptions { const message = globalThis.Object.create((this.messagePrototype!)); + message.targets = []; + message.edition_defaults = []; message.uninterpreted_option = []; if (value !== undefined) reflectionMergePartial(this, message, value); @@ -2684,12 +3659,37 @@ class FieldOptions$Type extends MessageType { case /* optional bool lazy = 5 [default = false] */ 5: message.lazy = reader.bool(); break; + case /* optional bool unverified_lazy = 15 [default = false] */ 15: + message.unverified_lazy = reader.bool(); + break; case /* optional bool deprecated = 3 [default = false] */ 3: message.deprecated = reader.bool(); break; - case /* optional bool weak = 10 [default = false] */ 10: + case /* optional bool weak = 10 [default = false, deprecated = true] */ 10: message.weak = reader.bool(); break; + case /* optional bool debug_redact = 16 [default = false] */ 16: + message.debug_redact = reader.bool(); + break; + case /* optional google.protobuf.FieldOptions.OptionRetention retention */ 17: + message.retention = reader.int32(); + break; + case /* repeated google.protobuf.FieldOptions.OptionTargetType targets */ 19: + if (wireType === WireType.LengthDelimited) + for (let e = reader.int32() + reader.pos; reader.pos < e;) + message.targets.push(reader.int32()); + else + message.targets.push(reader.int32()); + break; + case /* repeated google.protobuf.FieldOptions.EditionDefault edition_defaults */ 20: + message.edition_defaults.push(FieldOptions_EditionDefault.internalBinaryRead(reader, reader.uint32(), options)); + break; + case /* optional google.protobuf.FeatureSet features */ 21: + message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); + break; + case /* optional google.protobuf.FieldOptions.FeatureSupport feature_support */ 22: + message.feature_support = FieldOptions_FeatureSupport.internalBinaryRead(reader, reader.uint32(), options, message.feature_support); + break; case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: message.uninterpreted_option.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); break; @@ -2720,9 +3720,30 @@ class FieldOptions$Type extends MessageType { /* optional google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL]; */ if (message.jstype !== undefined) writer.tag(6, WireType.Varint).int32(message.jstype); - /* optional bool weak = 10 [default = false]; */ + /* optional bool weak = 10 [default = false, deprecated = true]; */ if (message.weak !== undefined) writer.tag(10, WireType.Varint).bool(message.weak); + /* optional bool unverified_lazy = 15 [default = false]; */ + if (message.unverified_lazy !== undefined) + writer.tag(15, WireType.Varint).bool(message.unverified_lazy); + /* optional bool debug_redact = 16 [default = false]; */ + if (message.debug_redact !== undefined) + writer.tag(16, WireType.Varint).bool(message.debug_redact); + /* optional google.protobuf.FieldOptions.OptionRetention retention = 17; */ + if (message.retention !== undefined) + writer.tag(17, WireType.Varint).int32(message.retention); + /* repeated google.protobuf.FieldOptions.OptionTargetType targets = 19; */ + for (let i = 0; i < message.targets.length; i++) + writer.tag(19, WireType.Varint).int32(message.targets[i]); + /* repeated google.protobuf.FieldOptions.EditionDefault edition_defaults = 20; */ + for (let i = 0; i < message.edition_defaults.length; i++) + FieldOptions_EditionDefault.internalBinaryWrite(message.edition_defaults[i], writer.tag(20, WireType.LengthDelimited).fork(), options).join(); + /* optional google.protobuf.FeatureSet features = 21; */ + if (message.features) + FeatureSet.internalBinaryWrite(message.features, writer.tag(21, WireType.LengthDelimited).fork(), options).join(); + /* optional google.protobuf.FieldOptions.FeatureSupport feature_support = 22; */ + if (message.feature_support) + FieldOptions_FeatureSupport.internalBinaryWrite(message.feature_support, writer.tag(22, WireType.LengthDelimited).fork(), options).join(); /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ for (let i = 0; i < message.uninterpreted_option.length; i++) UninterpretedOption.internalBinaryWrite(message.uninterpreted_option[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); @@ -2737,9 +3758,137 @@ class FieldOptions$Type extends MessageType { */ export const FieldOptions = new FieldOptions$Type(); // @generated message type with reflection information, may provide speed optimized methods +class FieldOptions_EditionDefault$Type extends MessageType { + constructor() { + super("google.protobuf.FieldOptions.EditionDefault", [ + { no: 3, name: "edition", kind: "enum", opt: true, T: () => ["google.protobuf.Edition", Edition] }, + { no: 2, name: "value", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): FieldOptions_EditionDefault { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FieldOptions_EditionDefault): FieldOptions_EditionDefault { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* optional google.protobuf.Edition edition */ 3: + message.edition = reader.int32(); + break; + case /* optional string value */ 2: + message.value = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: FieldOptions_EditionDefault, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* optional string value = 2; */ + if (message.value !== undefined) + writer.tag(2, WireType.LengthDelimited).string(message.value); + /* optional google.protobuf.Edition edition = 3; */ + if (message.edition !== undefined) + writer.tag(3, WireType.Varint).int32(message.edition); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message google.protobuf.FieldOptions.EditionDefault + */ +export const FieldOptions_EditionDefault = new FieldOptions_EditionDefault$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class FieldOptions_FeatureSupport$Type extends MessageType { + constructor() { + super("google.protobuf.FieldOptions.FeatureSupport", [ + { no: 1, name: "edition_introduced", kind: "enum", localName: "edition_introduced", opt: true, T: () => ["google.protobuf.Edition", Edition] }, + { no: 2, name: "edition_deprecated", kind: "enum", localName: "edition_deprecated", opt: true, T: () => ["google.protobuf.Edition", Edition] }, + { no: 3, name: "deprecation_warning", kind: "scalar", localName: "deprecation_warning", opt: true, T: 9 /*ScalarType.STRING*/ }, + { no: 4, name: "edition_removed", kind: "enum", localName: "edition_removed", opt: true, T: () => ["google.protobuf.Edition", Edition] }, + { no: 5, name: "removal_error", kind: "scalar", localName: "removal_error", opt: true, T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): FieldOptions_FeatureSupport { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FieldOptions_FeatureSupport): FieldOptions_FeatureSupport { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* optional google.protobuf.Edition edition_introduced */ 1: + message.edition_introduced = reader.int32(); + break; + case /* optional google.protobuf.Edition edition_deprecated */ 2: + message.edition_deprecated = reader.int32(); + break; + case /* optional string deprecation_warning */ 3: + message.deprecation_warning = reader.string(); + break; + case /* optional google.protobuf.Edition edition_removed */ 4: + message.edition_removed = reader.int32(); + break; + case /* optional string removal_error */ 5: + message.removal_error = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: FieldOptions_FeatureSupport, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* optional google.protobuf.Edition edition_introduced = 1; */ + if (message.edition_introduced !== undefined) + writer.tag(1, WireType.Varint).int32(message.edition_introduced); + /* optional google.protobuf.Edition edition_deprecated = 2; */ + if (message.edition_deprecated !== undefined) + writer.tag(2, WireType.Varint).int32(message.edition_deprecated); + /* optional string deprecation_warning = 3; */ + if (message.deprecation_warning !== undefined) + writer.tag(3, WireType.LengthDelimited).string(message.deprecation_warning); + /* optional google.protobuf.Edition edition_removed = 4; */ + if (message.edition_removed !== undefined) + writer.tag(4, WireType.Varint).int32(message.edition_removed); + /* optional string removal_error = 5; */ + if (message.removal_error !== undefined) + writer.tag(5, WireType.LengthDelimited).string(message.removal_error); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message google.protobuf.FieldOptions.FeatureSupport + */ +export const FieldOptions_FeatureSupport = new FieldOptions_FeatureSupport$Type(); +// @generated message type with reflection information, may provide speed optimized methods class OneofOptions$Type extends MessageType { constructor() { super("google.protobuf.OneofOptions", [ + { no: 1, name: "features", kind: "message", T: () => FeatureSet }, { no: 999, name: "uninterpreted_option", kind: "message", localName: "uninterpreted_option", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } ]); } @@ -2755,6 +3904,9 @@ class OneofOptions$Type extends MessageType { while (reader.pos < end) { let [fieldNo, wireType] = reader.tag(); switch (fieldNo) { + case /* optional google.protobuf.FeatureSet features */ 1: + message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); + break; case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: message.uninterpreted_option.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); break; @@ -2770,6 +3922,9 @@ class OneofOptions$Type extends MessageType { return message; } internalBinaryWrite(message: OneofOptions, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* optional google.protobuf.FeatureSet features = 1; */ + if (message.features) + FeatureSet.internalBinaryWrite(message.features, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ for (let i = 0; i < message.uninterpreted_option.length; i++) UninterpretedOption.internalBinaryWrite(message.uninterpreted_option[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); @@ -2789,6 +3944,8 @@ class EnumOptions$Type extends MessageType { super("google.protobuf.EnumOptions", [ { no: 2, name: "allow_alias", kind: "scalar", localName: "allow_alias", opt: true, T: 8 /*ScalarType.BOOL*/ }, { no: 3, name: "deprecated", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, + { no: 6, name: "deprecated_legacy_json_field_conflicts", kind: "scalar", localName: "deprecated_legacy_json_field_conflicts", opt: true, T: 8 /*ScalarType.BOOL*/ }, + { no: 7, name: "features", kind: "message", T: () => FeatureSet }, { no: 999, name: "uninterpreted_option", kind: "message", localName: "uninterpreted_option", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } ]); } @@ -2810,6 +3967,12 @@ class EnumOptions$Type extends MessageType { case /* optional bool deprecated = 3 [default = false] */ 3: message.deprecated = reader.bool(); break; + case /* optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true] */ 6: + message.deprecated_legacy_json_field_conflicts = reader.bool(); + break; + case /* optional google.protobuf.FeatureSet features */ 7: + message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); + break; case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: message.uninterpreted_option.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); break; @@ -2831,6 +3994,12 @@ class EnumOptions$Type extends MessageType { /* optional bool deprecated = 3 [default = false]; */ if (message.deprecated !== undefined) writer.tag(3, WireType.Varint).bool(message.deprecated); + /* optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true]; */ + if (message.deprecated_legacy_json_field_conflicts !== undefined) + writer.tag(6, WireType.Varint).bool(message.deprecated_legacy_json_field_conflicts); + /* optional google.protobuf.FeatureSet features = 7; */ + if (message.features) + FeatureSet.internalBinaryWrite(message.features, writer.tag(7, WireType.LengthDelimited).fork(), options).join(); /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ for (let i = 0; i < message.uninterpreted_option.length; i++) UninterpretedOption.internalBinaryWrite(message.uninterpreted_option[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); @@ -2849,6 +4018,9 @@ class EnumValueOptions$Type extends MessageType { constructor() { super("google.protobuf.EnumValueOptions", [ { no: 1, name: "deprecated", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, + { no: 2, name: "features", kind: "message", T: () => FeatureSet }, + { no: 3, name: "debug_redact", kind: "scalar", localName: "debug_redact", opt: true, T: 8 /*ScalarType.BOOL*/ }, + { no: 4, name: "feature_support", kind: "message", localName: "feature_support", T: () => FieldOptions_FeatureSupport }, { no: 999, name: "uninterpreted_option", kind: "message", localName: "uninterpreted_option", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } ]); } @@ -2867,6 +4039,15 @@ class EnumValueOptions$Type extends MessageType { case /* optional bool deprecated = 1 [default = false] */ 1: message.deprecated = reader.bool(); break; + case /* optional google.protobuf.FeatureSet features */ 2: + message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); + break; + case /* optional bool debug_redact = 3 [default = false] */ 3: + message.debug_redact = reader.bool(); + break; + case /* optional google.protobuf.FieldOptions.FeatureSupport feature_support */ 4: + message.feature_support = FieldOptions_FeatureSupport.internalBinaryRead(reader, reader.uint32(), options, message.feature_support); + break; case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: message.uninterpreted_option.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); break; @@ -2885,6 +4066,15 @@ class EnumValueOptions$Type extends MessageType { /* optional bool deprecated = 1 [default = false]; */ if (message.deprecated !== undefined) writer.tag(1, WireType.Varint).bool(message.deprecated); + /* optional google.protobuf.FeatureSet features = 2; */ + if (message.features) + FeatureSet.internalBinaryWrite(message.features, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + /* optional bool debug_redact = 3 [default = false]; */ + if (message.debug_redact !== undefined) + writer.tag(3, WireType.Varint).bool(message.debug_redact); + /* optional google.protobuf.FieldOptions.FeatureSupport feature_support = 4; */ + if (message.feature_support) + FieldOptions_FeatureSupport.internalBinaryWrite(message.feature_support, writer.tag(4, WireType.LengthDelimited).fork(), options).join(); /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ for (let i = 0; i < message.uninterpreted_option.length; i++) UninterpretedOption.internalBinaryWrite(message.uninterpreted_option[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); @@ -2902,6 +4092,7 @@ export const EnumValueOptions = new EnumValueOptions$Type(); class ServiceOptions$Type extends MessageType { constructor() { super("google.protobuf.ServiceOptions", [ + { no: 34, name: "features", kind: "message", T: () => FeatureSet }, { no: 33, name: "deprecated", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, { no: 999, name: "uninterpreted_option", kind: "message", localName: "uninterpreted_option", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } ]); @@ -2918,6 +4109,9 @@ class ServiceOptions$Type extends MessageType { while (reader.pos < end) { let [fieldNo, wireType] = reader.tag(); switch (fieldNo) { + case /* optional google.protobuf.FeatureSet features */ 34: + message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); + break; case /* optional bool deprecated = 33 [default = false] */ 33: message.deprecated = reader.bool(); break; @@ -2939,6 +4133,9 @@ class ServiceOptions$Type extends MessageType { /* optional bool deprecated = 33 [default = false]; */ if (message.deprecated !== undefined) writer.tag(33, WireType.Varint).bool(message.deprecated); + /* optional google.protobuf.FeatureSet features = 34; */ + if (message.features) + FeatureSet.internalBinaryWrite(message.features, writer.tag(34, WireType.LengthDelimited).fork(), options).join(); /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ for (let i = 0; i < message.uninterpreted_option.length; i++) UninterpretedOption.internalBinaryWrite(message.uninterpreted_option[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); @@ -2958,6 +4155,7 @@ class MethodOptions$Type extends MessageType { super("google.protobuf.MethodOptions", [ { no: 33, name: "deprecated", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, { no: 34, name: "idempotency_level", kind: "enum", localName: "idempotency_level", opt: true, T: () => ["google.protobuf.MethodOptions.IdempotencyLevel", MethodOptions_IdempotencyLevel] }, + { no: 35, name: "features", kind: "message", T: () => FeatureSet }, { no: 999, name: "uninterpreted_option", kind: "message", localName: "uninterpreted_option", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } ]); } @@ -2979,6 +4177,9 @@ class MethodOptions$Type extends MessageType { case /* optional google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN] */ 34: message.idempotency_level = reader.int32(); break; + case /* optional google.protobuf.FeatureSet features */ 35: + message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); + break; case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: message.uninterpreted_option.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); break; @@ -3000,6 +4201,9 @@ class MethodOptions$Type extends MessageType { /* optional google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN]; */ if (message.idempotency_level !== undefined) writer.tag(34, WireType.Varint).int32(message.idempotency_level); + /* optional google.protobuf.FeatureSet features = 35; */ + if (message.features) + FeatureSet.internalBinaryWrite(message.features, writer.tag(35, WireType.LengthDelimited).fork(), options).join(); /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ for (let i = 0; i < message.uninterpreted_option.length; i++) UninterpretedOption.internalBinaryWrite(message.uninterpreted_option[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); @@ -3158,6 +4362,260 @@ class UninterpretedOption_NamePart$Type extends MessageType { + constructor() { + super("google.protobuf.FeatureSet", [ + { no: 1, name: "field_presence", kind: "enum", localName: "field_presence", opt: true, T: () => ["google.protobuf.FeatureSet.FieldPresence", FeatureSet_FieldPresence] }, + { no: 2, name: "enum_type", kind: "enum", localName: "enum_type", opt: true, T: () => ["google.protobuf.FeatureSet.EnumType", FeatureSet_EnumType] }, + { no: 3, name: "repeated_field_encoding", kind: "enum", localName: "repeated_field_encoding", opt: true, T: () => ["google.protobuf.FeatureSet.RepeatedFieldEncoding", FeatureSet_RepeatedFieldEncoding] }, + { no: 4, name: "utf8_validation", kind: "enum", localName: "utf8_validation", opt: true, T: () => ["google.protobuf.FeatureSet.Utf8Validation", FeatureSet_Utf8Validation] }, + { no: 5, name: "message_encoding", kind: "enum", localName: "message_encoding", opt: true, T: () => ["google.protobuf.FeatureSet.MessageEncoding", FeatureSet_MessageEncoding] }, + { no: 6, name: "json_format", kind: "enum", localName: "json_format", opt: true, T: () => ["google.protobuf.FeatureSet.JsonFormat", FeatureSet_JsonFormat] }, + { no: 7, name: "enforce_naming_style", kind: "enum", localName: "enforce_naming_style", opt: true, T: () => ["google.protobuf.FeatureSet.EnforceNamingStyle", FeatureSet_EnforceNamingStyle] }, + { no: 8, name: "default_symbol_visibility", kind: "enum", localName: "default_symbol_visibility", opt: true, T: () => ["google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility", FeatureSet_VisibilityFeature_DefaultSymbolVisibility] } + ]); + } + create(value?: PartialMessage): FeatureSet { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FeatureSet): FeatureSet { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* optional google.protobuf.FeatureSet.FieldPresence field_presence */ 1: + message.field_presence = reader.int32(); + break; + case /* optional google.protobuf.FeatureSet.EnumType enum_type */ 2: + message.enum_type = reader.int32(); + break; + case /* optional google.protobuf.FeatureSet.RepeatedFieldEncoding repeated_field_encoding */ 3: + message.repeated_field_encoding = reader.int32(); + break; + case /* optional google.protobuf.FeatureSet.Utf8Validation utf8_validation */ 4: + message.utf8_validation = reader.int32(); + break; + case /* optional google.protobuf.FeatureSet.MessageEncoding message_encoding */ 5: + message.message_encoding = reader.int32(); + break; + case /* optional google.protobuf.FeatureSet.JsonFormat json_format */ 6: + message.json_format = reader.int32(); + break; + case /* optional google.protobuf.FeatureSet.EnforceNamingStyle enforce_naming_style */ 7: + message.enforce_naming_style = reader.int32(); + break; + case /* optional google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility default_symbol_visibility */ 8: + message.default_symbol_visibility = reader.int32(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: FeatureSet, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* optional google.protobuf.FeatureSet.FieldPresence field_presence = 1; */ + if (message.field_presence !== undefined) + writer.tag(1, WireType.Varint).int32(message.field_presence); + /* optional google.protobuf.FeatureSet.EnumType enum_type = 2; */ + if (message.enum_type !== undefined) + writer.tag(2, WireType.Varint).int32(message.enum_type); + /* optional google.protobuf.FeatureSet.RepeatedFieldEncoding repeated_field_encoding = 3; */ + if (message.repeated_field_encoding !== undefined) + writer.tag(3, WireType.Varint).int32(message.repeated_field_encoding); + /* optional google.protobuf.FeatureSet.Utf8Validation utf8_validation = 4; */ + if (message.utf8_validation !== undefined) + writer.tag(4, WireType.Varint).int32(message.utf8_validation); + /* optional google.protobuf.FeatureSet.MessageEncoding message_encoding = 5; */ + if (message.message_encoding !== undefined) + writer.tag(5, WireType.Varint).int32(message.message_encoding); + /* optional google.protobuf.FeatureSet.JsonFormat json_format = 6; */ + if (message.json_format !== undefined) + writer.tag(6, WireType.Varint).int32(message.json_format); + /* optional google.protobuf.FeatureSet.EnforceNamingStyle enforce_naming_style = 7; */ + if (message.enforce_naming_style !== undefined) + writer.tag(7, WireType.Varint).int32(message.enforce_naming_style); + /* optional google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility default_symbol_visibility = 8; */ + if (message.default_symbol_visibility !== undefined) + writer.tag(8, WireType.Varint).int32(message.default_symbol_visibility); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message google.protobuf.FeatureSet + */ +export const FeatureSet = new FeatureSet$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class FeatureSet_VisibilityFeature$Type extends MessageType { + constructor() { + super("google.protobuf.FeatureSet.VisibilityFeature", []); + } + create(value?: PartialMessage): FeatureSet_VisibilityFeature { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FeatureSet_VisibilityFeature): FeatureSet_VisibilityFeature { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: FeatureSet_VisibilityFeature, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message google.protobuf.FeatureSet.VisibilityFeature + */ +export const FeatureSet_VisibilityFeature = new FeatureSet_VisibilityFeature$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class FeatureSetDefaults$Type extends MessageType { + constructor() { + super("google.protobuf.FeatureSetDefaults", [ + { no: 1, name: "defaults", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => FeatureSetDefaults_FeatureSetEditionDefault }, + { no: 4, name: "minimum_edition", kind: "enum", localName: "minimum_edition", opt: true, T: () => ["google.protobuf.Edition", Edition] }, + { no: 5, name: "maximum_edition", kind: "enum", localName: "maximum_edition", opt: true, T: () => ["google.protobuf.Edition", Edition] } + ]); + } + create(value?: PartialMessage): FeatureSetDefaults { + const message = globalThis.Object.create((this.messagePrototype!)); + message.defaults = []; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FeatureSetDefaults): FeatureSetDefaults { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* repeated google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults */ 1: + message.defaults.push(FeatureSetDefaults_FeatureSetEditionDefault.internalBinaryRead(reader, reader.uint32(), options)); + break; + case /* optional google.protobuf.Edition minimum_edition */ 4: + message.minimum_edition = reader.int32(); + break; + case /* optional google.protobuf.Edition maximum_edition */ 5: + message.maximum_edition = reader.int32(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: FeatureSetDefaults, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* repeated google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults = 1; */ + for (let i = 0; i < message.defaults.length; i++) + FeatureSetDefaults_FeatureSetEditionDefault.internalBinaryWrite(message.defaults[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* optional google.protobuf.Edition minimum_edition = 4; */ + if (message.minimum_edition !== undefined) + writer.tag(4, WireType.Varint).int32(message.minimum_edition); + /* optional google.protobuf.Edition maximum_edition = 5; */ + if (message.maximum_edition !== undefined) + writer.tag(5, WireType.Varint).int32(message.maximum_edition); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message google.protobuf.FeatureSetDefaults + */ +export const FeatureSetDefaults = new FeatureSetDefaults$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class FeatureSetDefaults_FeatureSetEditionDefault$Type extends MessageType { + constructor() { + super("google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault", [ + { no: 3, name: "edition", kind: "enum", opt: true, T: () => ["google.protobuf.Edition", Edition] }, + { no: 4, name: "overridable_features", kind: "message", localName: "overridable_features", T: () => FeatureSet }, + { no: 5, name: "fixed_features", kind: "message", localName: "fixed_features", T: () => FeatureSet } + ]); + } + create(value?: PartialMessage): FeatureSetDefaults_FeatureSetEditionDefault { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FeatureSetDefaults_FeatureSetEditionDefault): FeatureSetDefaults_FeatureSetEditionDefault { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* optional google.protobuf.Edition edition */ 3: + message.edition = reader.int32(); + break; + case /* optional google.protobuf.FeatureSet overridable_features */ 4: + message.overridable_features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.overridable_features); + break; + case /* optional google.protobuf.FeatureSet fixed_features */ 5: + message.fixed_features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.fixed_features); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: FeatureSetDefaults_FeatureSetEditionDefault, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* optional google.protobuf.Edition edition = 3; */ + if (message.edition !== undefined) + writer.tag(3, WireType.Varint).int32(message.edition); + /* optional google.protobuf.FeatureSet overridable_features = 4; */ + if (message.overridable_features) + FeatureSet.internalBinaryWrite(message.overridable_features, writer.tag(4, WireType.LengthDelimited).fork(), options).join(); + /* optional google.protobuf.FeatureSet fixed_features = 5; */ + if (message.fixed_features) + FeatureSet.internalBinaryWrite(message.fixed_features, writer.tag(5, WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault + */ +export const FeatureSetDefaults_FeatureSetEditionDefault = new FeatureSetDefaults_FeatureSetEditionDefault$Type(); +// @generated message type with reflection information, may provide speed optimized methods class SourceCodeInfo$Type extends MessageType { constructor() { super("google.protobuf.SourceCodeInfo", [ @@ -3351,7 +4809,8 @@ class GeneratedCodeInfo_Annotation$Type extends MessageType ["google.protobuf.GeneratedCodeInfo.Annotation.Semantic", GeneratedCodeInfo_Annotation_Semantic] } ]); } create(value?: PartialMessage): GeneratedCodeInfo_Annotation { @@ -3382,6 +4841,9 @@ class GeneratedCodeInfo_Annotation$Type extends MessageType { @@ -423,7 +465,8 @@ class Type$Type extends MessageType { { no: 3, name: "oneofs", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }, { no: 4, name: "options", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Option }, { no: 5, name: "source_context", kind: "message", localName: "source_context", T: () => SourceContext }, - { no: 6, name: "syntax", kind: "enum", T: () => ["google.protobuf.Syntax", Syntax] } + { no: 6, name: "syntax", kind: "enum", T: () => ["google.protobuf.Syntax", Syntax] }, + { no: 7, name: "edition", kind: "scalar", T: 9 /*ScalarType.STRING*/ } ]); } create(value?: PartialMessage): Type { @@ -433,6 +476,7 @@ class Type$Type extends MessageType { message.oneofs = []; message.options = []; message.syntax = 0; + message.edition = ""; if (value !== undefined) reflectionMergePartial(this, message, value); return message; @@ -460,6 +504,9 @@ class Type$Type extends MessageType { case /* google.protobuf.Syntax syntax */ 6: message.syntax = reader.int32(); break; + case /* string edition */ 7: + message.edition = reader.string(); + break; default: let u = options.readUnknownField; if (u === "throw") @@ -490,6 +537,9 @@ class Type$Type extends MessageType { /* google.protobuf.Syntax syntax = 6; */ if (message.syntax !== 0) writer.tag(6, WireType.Varint).int32(message.syntax); + /* string edition = 7; */ + if (message.edition !== "") + writer.tag(7, WireType.LengthDelimited).string(message.edition); let u = options.writeUnknownFields; if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); @@ -627,7 +677,8 @@ class Enum$Type extends MessageType { { no: 2, name: "enumvalue", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => EnumValue }, { no: 3, name: "options", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Option }, { no: 4, name: "source_context", kind: "message", localName: "source_context", T: () => SourceContext }, - { no: 5, name: "syntax", kind: "enum", T: () => ["google.protobuf.Syntax", Syntax] } + { no: 5, name: "syntax", kind: "enum", T: () => ["google.protobuf.Syntax", Syntax] }, + { no: 6, name: "edition", kind: "scalar", T: 9 /*ScalarType.STRING*/ } ]); } create(value?: PartialMessage): Enum { @@ -636,6 +687,7 @@ class Enum$Type extends MessageType { message.enumvalue = []; message.options = []; message.syntax = 0; + message.edition = ""; if (value !== undefined) reflectionMergePartial(this, message, value); return message; @@ -660,6 +712,9 @@ class Enum$Type extends MessageType { case /* google.protobuf.Syntax syntax */ 5: message.syntax = reader.int32(); break; + case /* string edition */ 6: + message.edition = reader.string(); + break; default: let u = options.readUnknownField; if (u === "throw") @@ -687,6 +742,9 @@ class Enum$Type extends MessageType { /* google.protobuf.Syntax syntax = 5; */ if (message.syntax !== 0) writer.tag(5, WireType.Varint).int32(message.syntax); + /* string edition = 6; */ + if (message.edition !== "") + writer.tag(6, WireType.LengthDelimited).string(message.edition); let u = options.writeUnknownFields; if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); diff --git a/google/protobuf/wrappers.ts b/google/protobuf/wrappers.ts index daae96e..7800655 100644 --- a/google/protobuf/wrappers.ts +++ b/google/protobuf/wrappers.ts @@ -32,11 +32,17 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // +// Wrappers for primitive (non-message) types. These types were needed +// for legacy reasons and are not recommended for use in new APIs. // -// Wrappers for primitive (non-message) types. These types are useful -// for embedding primitives in the `google.protobuf.Any` type and for places -// where we need to distinguish between the absence of a primitive -// typed field and its default value. +// Historically these wrappers were useful to have presence on proto3 primitive +// fields, but proto3 syntax has been updated to support the `optional` keyword. +// Using that keyword is now the strongly preferred way to add presence to +// proto3 primitive fields. +// +// A secondary usecase was to embed primitives in the `google.protobuf.Any` +// type: it is now recommended that you embed your value in your own wrapper +// message which can be specifically documented. // // These wrappers have no meaningful use within repeated fields as they lack // the ability to detect presence on individual elements. @@ -62,6 +68,9 @@ import { MessageType } from "@protobuf-ts/runtime"; * * The JSON representation for `DoubleValue` is JSON number. * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * * @generated from protobuf message google.protobuf.DoubleValue */ export interface DoubleValue { @@ -77,6 +86,9 @@ export interface DoubleValue { * * The JSON representation for `FloatValue` is JSON number. * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * * @generated from protobuf message google.protobuf.FloatValue */ export interface FloatValue { @@ -92,6 +104,9 @@ export interface FloatValue { * * The JSON representation for `Int64Value` is JSON string. * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * * @generated from protobuf message google.protobuf.Int64Value */ export interface Int64Value { @@ -107,6 +122,9 @@ export interface Int64Value { * * The JSON representation for `UInt64Value` is JSON string. * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * * @generated from protobuf message google.protobuf.UInt64Value */ export interface UInt64Value { @@ -122,6 +140,9 @@ export interface UInt64Value { * * The JSON representation for `Int32Value` is JSON number. * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * * @generated from protobuf message google.protobuf.Int32Value */ export interface Int32Value { @@ -137,6 +158,9 @@ export interface Int32Value { * * The JSON representation for `UInt32Value` is JSON number. * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * * @generated from protobuf message google.protobuf.UInt32Value */ export interface UInt32Value { @@ -152,6 +176,9 @@ export interface UInt32Value { * * The JSON representation for `BoolValue` is JSON `true` and `false`. * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * * @generated from protobuf message google.protobuf.BoolValue */ export interface BoolValue { @@ -167,6 +194,9 @@ export interface BoolValue { * * The JSON representation for `StringValue` is JSON string. * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * * @generated from protobuf message google.protobuf.StringValue */ export interface StringValue { @@ -182,6 +212,9 @@ export interface StringValue { * * The JSON representation for `BytesValue` is JSON string. * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * * @generated from protobuf message google.protobuf.BytesValue */ export interface BytesValue { diff --git a/openapiv2.ts b/openapiv2.ts index 7c55fa6..2a0fc2a 100644 --- a/openapiv2.ts +++ b/openapiv2.ts @@ -30,7 +30,7 @@ import { Value } from "./google/protobuf/struct"; * }; * license: { * name: "BSD 3-Clause License"; - * url: "https://github.com/grpc-ecosystem/grpc-gateway/blob/master/LICENSE.txt"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway/blob/main/LICENSE"; * }; * }; * schemes: HTTPS; @@ -278,6 +278,99 @@ export interface Operation { extensions: { [key: string]: Value; }; + /** + * Custom parameters such as HTTP request headers. + * See: https://swagger.io/docs/specification/2-0/describing-parameters/ + * and https://swagger.io/specification/v2/#parameter-object. + * + * @generated from protobuf field: grpc.gateway.protoc_gen_openapiv2.options.Parameters parameters = 14 + */ + parameters?: Parameters; +} +/** + * `Parameters` is a representation of OpenAPI v2 specification's parameters object. + * Note: This technically breaks compatibility with the OpenAPI 2 definition structure as we only + * allow header parameters to be set here since we do not want users specifying custom non-header + * parameters beyond those inferred from the Protobuf schema. + * See: https://swagger.io/specification/v2/#parameter-object + * + * @generated from protobuf message grpc.gateway.protoc_gen_openapiv2.options.Parameters + */ +export interface Parameters { + /** + * `Headers` is one or more HTTP header parameter. + * See: https://swagger.io/docs/specification/2-0/describing-parameters/#header-parameters + * + * @generated from protobuf field: repeated grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter headers = 1 + */ + headers: HeaderParameter[]; +} +/** + * `HeaderParameter` a HTTP header parameter. + * See: https://swagger.io/specification/v2/#parameter-object + * + * @generated from protobuf message grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter + */ +export interface HeaderParameter { + /** + * `Name` is the header name. + * + * @generated from protobuf field: string name = 1 + */ + name: string; + /** + * `Description` is a short description of the header. + * + * @generated from protobuf field: string description = 2 + */ + description: string; + /** + * `Type` is the type of the object. The value MUST be one of "string", "number", "integer", or "boolean". The "array" type is not supported. + * See: https://swagger.io/specification/v2/#parameterType. + * + * @generated from protobuf field: grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter.Type type = 3 + */ + type: HeaderParameter_Type; + /** + * `Format` The extending format for the previously mentioned type. + * + * @generated from protobuf field: string format = 4 + */ + format: string; + /** + * `Required` indicates if the header is optional + * + * @generated from protobuf field: bool required = 5 + */ + required: boolean; +} +/** + * `Type` is a supported HTTP header type. + * See https://swagger.io/specification/v2/#parameterType. + * + * @generated from protobuf enum grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter.Type + */ +export enum HeaderParameter_Type { + /** + * @generated from protobuf enum value: UNKNOWN = 0; + */ + UNKNOWN = 0, + /** + * @generated from protobuf enum value: STRING = 1; + */ + STRING = 1, + /** + * @generated from protobuf enum value: NUMBER = 2; + */ + NUMBER = 2, + /** + * @generated from protobuf enum value: INTEGER = 3; + */ + INTEGER = 3, + /** + * @generated from protobuf enum value: BOOLEAN = 4; + */ + BOOLEAN = 4 } /** * `Header` is a representation of OpenAPI v2 specification's Header object. @@ -393,7 +486,7 @@ export interface Response { * }; * license: { * name: "BSD 3-Clause License"; - * url: "https://github.com/grpc-ecosystem/grpc-gateway/blob/master/LICENSE.txt"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway/blob/main/LICENSE"; * }; * }; * ... @@ -509,7 +602,7 @@ export interface Contact { * ... * license: { * name: "BSD 3-Clause License"; - * url: "https://github.com/grpc-ecosystem/grpc-gateway/blob/master/LICENSE.txt"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway/blob/main/LICENSE"; * }; * ... * }; @@ -616,6 +709,82 @@ export interface Schema { */ example: string; } +/** + * `EnumSchema` is subset of fields from the OpenAPI v2 specification's Schema object. + * Only fields that are applicable to Enums are included + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject + * + * Example: + * + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_enum) = { + * ... + * title: "MyEnum"; + * description:"This is my nice enum"; + * example: "ZERO"; + * required: true; + * ... + * }; + * + * + * @generated from protobuf message grpc.gateway.protoc_gen_openapiv2.options.EnumSchema + */ +export interface EnumSchema { + /** + * A short description of the schema. + * + * @generated from protobuf field: string description = 1 + */ + description: string; + /** + * @generated from protobuf field: string default = 2 + */ + default: string; + /** + * The title of the schema. + * + * @generated from protobuf field: string title = 3 + */ + title: string; + /** + * @generated from protobuf field: bool required = 4 + */ + required: boolean; + /** + * @generated from protobuf field: bool read_only = 5 + */ + read_only: boolean; + /** + * Additional external documentation for this schema. + * + * @generated from protobuf field: grpc.gateway.protoc_gen_openapiv2.options.ExternalDocumentation external_docs = 6 + */ + external_docs?: ExternalDocumentation; + /** + * @generated from protobuf field: string example = 7 + */ + example: string; + /** + * Ref is used to define an external reference to include in the message. + * This could be a fully qualified proto message reference, and that type must + * be imported into the protofile. If no message is identified, the Ref will + * be used verbatim in the output. + * For example: + * `ref: ".google.protobuf.Timestamp"`. + * + * @generated from protobuf field: string ref = 8 + */ + ref: string; + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + * + * @generated from protobuf field: map extensions = 9 + */ + extensions: { + [key: string]: Value; + }; +} /** * `JSONSchema` represents properties from JSON Schema taken, and as used, in * the OpenAPI v2 spec. @@ -805,6 +974,13 @@ export interface JSONSchema_FieldConfiguration { * @generated from protobuf field: string path_param_name = 47 */ path_param_name: string; + /** + * Declares this field to be deprecated. Allows for the generated OpenAPI + * parameter to be marked as deprecated without affecting the proto field. + * + * @generated from protobuf field: bool deprecated = 49 + */ + deprecated: boolean; } /** * @generated from protobuf enum grpc.gateway.protoc_gen_openapiv2.options.JSONSchema.JSONSchemaSimpleTypes @@ -1354,7 +1530,8 @@ class Operation$Type extends MessageType { { no: 10, name: "schemes", kind: "enum", repeat: 1 /*RepeatType.PACKED*/, T: () => ["grpc.gateway.protoc_gen_openapiv2.options.Scheme", Scheme] }, { no: 11, name: "deprecated", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, { no: 12, name: "security", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => SecurityRequirement }, - { no: 13, name: "extensions", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "message", T: () => Value } } + { no: 13, name: "extensions", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "message", T: () => Value } }, + { no: 14, name: "parameters", kind: "message", T: () => Parameters } ]); } create(value?: PartialMessage): Operation { @@ -1419,6 +1596,9 @@ class Operation$Type extends MessageType { case /* map extensions */ 13: this.binaryReadMap13(message.extensions, reader, options); break; + case /* grpc.gateway.protoc_gen_openapiv2.options.Parameters parameters */ 14: + message.parameters = Parameters.internalBinaryRead(reader, reader.uint32(), options, message.parameters); + break; default: let u = options.readUnknownField; if (u === "throw") @@ -1511,6 +1691,9 @@ class Operation$Type extends MessageType { Value.internalBinaryWrite(message.extensions[k], writer, options); writer.join().join(); } + /* grpc.gateway.protoc_gen_openapiv2.options.Parameters parameters = 14; */ + if (message.parameters) + Parameters.internalBinaryWrite(message.parameters, writer.tag(14, WireType.LengthDelimited).fork(), options).join(); let u = options.writeUnknownFields; if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); @@ -1522,6 +1705,132 @@ class Operation$Type extends MessageType { */ export const Operation = new Operation$Type(); // @generated message type with reflection information, may provide speed optimized methods +class Parameters$Type extends MessageType { + constructor() { + super("grpc.gateway.protoc_gen_openapiv2.options.Parameters", [ + { no: 1, name: "headers", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => HeaderParameter } + ]); + } + create(value?: PartialMessage): Parameters { + const message = globalThis.Object.create((this.messagePrototype!)); + message.headers = []; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Parameters): Parameters { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* repeated grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter headers */ 1: + message.headers.push(HeaderParameter.internalBinaryRead(reader, reader.uint32(), options)); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: Parameters, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* repeated grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter headers = 1; */ + for (let i = 0; i < message.headers.length; i++) + HeaderParameter.internalBinaryWrite(message.headers[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message grpc.gateway.protoc_gen_openapiv2.options.Parameters + */ +export const Parameters = new Parameters$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class HeaderParameter$Type extends MessageType { + constructor() { + super("grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter", [ + { no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "description", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "type", kind: "enum", T: () => ["grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter.Type", HeaderParameter_Type] }, + { no: 4, name: "format", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 5, name: "required", kind: "scalar", T: 8 /*ScalarType.BOOL*/ } + ]); + } + create(value?: PartialMessage): HeaderParameter { + const message = globalThis.Object.create((this.messagePrototype!)); + message.name = ""; + message.description = ""; + message.type = 0; + message.format = ""; + message.required = false; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HeaderParameter): HeaderParameter { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string name */ 1: + message.name = reader.string(); + break; + case /* string description */ 2: + message.description = reader.string(); + break; + case /* grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter.Type type */ 3: + message.type = reader.int32(); + break; + case /* string format */ 4: + message.format = reader.string(); + break; + case /* bool required */ 5: + message.required = reader.bool(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: HeaderParameter, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string name = 1; */ + if (message.name !== "") + writer.tag(1, WireType.LengthDelimited).string(message.name); + /* string description = 2; */ + if (message.description !== "") + writer.tag(2, WireType.LengthDelimited).string(message.description); + /* grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter.Type type = 3; */ + if (message.type !== 0) + writer.tag(3, WireType.Varint).int32(message.type); + /* string format = 4; */ + if (message.format !== "") + writer.tag(4, WireType.LengthDelimited).string(message.format); + /* bool required = 5; */ + if (message.required !== false) + writer.tag(5, WireType.Varint).bool(message.required); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message grpc.gateway.protoc_gen_openapiv2.options.HeaderParameter + */ +export const HeaderParameter = new HeaderParameter$Type(); +// @generated message type with reflection information, may provide speed optimized methods class Header$Type extends MessageType
{ constructor() { super("grpc.gateway.protoc_gen_openapiv2.options.Header", [ @@ -2098,6 +2407,136 @@ class Schema$Type extends MessageType { */ export const Schema = new Schema$Type(); // @generated message type with reflection information, may provide speed optimized methods +class EnumSchema$Type extends MessageType { + constructor() { + super("grpc.gateway.protoc_gen_openapiv2.options.EnumSchema", [ + { no: 1, name: "description", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "default", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "title", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 4, name: "required", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 5, name: "read_only", kind: "scalar", localName: "read_only", T: 8 /*ScalarType.BOOL*/ }, + { no: 6, name: "external_docs", kind: "message", localName: "external_docs", T: () => ExternalDocumentation }, + { no: 7, name: "example", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 8, name: "ref", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 9, name: "extensions", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "message", T: () => Value } } + ]); + } + create(value?: PartialMessage): EnumSchema { + const message = globalThis.Object.create((this.messagePrototype!)); + message.description = ""; + message.default = ""; + message.title = ""; + message.required = false; + message.read_only = false; + message.example = ""; + message.ref = ""; + message.extensions = {}; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EnumSchema): EnumSchema { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string description */ 1: + message.description = reader.string(); + break; + case /* string default */ 2: + message.default = reader.string(); + break; + case /* string title */ 3: + message.title = reader.string(); + break; + case /* bool required */ 4: + message.required = reader.bool(); + break; + case /* bool read_only */ 5: + message.read_only = reader.bool(); + break; + case /* grpc.gateway.protoc_gen_openapiv2.options.ExternalDocumentation external_docs */ 6: + message.external_docs = ExternalDocumentation.internalBinaryRead(reader, reader.uint32(), options, message.external_docs); + break; + case /* string example */ 7: + message.example = reader.string(); + break; + case /* string ref */ 8: + message.ref = reader.string(); + break; + case /* map extensions */ 9: + this.binaryReadMap9(message.extensions, reader, options); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + private binaryReadMap9(map: EnumSchema["extensions"], reader: IBinaryReader, options: BinaryReadOptions): void { + let len = reader.uint32(), end = reader.pos + len, key: keyof EnumSchema["extensions"] | undefined, val: EnumSchema["extensions"][any] | undefined; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case 1: + key = reader.string(); + break; + case 2: + val = Value.internalBinaryRead(reader, reader.uint32(), options); + break; + default: throw new globalThis.Error("unknown map entry field for grpc.gateway.protoc_gen_openapiv2.options.EnumSchema.extensions"); + } + } + map[key ?? ""] = val ?? Value.create(); + } + internalBinaryWrite(message: EnumSchema, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string description = 1; */ + if (message.description !== "") + writer.tag(1, WireType.LengthDelimited).string(message.description); + /* string default = 2; */ + if (message.default !== "") + writer.tag(2, WireType.LengthDelimited).string(message.default); + /* string title = 3; */ + if (message.title !== "") + writer.tag(3, WireType.LengthDelimited).string(message.title); + /* bool required = 4; */ + if (message.required !== false) + writer.tag(4, WireType.Varint).bool(message.required); + /* bool read_only = 5; */ + if (message.read_only !== false) + writer.tag(5, WireType.Varint).bool(message.read_only); + /* grpc.gateway.protoc_gen_openapiv2.options.ExternalDocumentation external_docs = 6; */ + if (message.external_docs) + ExternalDocumentation.internalBinaryWrite(message.external_docs, writer.tag(6, WireType.LengthDelimited).fork(), options).join(); + /* string example = 7; */ + if (message.example !== "") + writer.tag(7, WireType.LengthDelimited).string(message.example); + /* string ref = 8; */ + if (message.ref !== "") + writer.tag(8, WireType.LengthDelimited).string(message.ref); + /* map extensions = 9; */ + for (let k of globalThis.Object.keys(message.extensions)) { + writer.tag(9, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k); + writer.tag(2, WireType.LengthDelimited).fork(); + Value.internalBinaryWrite(message.extensions[k], writer, options); + writer.join().join(); + } + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message grpc.gateway.protoc_gen_openapiv2.options.EnumSchema + */ +export const EnumSchema = new EnumSchema$Type(); +// @generated message type with reflection information, may provide speed optimized methods class JSONSchema$Type extends MessageType { constructor() { super("grpc.gateway.protoc_gen_openapiv2.options.JSONSchema", [ @@ -2375,12 +2814,14 @@ export const JSONSchema = new JSONSchema$Type(); class JSONSchema_FieldConfiguration$Type extends MessageType { constructor() { super("grpc.gateway.protoc_gen_openapiv2.options.JSONSchema.FieldConfiguration", [ - { no: 47, name: "path_param_name", kind: "scalar", localName: "path_param_name", T: 9 /*ScalarType.STRING*/ } + { no: 47, name: "path_param_name", kind: "scalar", localName: "path_param_name", T: 9 /*ScalarType.STRING*/ }, + { no: 49, name: "deprecated", kind: "scalar", T: 8 /*ScalarType.BOOL*/ } ]); } create(value?: PartialMessage): JSONSchema_FieldConfiguration { const message = globalThis.Object.create((this.messagePrototype!)); message.path_param_name = ""; + message.deprecated = false; if (value !== undefined) reflectionMergePartial(this, message, value); return message; @@ -2393,6 +2834,9 @@ class JSONSchema_FieldConfiguration$Type extends MessageType