proto-lens-protobuf-types 0.7.2.1 → 0.7.2.2
raw patch · 14 files changed
+510/−119 lines, 14 filesdep ~base
Dependency ranges changed: base
Files
- Changelog.md +3/−0
- proto-lens-protobuf-types.cabal +5/−5
- proto-src/google/protobuf/any.proto +7/−3
- proto-src/google/protobuf/api.proto +2/−3
- proto-src/google/protobuf/compiler/plugin.proto +27/−30
- proto-src/google/protobuf/descriptor.proto +447/−60
- proto-src/google/protobuf/duration.proto +1/−2
- proto-src/google/protobuf/empty.proto +1/−2
- proto-src/google/protobuf/field_mask.proto +1/−1
- proto-src/google/protobuf/source_context.proto +1/−1
- proto-src/google/protobuf/struct.proto +4/−4
- proto-src/google/protobuf/timestamp.proto +2/−5
- proto-src/google/protobuf/type.proto +7/−1
- proto-src/google/protobuf/wrappers.proto +2/−2
Changelog.md view
@@ -1,5 +1,8 @@ # Changelog for `proto-lens-protobuf-types` +## v0.7.2.2+- Bump upper bounds for ghc-9.10.+ ## v0.7.2.0 - Add support for additional well known types
proto-lens-protobuf-types.cabal view
@@ -1,11 +1,11 @@ cabal-version: 2.0 --- This file has been generated from package.yaml by hpack version 0.36.0.+-- This file has been generated from package.yaml by hpack version 0.37.0. -- -- see: https://github.com/sol/hpack name: proto-lens-protobuf-types-version: 0.7.2.1+version: 0.7.2.2 synopsis: Basic protocol buffer message types. description: This package provides bindings standard protocol message types, for use with the proto-lens library. category: Data@@ -39,8 +39,8 @@ custom-setup setup-depends:- Cabal >=3 && <3.12- , base >=4.10 && <4.20+ Cabal >=3 && <3.13+ , base >=4.10 && <4.21 , proto-lens-setup ==0.4.* library@@ -101,7 +101,7 @@ build-tool-depends: proto-lens-protoc:proto-lens-protoc build-depends:- base >=4.10 && <4.20+ base >=4.10 && <4.21 , lens-family >=1.2 && <2.2 , proto-lens ==0.7.* , proto-lens-runtime ==0.7.*
proto-src/google/protobuf/any.proto view
@@ -32,12 +32,12 @@ package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option go_package = "google.golang.org/protobuf/types/known/anypb"; option java_package = "com.google.protobuf"; option java_outer_classname = "AnyProto"; option java_multiple_files = true; option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes"; // `Any` contains an arbitrary serialized protocol buffer message along with a // URL that describes the type of the serialized message.@@ -63,6 +63,10 @@ // 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. //@@ -93,7 +97,6 @@ // 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@@ -146,7 +149,8 @@ // // 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.
proto-src/google/protobuf/api.proto view
@@ -35,11 +35,11 @@ import "google/protobuf/source_context.proto"; import "google/protobuf/type.proto"; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option java_package = "com.google.protobuf"; option java_outer_classname = "ApiProto"; option java_multiple_files = true; option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option go_package = "google.golang.org/protobuf/types/known/apipb"; // Api is a light-weight descriptor for an API Interface.@@ -82,7 +82,6 @@ // be omitted. Zero major versions must only be used for // experimental, non-GA interfaces. //- // string version = 4; // Source context for the protocol buffer service represented by this@@ -167,7 +166,7 @@ // 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 inheriting+// see the effective `Storage.GetAcl` method after inherting // documentation and annotations as follows: // // service Storage {
proto-src/google/protobuf/compiler/plugin.proto view
@@ -1,38 +1,12 @@ // 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.@@ -50,6 +24,7 @@ option java_package = "com.google.protobuf.compiler"; option java_outer_classname = "PluginProtos"; +option csharp_namespace = "Google.Protobuf.Compiler"; option go_package = "google.golang.org/protobuf/types/pluginpb"; import "google/protobuf/descriptor.proto";@@ -78,6 +53,11 @@ // 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@@ -90,9 +70,13 @@ // fully qualified. repeated FileDescriptorProto proto_file = 15; + // File descriptors with all options, including source-retention options.+ // These descriptors are only provided for the files listed in+ // files_to_generate.+ repeated FileDescriptorProto source_file_descriptors = 17;+ // The version number of protocol compiler. optional Version compiler_version = 3;- } // The plugin writes an encoded CodeGeneratorResponse to stdout.@@ -115,7 +99,20 @@ enum Feature { FEATURE_NONE = 0; FEATURE_PROTO3_OPTIONAL = 1;+ FEATURE_SUPPORTS_EDITIONS = 2; }++ // 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.+ optional int32 minimum_edition = 3;++ // 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.+ optional int32 maximum_edition = 4; // Represents a single generated file. message File {
proto-src/google/protobuf/descriptor.proto view
@@ -36,7 +36,6 @@ // A valid .proto file can be translated directly to a FileDescriptorProto // without any other information (e.g. without reading its imports). - syntax = "proto2"; package google.protobuf;@@ -58,6 +57,42 @@ repeated FileDescriptorProto file = 1; } +// The full set of known editions.+enum Edition {+ // A placeholder for an unknown edition value.+ EDITION_UNKNOWN = 0;++ // A placeholder edition for specifying default behaviors *before* a feature+ // was first introduced. This is effectively an "infinite past".+ 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.+ EDITION_PROTO2 = 998;+ 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.+ EDITION_2023 = 1000;+ EDITION_2024 = 1001;++ // Placeholder editions for testing feature resolution. These should not be+ // used or relyed on outside of tests.+ EDITION_1_TEST_ONLY = 1;+ EDITION_2_TEST_ONLY = 2;+ EDITION_99997_TEST_ONLY = 99997;+ EDITION_99998_TEST_ONLY = 99998;+ 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.+ EDITION_MAX = 0x7FFFFFFF;+}+ // Describes a complete .proto file. message FileDescriptorProto { optional string name = 1; // file name, relative to root of source tree@@ -86,8 +121,13 @@ optional SourceCodeInfo source_code_info = 9; // The syntax of the proto file.- // The supported values are "proto2" and "proto3".+ // The supported values are "proto2", "proto3", and "editions".+ //+ // If `edition` is present, this value must be "editions". optional string syntax = 12;++ // The edition of the proto file.+ optional Edition edition = 14; } // Describes a message type.@@ -129,7 +169,52 @@ // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; + message Declaration {+ // The extension number declared within the extension range.+ optional int32 number = 1; + // The fully-qualified name of the extension field. There must be a leading+ // dot in front of the full name.+ optional string full_name = 2;++ // The fully-qualified type name of the extension field. Unlike+ // Metadata.type, Declaration.type must have a leading dot for messages+ // and enums.+ optional string type = 3;++ // If true, indicates that the number is reserved in the extension range,+ // and any extension field with the number will fail to compile. Set this+ // when a declared extension field is deleted.+ optional bool reserved = 5;++ // If true, indicates that the extension must be defined as repeated.+ // Otherwise the extension must be defined as optional.+ optional bool repeated = 6;++ reserved 4; // removed is_repeated+ }++ // For external users: DO NOT USE. We are in the process of open sourcing+ // extension declaration and executing internal cleanups before it can be+ // used externally.+ repeated Declaration declaration = 2 [retention = RETENTION_SOURCE];++ // Any features defined in the specific edition.+ optional FeatureSet features = 50;++ // The verification state of the extension range.+ enum VerificationState {+ // All the extensions of the range must be declared.+ DECLARATION = 0;+ UNVERIFIED = 1;+ }++ // The verification state of the range.+ // TODO: flip the default to DECLARATION once all empty ranges+ // are marked as UNVERIFIED.+ optional VerificationState verification = 3+ [default = UNVERIFIED, retention = RETENTION_SOURCE];+ // Clients can define custom options in extensions of this message. See above. extensions 1000 to max; }@@ -153,9 +238,10 @@ TYPE_BOOL = 8; 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. TYPE_GROUP = 10; TYPE_MESSAGE = 11; // Length-delimited aggregate. @@ -172,8 +258,11 @@ enum Label { // 0 is reserved for errors LABEL_OPTIONAL = 1;- LABEL_REQUIRED = 2; 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.+ LABEL_REQUIRED = 2; } optional string name = 1;@@ -199,7 +288,6 @@ // For booleans, "true" or "false". // For strings, contains the default text contents (not escaped in any way). // For bytes, contains the C escaped value. All bytes >= 128 are escaped.- // TODO(kenton): Base-64 encode? optional string default_value = 7; // If set, gives the index of a oneof in the containing type's oneof_decl@@ -217,12 +305,12 @@ // 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 be 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.+ // 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@@ -306,7 +394,6 @@ optional bool server_streaming = 6 [default = false]; } - // =================================================================== // Options @@ -347,18 +434,17 @@ // domain names. optional string java_package = 1; -- // 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. optional string java_outer_classname = 8; - // 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. optional bool java_multiple_files = 10 [default = false];@@ -366,15 +452,18 @@ // This option does nothing. optional bool java_generate_equals_and_hash = 20 [deprecated=true]; - // 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. optional bool java_string_check_utf8 = 27 [default = false]; - // Generated classes can be optimized for speed or code size. enum OptimizeMode { SPEED = 1; // Generate complete code for parsing, serialization,@@ -391,9 +480,6 @@ // - Otherwise, the basename of the .proto file, without extension. optional string go_package = 11; --- // Should generic services be generated in each language? "Generic" services // are not specific to any particular RPC system. They are generated by the // main code generators in each language (without additional plugins).@@ -407,7 +493,8 @@ optional bool cc_generic_services = 16 [default = false]; optional bool java_generic_services = 17 [default = false]; optional bool py_generic_services = 18 [default = false];- optional bool php_generic_services = 42 [default = false];+ reserved 42; // removed php_generic_services+ reserved "php_generic_services"; // Is this file deprecated? // Depending on the target platform, this can emit Deprecated annotations@@ -419,7 +506,6 @@ // only to generated classes for C++. optional bool cc_enable_arenas = 31 [default = true]; - // Sets the objective c class prefix which is prepended to all objective c // generated classes from this .proto. There is no default. optional string objc_class_prefix = 36;@@ -452,6 +538,8 @@ // determining the ruby package. optional string ruby_package = 45; + // Any features defined in the specific edition.+ optional FeatureSet features = 50; // The parser stores options it doesn't recognize here. // See the documentation for the "Options" section above.@@ -496,6 +584,8 @@ // this is a formalization for deprecating messages. optional bool deprecated = 3 [default = false]; + reserved 4, 5, 6;+ // Whether the message is an automatically generated map entry type for the // maps field. //@@ -522,7 +612,21 @@ reserved 8; // javalite_serializable reserved 9; // javanano_as_lite + // 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.+ optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true]; + // Any features defined in the specific edition.+ optional FeatureSet features = 12;+ // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; @@ -531,15 +635,24 @@ } message 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!- optional CType ctype = 1 [default = STRING];+ // 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.+ optional CType ctype = 1 [/*deprecated = true,*/ default = STRING]; enum CType { // Default mode. 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. CORD = 1; STRING_PIECE = 2;@@ -548,7 +661,9 @@ // 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. optional bool packed = 2; // The jstype option determines the JavaScript type used for values of the@@ -591,19 +706,18 @@ // 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). optional bool lazy = 5 [default = false]; + // unverified_lazy does no correctness checks on the byte stream. This should+ // only be used where lazy with verification is prohibitive for performance+ // reasons.+ optional bool unverified_lazy = 15 [default = false];+ // Is this field deprecated? // Depending on the target platform, this can emit Deprecated annotations // for accessors, or it will be completely ignored; in the very least, this@@ -613,17 +727,85 @@ // For Google-internal migration only. Do not use. optional bool weak = 10 [default = false]; + // Indicate that the field value should not be printed out when using debug+ // formats, e.g. when the field contains sensitive credentials.+ optional bool debug_redact = 16 [default = false]; + // If set to RETENTION_SOURCE, the option will be omitted from the binary.+ // Note: as of January 2023, support for this is in progress and does not yet+ // have an effect (b/264593489).+ enum OptionRetention {+ RETENTION_UNKNOWN = 0;+ RETENTION_RUNTIME = 1;+ RETENTION_SOURCE = 2;+ }++ optional OptionRetention retention = 17;++ // 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. Note: as of January 2023, support for this is+ // in progress and does not yet have an effect (b/264593489).+ enum OptionTargetType {+ TARGET_TYPE_UNKNOWN = 0;+ TARGET_TYPE_FILE = 1;+ TARGET_TYPE_EXTENSION_RANGE = 2;+ TARGET_TYPE_MESSAGE = 3;+ TARGET_TYPE_FIELD = 4;+ TARGET_TYPE_ONEOF = 5;+ TARGET_TYPE_ENUM = 6;+ TARGET_TYPE_ENUM_ENTRY = 7;+ TARGET_TYPE_SERVICE = 8;+ TARGET_TYPE_METHOD = 9;+ }++ repeated OptionTargetType targets = 19;++ message EditionDefault {+ optional Edition edition = 3;+ optional string value = 2; // Textproto value.+ }+ repeated EditionDefault edition_defaults = 20;++ // Any features defined in the specific edition.+ optional FeatureSet features = 21;++ // Information about the support window of a feature.+ message 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.+ optional Edition edition_introduced = 1;++ // The edition this feature becomes deprecated in. Using this after this+ // edition may trigger warnings.+ optional Edition edition_deprecated = 2;++ // The deprecation warning text if this feature is used after the edition it+ // was marked deprecated in.+ optional string deprecation_warning = 3;++ // 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.+ optional Edition edition_removed = 4;+ }+ optional FeatureSupport feature_support = 22;+ // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; // Clients can define custom options in extensions of this message. See above. extensions 1000 to max; - reserved 4; // removed jtype+ reserved 4; // removed jtype+ reserved 18; // reserve target, target_obsolete_do_not_use } message OneofOptions {+ // Any features defined in the specific edition.+ optional FeatureSet features = 1;+ // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; @@ -645,6 +827,17 @@ reserved 5; // javanano_as_lite + // 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.+ optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true];++ // Any features defined in the specific edition.+ optional FeatureSet features = 7;+ // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; @@ -659,6 +852,17 @@ // this is a formalization for deprecating enum values. optional bool deprecated = 1 [default = false]; + // Any features defined in the specific edition.+ optional FeatureSet features = 2;++ // 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.+ optional bool debug_redact = 3 [default = false];++ // Information about the support window of a feature value.+ optional FieldOptions.FeatureSupport feature_support = 4;+ // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; @@ -668,6 +872,9 @@ message ServiceOptions { + // Any features defined in the specific edition.+ optional FeatureSet features = 34;+ // 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@@ -710,6 +917,9 @@ optional IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN]; + // Any features defined in the specific edition.+ optional FeatureSet features = 35;+ // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; @@ -717,7 +927,6 @@ extensions 1000 to max; } - // A message representing a option the parser does not recognize. This only // appears in options protos created by the compiler::Parser class. // DescriptorPool resolves these when building Descriptor objects. Therefore,@@ -728,8 +937,8 @@ // 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". message NamePart { required string name_part = 1; required bool is_extension = 2;@@ -747,6 +956,172 @@ } // ===================================================================+// 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.+message FeatureSet {+ enum FieldPresence {+ FIELD_PRESENCE_UNKNOWN = 0;+ EXPLICIT = 1;+ IMPLICIT = 2;+ LEGACY_REQUIRED = 3;+ }+ optional FieldPresence field_presence = 1 [+ retention = RETENTION_RUNTIME,+ targets = TARGET_TYPE_FIELD,+ targets = TARGET_TYPE_FILE,+ feature_support = {+ edition_introduced: EDITION_2023,+ },+ edition_defaults = { edition: EDITION_LEGACY, value: "EXPLICIT" },+ edition_defaults = { edition: EDITION_PROTO3, value: "IMPLICIT" },+ edition_defaults = { edition: EDITION_2023, value: "EXPLICIT" }+ ];++ enum EnumType {+ ENUM_TYPE_UNKNOWN = 0;+ OPEN = 1;+ CLOSED = 2;+ }+ optional EnumType enum_type = 2 [+ retention = RETENTION_RUNTIME,+ targets = TARGET_TYPE_ENUM,+ targets = TARGET_TYPE_FILE,+ feature_support = {+ edition_introduced: EDITION_2023,+ },+ edition_defaults = { edition: EDITION_LEGACY, value: "CLOSED" },+ edition_defaults = { edition: EDITION_PROTO3, value: "OPEN" }+ ];++ enum RepeatedFieldEncoding {+ REPEATED_FIELD_ENCODING_UNKNOWN = 0;+ PACKED = 1;+ EXPANDED = 2;+ }+ optional RepeatedFieldEncoding repeated_field_encoding = 3 [+ retention = RETENTION_RUNTIME,+ targets = TARGET_TYPE_FIELD,+ targets = TARGET_TYPE_FILE,+ feature_support = {+ edition_introduced: EDITION_2023,+ },+ edition_defaults = { edition: EDITION_LEGACY, value: "EXPANDED" },+ edition_defaults = { edition: EDITION_PROTO3, value: "PACKED" }+ ];++ enum Utf8Validation {+ UTF8_VALIDATION_UNKNOWN = 0;+ VERIFY = 2;+ NONE = 3;+ reserved 1;+ }+ optional Utf8Validation utf8_validation = 4 [+ retention = RETENTION_RUNTIME,+ targets = TARGET_TYPE_FIELD,+ targets = TARGET_TYPE_FILE,+ feature_support = {+ edition_introduced: EDITION_2023,+ },+ edition_defaults = { edition: EDITION_LEGACY, value: "NONE" },+ edition_defaults = { edition: EDITION_PROTO3, value: "VERIFY" }+ ];++ enum MessageEncoding {+ MESSAGE_ENCODING_UNKNOWN = 0;+ LENGTH_PREFIXED = 1;+ DELIMITED = 2;+ }+ optional MessageEncoding message_encoding = 5 [+ retention = RETENTION_RUNTIME,+ targets = TARGET_TYPE_FIELD,+ targets = TARGET_TYPE_FILE,+ feature_support = {+ edition_introduced: EDITION_2023,+ },+ edition_defaults = { edition: EDITION_LEGACY, value: "LENGTH_PREFIXED" }+ ];++ enum JsonFormat {+ JSON_FORMAT_UNKNOWN = 0;+ ALLOW = 1;+ LEGACY_BEST_EFFORT = 2;+ }+ optional JsonFormat json_format = 6 [+ retention = RETENTION_RUNTIME,+ targets = TARGET_TYPE_MESSAGE,+ targets = TARGET_TYPE_ENUM,+ targets = TARGET_TYPE_FILE,+ feature_support = {+ edition_introduced: EDITION_2023,+ },+ edition_defaults = { edition: EDITION_LEGACY, value: "LEGACY_BEST_EFFORT" },+ edition_defaults = { edition: EDITION_PROTO3, value: "ALLOW" }+ ];++ reserved 999;++ extensions 1000 to 9994 [+ declaration = {+ number: 1000,+ full_name: ".pb.cpp",+ type: ".pb.CppFeatures"+ },+ declaration = {+ number: 1001,+ full_name: ".pb.java",+ type: ".pb.JavaFeatures"+ },+ declaration = { number: 1002, full_name: ".pb.go", type: ".pb.GoFeatures" },+ declaration = {+ number: 9990,+ full_name: ".pb.proto1",+ type: ".pb.Proto1Features"+ }+ ];++ extensions 9995 to 9999; // For internal testing+ extensions 10000; // for https://github.com/bufbuild/protobuf-es+}++// 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.+message FeatureSetDefaults {+ // 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.+ message FeatureSetEditionDefault {+ optional Edition edition = 3;++ // Defaults of features that can be overridden in this edition.+ optional FeatureSet overridable_features = 4;++ // Defaults of features that can't be overridden in this edition.+ optional FeatureSet fixed_features = 5;++ reserved 1, 2;+ reserved "features";+ }+ repeated FeatureSetEditionDefault defaults = 1;++ // The minimum supported edition (inclusive) when this was constructed.+ // Editions before this will not have defaults.+ optional Edition minimum_edition = 4;++ // The maximum known edition (inclusive) when this was constructed. Editions+ // after this will not have reliable defaults.+ optional Edition maximum_edition = 5;+}++// =================================================================== // Optional source code info // Encapsulates information about the original source file from which a@@ -801,8 +1176,8 @@ // 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@@ -856,13 +1231,13 @@ // // 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.@@ -902,8 +1277,20 @@ optional int32 begin = 3; // 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). optional int32 end = 4;++ // Represents the identified object's effect on the element in the original+ // .proto file.+ enum Semantic {+ // There is no effect or the effect is indescribable.+ NONE = 0;+ // The element is set or otherwise mutated.+ SET = 1;+ // An alias to the element is returned.+ ALIAS = 2;+ }+ optional Semantic semantic = 5; } }
proto-src/google/protobuf/duration.proto view
@@ -32,13 +32,13 @@ package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; option go_package = "google.golang.org/protobuf/types/known/durationpb"; option java_package = "com.google.protobuf"; option java_outer_classname = "DurationProto"; option java_multiple_files = true; option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes"; // A Duration represents a signed, fixed-length span of time represented // as a count of seconds and fractions of seconds at nanosecond@@ -98,7 +98,6 @@ // encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should // be expressed in JSON format as "3.000000001s", and 3 seconds and 1 // microsecond should be expressed in JSON format as "3.000001s".-// // message Duration { // Signed seconds of the span of time. Must be from -315,576,000,000
proto-src/google/protobuf/empty.proto view
@@ -32,12 +32,12 @@ package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option go_package = "google.golang.org/protobuf/types/known/emptypb"; option java_package = "com.google.protobuf"; option java_outer_classname = "EmptyProto"; option java_multiple_files = true; option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; // A generic empty message that you can re-use to avoid defining duplicated@@ -48,5 +48,4 @@ // rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); // } //-// The JSON representation for `Empty` is empty JSON object `{}`. message Empty {}
proto-src/google/protobuf/field_mask.proto view
@@ -32,11 +32,11 @@ package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option java_package = "com.google.protobuf"; option java_outer_classname = "FieldMaskProto"; option java_multiple_files = true; option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option go_package = "google.golang.org/protobuf/types/known/fieldmaskpb"; option cc_enable_arenas = true;
proto-src/google/protobuf/source_context.proto view
@@ -32,11 +32,11 @@ package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option java_package = "com.google.protobuf"; option java_outer_classname = "SourceContextProto"; option java_multiple_files = true; option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option go_package = "google.golang.org/protobuf/types/known/sourcecontextpb"; // `SourceContext` represents information about the source of a
proto-src/google/protobuf/struct.proto view
@@ -32,13 +32,13 @@ package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; option go_package = "google.golang.org/protobuf/types/known/structpb"; option java_package = "com.google.protobuf"; option java_outer_classname = "StructProto"; option java_multiple_files = true; option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes"; // `Struct` represents a structured data value, consisting of fields // which map to dynamically typed values. In some languages, `Struct`@@ -55,8 +55,8 @@ // `Value` represents a dynamically typed value which can be either // null, a number, a string, a boolean, a recursive struct value, or a-// list of values. A producer of value is expected to set one of that-// variants, absence of any variant indicates an error.+// list of values. A producer of value is expected to set one of these+// variants. Absence of any variant indicates an error. // // The JSON representation for `Value` is JSON value. message Value {@@ -80,7 +80,7 @@ // `NullValue` is a singleton enumeration to represent the null value for the // `Value` type union. //-// The JSON representation for `NullValue` is JSON `null`.+// The JSON representation for `NullValue` is JSON `null`. enum NullValue { // Null value. NULL_VALUE = 0;
proto-src/google/protobuf/timestamp.proto view
@@ -32,13 +32,13 @@ package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; option go_package = "google.golang.org/protobuf/types/known/timestamppb"; option java_package = "com.google.protobuf"; option java_outer_classname = "TimestampProto"; option java_multiple_files = true; option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes"; // A Timestamp represents a point in time independent of any time zone or local // calendar, encoded as a count of seconds and fractions of seconds at@@ -90,7 +90,6 @@ // Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) // .setNanos((int) ((millis % 1000) * 1000000)).build(); //-// // Example 5: Compute Timestamp from Java `Instant.now()`. // // Instant now = Instant.now();@@ -99,7 +98,6 @@ // Timestamp.newBuilder().setSeconds(now.getEpochSecond()) // .setNanos(now.getNano()).build(); //-// // Example 6: Compute Timestamp from current time in Python. // // timestamp = Timestamp()@@ -129,9 +127,8 @@ // [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with // the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use // the Joda Time's [`ISODateTimeFormat.dateTime()`](-// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D+// http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime() // ) to obtain a formatter capable of generating timestamps in this format.-// // message Timestamp { // Represents seconds of UTC time since Unix epoch
proto-src/google/protobuf/type.proto view
@@ -35,12 +35,12 @@ import "google/protobuf/any.proto"; import "google/protobuf/source_context.proto"; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; option java_package = "com.google.protobuf"; option java_outer_classname = "TypeProto"; option java_multiple_files = true; option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option go_package = "google.golang.org/protobuf/types/known/typepb"; // A protocol buffer message type.@@ -57,6 +57,8 @@ SourceContext source_context = 5; // The source syntax. Syntax syntax = 6;+ // The source edition string, only valid when syntax is SYNTAX_EDITIONS.+ string edition = 7; } // A single field of a message type.@@ -151,6 +153,8 @@ SourceContext source_context = 4; // The source syntax. Syntax syntax = 5;+ // The source edition string, only valid when syntax is SYNTAX_EDITIONS.+ string edition = 6; } // Enum value definition.@@ -184,4 +188,6 @@ SYNTAX_PROTO2 = 0; // Syntax `proto3`. SYNTAX_PROTO3 = 1;+ // Syntax `editions`.+ SYNTAX_EDITIONS = 2; }
proto-src/google/protobuf/wrappers.proto view
@@ -27,7 +27,7 @@ // 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.-+// // 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@@ -42,13 +42,13 @@ package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; option go_package = "google.golang.org/protobuf/types/known/wrapperspb"; option java_package = "com.google.protobuf"; option java_outer_classname = "WrappersProto"; option java_multiple_files = true; option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes"; // Wrapper message for `double`. //