proto-lens-protobuf-types 0.6.0.0 → 0.7.2.3
raw patch · 16 files changed
Files
- Changelog.md +28/−0
- proto-lens-protobuf-types.cabal +40/−16
- proto-src/google/protobuf/any.proto +15/−7
- proto-src/google/protobuf/api.proto +207/−0
- proto-src/google/protobuf/compiler/plugin.proto +44/−31
- proto-src/google/protobuf/descriptor.proto +534/−121
- proto-src/google/protobuf/duration.proto +3/−5
- proto-src/google/protobuf/empty.proto +2/−3
- proto-src/google/protobuf/field_mask.proto +245/−0
- proto-src/google/protobuf/source_context.proto +48/−0
- proto-src/google/protobuf/struct.proto +95/−0
- proto-src/google/protobuf/timestamp.proto +30/−21
- proto-src/google/protobuf/type.proto +193/−0
- proto-src/google/protobuf/wrappers.proto +8/−3
- src/Data/ProtoLens/Any.hs +7/−9
- src/Data/ProtoLens/Descriptor.hs +43/−0
Changelog.md view
@@ -1,5 +1,33 @@ # Changelog for `proto-lens-protobuf-types` +## v0.7.2.3+- Support GHC 9.12.+- Support GHC 9.14.+- Fix `Data.ProtoLens.Any` to not import `IsLabels` instance, allowing+ use of other `IsLabels` instances (e.g. from `generic-lens`) alongside+ `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++## v0.7.1.2+- Add protobuf struct types (#438)++## v0.7.1.1+- Relax upper bounds for ghc-9.2++## v0.7.1.0+- Support GHC 9.0.+- Add ServiceDescriptor to generated services (#409)++## v0.7.0.0+- Add the module `Data.ProtoLens.Descriptor`. It exposes `messageDescriptor`,+ which makes it easier to get the descriptor proto for a given message type.+- Bump upper bound to allow base-4.14.+ ## v0.6.0.0 - Bump lower bounds to base-4.10 (ghc-8.2). - Support dependencies on base-4.13 (ghc-8.8) and lens-family-2.0.
proto-lens-protobuf-types.cabal view
@@ -1,13 +1,11 @@ cabal-version: 2.0 --- This file has been generated from package.yaml by hpack version 0.31.2.+-- This file has been generated from package.yaml by hpack version 0.37.0. -- -- see: https://github.com/sol/hpack------ hash: 6fff397cb28cd075e027babec460623039628f01e3ce35bf4dd3735db4c8f3c4 name: proto-lens-protobuf-types-version: 0.6.0.0+version: 0.7.2.3 synopsis: Basic protocol buffer message types. description: This package provides bindings standard protocol message types, for use with the proto-lens library. category: Data@@ -22,12 +20,17 @@ extra-source-files: Changelog.md proto-src/google/protobuf/any.proto+ proto-src/google/protobuf/api.proto proto-src/google/protobuf/compiler/plugin.proto proto-src/google/protobuf/descriptor.proto proto-src/google/protobuf/duration.proto proto-src/google/protobuf/empty.proto- proto-src/google/protobuf/wrappers.proto+ proto-src/google/protobuf/field_mask.proto+ proto-src/google/protobuf/source_context.proto+ proto-src/google/protobuf/struct.proto proto-src/google/protobuf/timestamp.proto+ proto-src/google/protobuf/type.proto+ proto-src/google/protobuf/wrappers.proto source-repository head type: git@@ -36,15 +39,18 @@ custom-setup setup-depends:- Cabal- , base >=4.10 && <4.14+ Cabal >=3 && <3.17+ , base >=4.10 && <4.23 , proto-lens-setup ==0.4.* library exposed-modules: Data.ProtoLens.Any+ Data.ProtoLens.Descriptor Proto.Google.Protobuf.Any Proto.Google.Protobuf.Any_Fields+ Proto.Google.Protobuf.Api+ Proto.Google.Protobuf.Api_Fields Proto.Google.Protobuf.Compiler.Plugin Proto.Google.Protobuf.Compiler.Plugin_Fields Proto.Google.Protobuf.Descriptor@@ -53,13 +59,23 @@ Proto.Google.Protobuf.Duration_Fields Proto.Google.Protobuf.Empty Proto.Google.Protobuf.Empty_Fields- Proto.Google.Protobuf.Wrappers- Proto.Google.Protobuf.Wrappers_Fields+ Proto.Google.Protobuf.FieldMask+ Proto.Google.Protobuf.FieldMask_Fields+ Proto.Google.Protobuf.SourceContext+ Proto.Google.Protobuf.SourceContext_Fields+ Proto.Google.Protobuf.Struct+ Proto.Google.Protobuf.Struct_Fields Proto.Google.Protobuf.Timestamp Proto.Google.Protobuf.Timestamp_Fields+ Proto.Google.Protobuf.Type+ Proto.Google.Protobuf.Type_Fields+ Proto.Google.Protobuf.Wrappers+ Proto.Google.Protobuf.Wrappers_Fields autogen-modules: Proto.Google.Protobuf.Any Proto.Google.Protobuf.Any_Fields+ Proto.Google.Protobuf.Api+ Proto.Google.Protobuf.Api_Fields Proto.Google.Protobuf.Compiler.Plugin Proto.Google.Protobuf.Compiler.Plugin_Fields Proto.Google.Protobuf.Descriptor@@ -68,18 +84,26 @@ Proto.Google.Protobuf.Duration_Fields Proto.Google.Protobuf.Empty Proto.Google.Protobuf.Empty_Fields- Proto.Google.Protobuf.Wrappers- Proto.Google.Protobuf.Wrappers_Fields+ Proto.Google.Protobuf.FieldMask+ Proto.Google.Protobuf.FieldMask_Fields+ Proto.Google.Protobuf.SourceContext+ Proto.Google.Protobuf.SourceContext_Fields+ Proto.Google.Protobuf.Struct+ Proto.Google.Protobuf.Struct_Fields Proto.Google.Protobuf.Timestamp Proto.Google.Protobuf.Timestamp_Fields+ Proto.Google.Protobuf.Type+ Proto.Google.Protobuf.Type_Fields+ Proto.Google.Protobuf.Wrappers+ Proto.Google.Protobuf.Wrappers_Fields hs-source-dirs: src build-tool-depends: proto-lens-protoc:proto-lens-protoc build-depends:- base >=4.10 && <4.14- , lens-family >=1.2 && <2.1- , proto-lens ==0.6.*- , proto-lens-runtime ==0.6.*- , text ==1.2.*+ base >=4.10 && <4.23+ , lens-family >=1.2 && <2.2+ , proto-lens ==0.7.*+ , proto-lens-runtime ==0.7.*+ , text >=1.2 && <2.2 default-language: Haskell2010
proto-src/google/protobuf/any.proto view
@@ -32,12 +32,12 @@ package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes";-option go_package = "github.com/golang/protobuf/ptypes/any";+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. //@@ -77,10 +81,13 @@ // 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 { // ... // } //@@ -90,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@@ -121,7 +127,8 @@ // message Any { // A URL/resource name that uniquely identifies the type of the serialized- // protocol buffer message. The last segment of the URL's path must represent+ // protocol buffer message. This string must contain at least+ // one "/" character. The last segment of the URL's path must represent // the fully qualified name of the type (as in // `path/google.protobuf.Duration`). The name should be in a canonical form // (e.g., leading "." is not accepted).@@ -142,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
@@ -0,0 +1,207 @@+// 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.++syntax = "proto3";++package google.protobuf;++import "google/protobuf/source_context.proto";+import "google/protobuf/type.proto";++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.+//+// Interfaces are also described as "protocol buffer services" in some contexts,+// such as by the "service" keyword in a .proto file, but they are different+// from API Services, which represent a concrete implementation of an interface+// as opposed to simply a description of methods and bindings. They are also+// sometimes simply referred to as "APIs" in other contexts, such as the name of+// this message itself. See https://cloud.google.com/apis/design/glossary for+// detailed terminology.+message Api {+ // The fully qualified name of this interface, including package name+ // followed by the interface's simple name.+ string name = 1;++ // The methods of this interface, in unspecified order.+ repeated Method methods = 2;++ // Any metadata attached to the interface.+ repeated Option options = 3;++ // A version string for this interface. If specified, must have the form+ // `major-version.minor-version`, as in `1.10`. If the minor version is+ // omitted, it defaults to zero. If the entire version field is empty, the+ // major version is derived from the package name, as outlined below. If the+ // field is not empty, the version in the package name will be verified to be+ // consistent with what is provided here.+ //+ // The versioning schema uses [semantic+ // versioning](http://semver.org) where the major version number+ // indicates a breaking change and the minor version an additive,+ // non-breaking change. Both version numbers are signals to users+ // what to expect from different versions, and should be carefully+ // chosen based on the product plan.+ //+ // The major version is also reflected in the package name of the+ // interface, which must end in `v<major-version>`, as in+ // `google.feature.v1`. For major versions 0 and 1, the suffix can+ // 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+ // message.+ SourceContext source_context = 5;++ // Included interfaces. See [Mixin][].+ repeated Mixin mixins = 6;++ // The source syntax of the service.+ Syntax syntax = 7;+}++// Method represents a method of an API interface.+message Method {+ // The simple name of this method.+ string name = 1;++ // A URL of the input message type.+ string request_type_url = 2;++ // If true, the request is streamed.+ bool request_streaming = 3;++ // The URL of the output message type.+ string response_type_url = 4;++ // If true, the response is streamed.+ bool response_streaming = 5;++ // Any metadata attached to the method.+ repeated Option options = 6;++ // The source syntax of this method.+ Syntax syntax = 7;+}++// Declares an API Interface to be included in this interface. The including+// interface must redeclare all the methods from the included interface, but+// documentation and options are inherited as follows:+//+// - If after comment and whitespace stripping, the documentation+// string of the redeclared method is empty, it will be inherited+// from the original method.+//+// - Each annotation belonging to the service config (http,+// visibility) which is not set in the redeclared method will be+// inherited.+//+// - If an http annotation is inherited, the path pattern will be+// modified as follows. Any version prefix will be replaced by the+// version of the including interface plus the [root][] path if+// specified.+//+// Example of a simple mixin:+//+// package google.acl.v1;+// service AccessControl {+// // Get the underlying ACL object.+// rpc GetAcl(GetAclRequest) returns (Acl) {+// option (google.api.http).get = "/v1/{resource=**}:getAcl";+// }+// }+//+// package google.storage.v2;+// service Storage {+// rpc GetAcl(GetAclRequest) returns (Acl);+//+// // Get a data record.+// rpc GetData(GetDataRequest) returns (Data) {+// option (google.api.http).get = "/v2/{resource=**}";+// }+// }+//+// Example of a mixin configuration:+//+// apis:+// - name: google.storage.v2.Storage+// mixins:+// - name: google.acl.v1.AccessControl+//+// 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+// documentation and annotations as follows:+//+// service Storage {+// // Get the underlying ACL object.+// rpc GetAcl(GetAclRequest) returns (Acl) {+// option (google.api.http).get = "/v2/{resource=**}:getAcl";+// }+// ...+// }+//+// Note how the version in the path pattern changed from `v1` to `v2`.+//+// If the `root` field in the mixin is specified, it should be a+// relative path under which inherited HTTP paths are placed. Example:+//+// apis:+// - name: google.storage.v2.Storage+// mixins:+// - name: google.acl.v1.AccessControl+// root: acls+//+// This implies the following inherited HTTP annotation:+//+// service Storage {+// // Get the underlying ACL object.+// rpc GetAcl(GetAclRequest) returns (Acl) {+// option (google.api.http).get = "/v2/acls/{resource=**}:getAcl";+// }+// ...+// }+message Mixin {+ // The fully qualified name of the interface which is included.+ string name = 1;++ // If non-empty specifies a path under which inherited HTTP paths+ // are rooted.+ string root = 2;+}
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.@@ -45,11 +19,13 @@ // flag "--${NAME}_out" is passed to protoc. syntax = "proto2";+ package google.protobuf.compiler; option java_package = "com.google.protobuf.compiler"; option java_outer_classname = "PluginProtos"; -option go_package = "github.com/golang/protobuf/protoc-gen-go/plugin;plugin_go";+option csharp_namespace = "Google.Protobuf.Compiler";+option go_package = "google.golang.org/protobuf/types/pluginpb"; import "google/protobuf/descriptor.proto"; @@ -77,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@@ -89,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.@@ -106,6 +91,29 @@ // exiting with a non-zero status code. optional string error = 1; + // A bitmask of supported features that the code generator supports.+ // This is a bitwise "or" of values from the Feature enum.+ optional uint64 supported_features = 2;++ // Sync with code_generator.h.+ 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 { // The file name, relative to the output directory. The name must not@@ -162,6 +170,11 @@ // The file contents. optional string content = 15;++ // 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.+ optional GeneratedCodeInfo generated_code_info = 16; } repeated File file = 15; }
proto-src/google/protobuf/descriptor.proto view
@@ -36,11 +36,11 @@ // 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;-option go_package = "github.com/golang/protobuf/protoc-gen-go/descriptor;descriptor";++option go_package = "google.golang.org/protobuf/types/descriptorpb"; option java_package = "com.google.protobuf"; option java_outer_classname = "DescriptorProtos"; option csharp_namespace = "Google.Protobuf.Reflection";@@ -57,10 +57,46 @@ 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- optional string package = 2; // e.g. "foo", "foo.bar", etc.+ optional string name = 1; // file name, relative to root of source tree+ optional string package = 2; // e.g. "foo", "foo.bar", etc. // Names of files imported by this file. repeated string dependency = 3;@@ -85,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.@@ -100,8 +141,8 @@ repeated EnumDescriptorProto enum_type = 4; message ExtensionRange {- optional int32 start = 1;- optional int32 end = 2;+ optional int32 start = 1; // Inclusive.+ optional int32 end = 2; // Exclusive. optional ExtensionRangeOptions options = 3; }@@ -115,8 +156,8 @@ // fields or extension ranges in the same message. Reserved ranges may // not overlap. message ReservedRange {- optional int32 start = 1; // Inclusive.- optional int32 end = 2; // Exclusive.+ optional int32 start = 1; // Inclusive.+ optional int32 end = 2; // Exclusive. } repeated ReservedRange reserved_range = 9; // Reserved field names, which may not be used by fields in the same message.@@ -128,6 +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; }@@ -137,42 +224,46 @@ enum Type { // 0 is reserved for errors. // Order is weird for historical reasons.- TYPE_DOUBLE = 1;- TYPE_FLOAT = 2;+ TYPE_DOUBLE = 1;+ TYPE_FLOAT = 2; // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if // negative values are likely.- TYPE_INT64 = 3;- TYPE_UINT64 = 4;+ TYPE_INT64 = 3;+ TYPE_UINT64 = 4; // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if // negative values are likely.- TYPE_INT32 = 5;- TYPE_FIXED64 = 6;- TYPE_FIXED32 = 7;- TYPE_BOOL = 8;- TYPE_STRING = 9;+ TYPE_INT32 = 5;+ TYPE_FIXED64 = 6;+ TYPE_FIXED32 = 7;+ 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.- TYPE_GROUP = 10;- TYPE_MESSAGE = 11; // Length-delimited aggregate.+ // 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. // New in version 2.- TYPE_BYTES = 12;- TYPE_UINT32 = 13;- TYPE_ENUM = 14;- TYPE_SFIXED32 = 15;- TYPE_SFIXED64 = 16;- TYPE_SINT32 = 17; // Uses ZigZag encoding.- TYPE_SINT64 = 18; // Uses ZigZag encoding.- };+ TYPE_BYTES = 12;+ TYPE_UINT32 = 13;+ TYPE_ENUM = 14;+ TYPE_SFIXED32 = 15;+ TYPE_SFIXED64 = 16;+ TYPE_SINT32 = 17; // Uses ZigZag encoding.+ TYPE_SINT64 = 18; // Uses ZigZag encoding.+ } enum Label { // 0 is reserved for errors- LABEL_OPTIONAL = 1;- LABEL_REQUIRED = 2;- LABEL_REPEATED = 3;- };+ LABEL_OPTIONAL = 1;+ 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; optional int32 number = 3;@@ -197,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@@ -211,6 +301,29 @@ optional string json_name = 10; optional FieldOptions options = 8;++ // 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`.+ optional bool proto3_optional = 17; } // Describes a oneof.@@ -234,8 +347,8 @@ // is inclusive such that it can appropriately represent the entire int32 // domain. message EnumReservedRange {- optional int32 start = 1; // Inclusive.- optional int32 end = 2; // Inclusive.+ optional int32 start = 1; // Inclusive.+ optional int32 end = 2; // Inclusive. } // Range of reserved numeric values. Reserved numeric values may not be used@@ -276,12 +389,11 @@ optional MethodOptions options = 4; // Identifies if client streams multiple client messages- optional bool client_streaming = 5 [default=false];+ optional bool client_streaming = 5 [default = false]; // Identifies if server streams multiple server messages- optional bool server_streaming = 6 [default=false];+ optional bool server_streaming = 6 [default = false]; } - // =================================================================== // Options @@ -314,7 +426,6 @@ // If this turns out to be popular, a web service will be set up // to automatically assign option numbers. - message FileOptions { // Sets the Java package where classes generated from this .proto will be@@ -323,42 +434,44 @@ // 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];+ optional bool java_multiple_files = 10 [default = false]; // 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.- optional bool java_string_check_utf8 = 27 [default=false];-+ // 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,- // etc.- CODE_SIZE = 2; // Use ReflectionOps to implement these methods.- LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.+ SPEED = 1; // Generate complete code for parsing, serialization,+ // etc.+ CODE_SIZE = 2; // Use ReflectionOps to implement these methods.+ LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime. }- optional OptimizeMode optimize_for = 9 [default=SPEED];+ optional OptimizeMode optimize_for = 9 [default = SPEED]; // Sets the Go package where structs generated from this .proto will be // placed. If omitted, the Go package will be derived from the following:@@ -367,8 +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).@@ -379,21 +490,21 @@ // that generate code specific to your particular RPC system. Therefore, // these default to false. Old code which depends on generic services should // explicitly set them to true.- 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];+ optional bool cc_generic_services = 16 [default = false];+ optional bool java_generic_services = 17 [default = false];+ optional bool py_generic_services = 18 [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 // for everything in the file, or it will be completely ignored; in the very // least, this is a formalization for deprecating files.- optional bool deprecated = 23 [default=false];+ optional bool deprecated = 23 [default = false]; // Enables the use of arenas for the proto messages in this file. This applies // only to generated classes for C++.- optional bool cc_enable_arenas = 31 [default=false];-+ 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.@@ -417,10 +528,9 @@ // determining the namespace. optional string php_namespace = 41; - // Use this option to change the namespace of php generated metadata classes.- // Default is empty. When this option is empty, the proto file name will be used- // for determining the namespace.+ // Default is empty. When this option is empty, the proto file name will be+ // used for determining the namespace. optional string php_metadata_namespace = 44; // Use this option to change the package of ruby generated classes. Default@@ -428,6 +538,9 @@ // 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. repeated UninterpretedOption uninterpreted_option = 999;@@ -458,19 +571,21 @@ // // Because this is an option, the above two restrictions are not enforced by // the protocol compiler.- optional bool message_set_wire_format = 1 [default=false];+ optional bool message_set_wire_format = 1 [default = false]; // Disables the generation of the standard "descriptor()" accessor, which can // conflict with a field of the same name. This is meant to make migration // from proto1 easier; new code should avoid fields named "descriptor".- optional bool no_standard_descriptor_accessor = 2 [default=false];+ optional bool no_standard_descriptor_accessor = 2 [default = false]; // Is this message deprecated? // Depending on the target platform, this can emit Deprecated annotations // for the message, or it will be completely ignored; in the very least, // this is a formalization for deprecating messages.- optional bool deprecated = 3 [default=false];+ optional bool deprecated = 3 [default = false]; + reserved 4, 5, 6;+ // Whether the message is an automatically generated map entry type for the // maps field. //@@ -486,7 +601,7 @@ // // Implementations may choose not to generate the map_entry=true message, but // use a native map in the target language to hold the keys and values.- // The reflection APIs in such implementions still need to work as+ // The reflection APIs in such implementations still need to work as // if the field is a repeated message field. // // NOTE: Do not set the option in .proto files. Always use the maps syntax@@ -497,6 +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; @@ -505,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;@@ -522,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@@ -565,39 +706,106 @@ // 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.- optional bool lazy = 5 [default=false];+ // 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 // is a formalization for deprecating fields.- optional bool deprecated = 3 [default=false];+ optional bool deprecated = 3 [default = false]; // For Google-internal migration only. Do not use.- optional bool weak = 10 [default=false];+ 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; @@ -615,10 +823,21 @@ // Depending on the target platform, this can emit Deprecated annotations // for the enum, or it will be completely ignored; in the very least, this // is a formalization for deprecating enums.- optional bool deprecated = 3 [default=false];+ optional bool deprecated = 3 [default = false]; 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; @@ -631,8 +850,19 @@ // Depending on the target platform, this can emit Deprecated annotations // for the enum value, or it will be completely ignored; in the very least, // this is a formalization for deprecating enum values.- optional bool deprecated = 1 [default=false];+ 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; @@ -642,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@@ -651,7 +884,7 @@ // Depending on the target platform, this can emit Deprecated annotations // for the service, or it will be completely ignored; in the very least, // this is a formalization for deprecating services.- optional bool deprecated = 33 [default=false];+ optional bool deprecated = 33 [default = false]; // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999;@@ -671,19 +904,22 @@ // Depending on the target platform, this can emit Deprecated annotations // for the method, or it will be completely ignored; in the very least, // this is a formalization for deprecating methods.- optional bool deprecated = 33 [default=false];+ optional bool deprecated = 33 [default = false]; // Is this method side-effect-free (or safe in HTTP parlance), or idempotent, // or neither? HTTP based RPC implementation may choose GET verb for safe // methods, and PUT verb for idempotent methods instead of the default POST. enum IdempotencyLevel { IDEMPOTENCY_UNKNOWN = 0;- NO_SIDE_EFFECTS = 1; // implies idempotent- IDEMPOTENT = 2; // idempotent, but may have side effects+ NO_SIDE_EFFECTS = 1; // implies idempotent+ IDEMPOTENT = 2; // idempotent, but may have side effects }- optional IdempotencyLevel idempotency_level =- 34 [default=IDEMPOTENCY_UNKNOWN];+ 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; @@ -691,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,@@ -702,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;@@ -721,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@@ -763,7 +1164,7 @@ // beginning of the "extend" block and is shared by all extensions within // the block. // - Just because a location's span is a subset of some other location's span- // does not mean that it is a descendent. For example, a "group" defines+ // does not mean that it is a descendant. For example, a "group" defines // both a type and a field in a single declaration. Thus, the locations // corresponding to the type and field and their components will overlap. // - Code which tries to interpret locations should probably be designed to@@ -775,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@@ -794,14 +1195,14 @@ // [ 4, 3, 2, 7 ] // this path refers to the whole field declaration (from the beginning // of the label to the terminating semicolon).- repeated int32 path = 1 [packed=true];+ repeated int32 path = 1 [packed = true]; // Always has exactly three or four elements: start line, start column, // end line (optional, otherwise assumed same as start line), end column. // These are packed into a single field for efficiency. Note that line // and column numbers are zero-based -- typically you will want to add // 1 to each before displaying to a user.- repeated int32 span = 2 [packed=true];+ repeated int32 span = 2 [packed = true]; // If this SourceCodeInfo represents a complete declaration, these are any // comments appearing before and after the declaration which appear to be@@ -830,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.@@ -866,7 +1267,7 @@ message Annotation { // Identifies the element in the original source .proto file. This field // is formatted the same as SourceCodeInfo.Location.path.- repeated int32 path = 1 [packed=true];+ repeated int32 path = 1 [packed = true]; // Identifies the filesystem path to the original source .proto. optional string source_file = 2;@@ -876,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 = "github.com/golang/protobuf/ptypes/duration";+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@@ -61,7 +61,7 @@ // if (duration.seconds < 0 && duration.nanos > 0) { // duration.seconds += 1; // duration.nanos -= 1000000000;-// } else if (durations.seconds > 0 && duration.nanos < 0) {+// } else if (duration.seconds > 0 && duration.nanos < 0) { // duration.seconds -= 1; // duration.nanos += 1000000000; // }@@ -99,9 +99,7 @@ // 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 // to +315,576,000,000 inclusive. Note: these bounds are computed from: // 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
proto-src/google/protobuf/empty.proto view
@@ -32,12 +32,12 @@ package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes";-option go_package = "github.com/golang/protobuf/ptypes/empty";+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
@@ -0,0 +1,245 @@+// 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.++syntax = "proto3";++package google.protobuf;++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;++// `FieldMask` represents a set of symbolic field paths, for example:+//+// paths: "f.a"+// paths: "f.b.d"+//+// Here `f` represents a field in some root message, `a` and `b`+// fields in the message found in `f`, and `d` a field found in the+// message in `f.b`.+//+// Field masks are used to specify a subset of fields that should be+// returned by a get operation or modified by an update operation.+// Field masks also have a custom JSON encoding (see below).+//+// # Field Masks in Projections+//+// When used in the context of a projection, a response message or+// sub-message is filtered by the API to only contain those fields as+// specified in the mask. For example, if the mask in the previous+// example is applied to a response message as follows:+//+// f {+// a : 22+// b {+// d : 1+// x : 2+// }+// y : 13+// }+// z: 8+//+// The result will not contain specific values for fields x,y and z+// (their value will be set to the default, and omitted in proto text+// output):+//+//+// f {+// a : 22+// b {+// d : 1+// }+// }+//+// A repeated field is not allowed except at the last position of a+// paths string.+//+// If a FieldMask object is not present in a get operation, the+// operation applies to all fields (as if a FieldMask of all fields+// had been specified).+//+// Note that a field mask does not necessarily apply to the+// top-level response message. In case of a REST get operation, the+// field mask applies directly to the response, but in case of a REST+// list operation, the mask instead applies to each individual message+// in the returned resource list. In case of a REST custom method,+// other definitions may be used. Where the mask applies will be+// clearly documented together with its declaration in the API. In+// any case, the effect on the returned resource/resources is required+// behavior for APIs.+//+// # Field Masks in Update Operations+//+// A field mask in update operations specifies which fields of the+// targeted resource are going to be updated. The API is required+// to only change the values of the fields as specified in the mask+// and leave the others untouched. If a resource is passed in to+// describe the updated values, the API ignores the values of all+// fields not covered by the mask.+//+// If a repeated field is specified for an update operation, new values will+// be appended to the existing repeated field in the target resource. Note that+// a repeated field is only allowed in the last position of a `paths` string.+//+// If a sub-message is specified in the last position of the field mask for an+// update operation, then new value will be merged into the existing sub-message+// in the target resource.+//+// For example, given the target message:+//+// f {+// b {+// d: 1+// x: 2+// }+// c: [1]+// }+//+// And an update message:+//+// f {+// b {+// d: 10+// }+// c: [2]+// }+//+// then if the field mask is:+//+// paths: ["f.b", "f.c"]+//+// then the result will be:+//+// f {+// b {+// d: 10+// x: 2+// }+// c: [1, 2]+// }+//+// An implementation may provide options to override this default behavior for+// repeated and message fields.+//+// In order to reset a field's value to the default, the field must+// be in the mask and set to the default value in the provided resource.+// Hence, in order to reset all fields of a resource, provide a default+// instance of the resource and set all fields in the mask, or do+// not provide a mask as described below.+//+// If a field mask is not present on update, the operation applies to+// all fields (as if a field mask of all fields has been specified).+// Note that in the presence of schema evolution, this may mean that+// fields the client does not know and has therefore not filled into+// the request will be reset to their default. If this is unwanted+// behavior, a specific service may require a client to always specify+// a field mask, producing an error if not.+//+// As with get operations, the location of the resource which+// describes the updated values in the request message depends on the+// operation kind. In any case, the effect of the field mask is+// required to be honored by the API.+//+// ## Considerations for HTTP REST+//+// The HTTP kind of an update operation which uses a field mask must+// be set to PATCH instead of PUT in order to satisfy HTTP semantics+// (PUT must only be used for full updates).+//+// # JSON Encoding of Field Masks+//+// In JSON, a field mask is encoded as a single string where paths are+// separated by a comma. Fields name in each path are converted+// to/from lower-camel naming conventions.+//+// As an example, consider the following message declarations:+//+// message Profile {+// User user = 1;+// Photo photo = 2;+// }+// message User {+// string display_name = 1;+// string address = 2;+// }+//+// In proto a field mask for `Profile` may look as such:+//+// mask {+// paths: "user.display_name"+// paths: "photo"+// }+//+// In JSON, the same mask is represented as below:+//+// {+// mask: "user.displayName,photo"+// }+//+// # Field Masks and Oneof Fields+//+// Field masks treat fields in oneofs just as regular fields. Consider the+// following message:+//+// message SampleMessage {+// oneof test_oneof {+// string name = 4;+// SubMessage sub_message = 9;+// }+// }+//+// The field mask can be:+//+// mask {+// paths: "name"+// }+//+// Or:+//+// mask {+// paths: "sub_message"+// }+//+// Note that oneof type names ("test_oneof" in this case) cannot be used in+// paths.+//+// ## Field Mask Verification+//+// The implementation of any API method which has a FieldMask type field in the+// request should verify the included field paths, and return an+// `INVALID_ARGUMENT` error if any path is unmappable.+message FieldMask {+ // The set of field mask paths.+ repeated string paths = 1;+}
+ proto-src/google/protobuf/source_context.proto view
@@ -0,0 +1,48 @@+// 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.++syntax = "proto3";++package google.protobuf;++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+// protobuf element, like the file in which it is defined.+message SourceContext {+ // The path-qualified name of the .proto file that contained the associated+ // protobuf element. For example: `"google/protobuf/source_context.proto"`.+ string file_name = 1;+}
+ proto-src/google/protobuf/struct.proto view
@@ -0,0 +1,95 @@+// 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.++syntax = "proto3";++package google.protobuf;++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`+// might be supported by a native representation. For example, in+// scripting languages like JS a struct is represented as an+// object. The details of that representation are described together+// with the proto support for the language.+//+// The JSON representation for `Struct` is JSON object.+message Struct {+ // Unordered map of dynamically typed values.+ map<string, Value> fields = 1;+}++// `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 these+// variants. Absence of any variant indicates an error.+//+// The JSON representation for `Value` is JSON value.+message Value {+ // The kind of value.+ oneof kind {+ // Represents a null value.+ NullValue null_value = 1;+ // Represents a double value.+ double number_value = 2;+ // Represents a string value.+ string string_value = 3;+ // Represents a boolean value.+ bool bool_value = 4;+ // Represents a structured value.+ Struct struct_value = 5;+ // Represents a repeated `Value`.+ ListValue list_value = 6;+ }+}++// `NullValue` is a singleton enumeration to represent the null value for the+// `Value` type union.+//+// The JSON representation for `NullValue` is JSON `null`.+enum NullValue {+ // Null value.+ NULL_VALUE = 0;+}++// `ListValue` is a wrapper around a repeated field of values.+//+// The JSON representation for `ListValue` is JSON array.+message ListValue {+ // Repeated field of dynamically typed values.+ repeated Value values = 1;+}
proto-src/google/protobuf/timestamp.proto view
@@ -32,26 +32,28 @@ package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true;-option go_package = "github.com/golang/protobuf/ptypes/timestamp";+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 calendar, represented as seconds and fractions of seconds at-// nanosecond resolution in UTC Epoch time. It is encoded using the-// Proleptic Gregorian Calendar which extends the Gregorian calendar-// backwards to year one. It is encoded assuming all minutes are 60-// seconds long, i.e. leap seconds are "smeared" so that no leap second-// table is needed for interpretation. Range is from-// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.-// By restricting to that range, we ensure that we can convert to-// and from RFC 3339 date strings.-// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).+// 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+// nanosecond resolution. The count is relative to an epoch at UTC midnight on+// January 1, 1970, in the proleptic Gregorian calendar which extends the+// Gregorian calendar backwards to year one. //+// All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap+// second table is needed for interpretation, using a [24-hour linear+// smear](https://developers.google.com/time/smear).+//+// The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By+// restricting to that range, we ensure that we can convert to and from [RFC+// 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.+// // # Examples // // Example 1: Compute Timestamp from POSIX `time()`.@@ -88,9 +90,16 @@ // Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) // .setNanos((int) ((millis % 1000) * 1000000)).build(); //+// Example 5: Compute Timestamp from Java `Instant.now()`. //-// Example 5: Compute Timestamp from current time in Python.+// Instant now = Instant.now(); //+// Timestamp timestamp =+// Timestamp.newBuilder().setSeconds(now.getEpochSecond())+// .setNanos(now.getNano()).build();+//+// Example 6: Compute Timestamp from current time in Python.+// // timestamp = Timestamp() // timestamp.GetCurrentTime() //@@ -111,17 +120,17 @@ // 01:30 UTC on January 15, 2017. // // In JavaScript, one can convert a Date object to this format using the-// standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString]+// standard+// [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) // method. In Python, a standard `datetime.datetime` object can be converted-// to this format using [`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--+// to this format using+// [`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://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 // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to // 9999-12-31T23:59:59Z inclusive.
+ proto-src/google/protobuf/type.proto view
@@ -0,0 +1,193 @@+// 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.++syntax = "proto3";++package google.protobuf;++import "google/protobuf/any.proto";+import "google/protobuf/source_context.proto";++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.+message Type {+ // The fully qualified message name.+ string name = 1;+ // The list of fields.+ repeated Field fields = 2;+ // The list of types appearing in `oneof` definitions in this type.+ repeated string oneofs = 3;+ // The protocol buffer options.+ repeated Option options = 4;+ // The source context.+ 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.+message Field {+ // Basic field types.+ enum Kind {+ // Field type unknown.+ TYPE_UNKNOWN = 0;+ // Field type double.+ TYPE_DOUBLE = 1;+ // Field type float.+ TYPE_FLOAT = 2;+ // Field type int64.+ TYPE_INT64 = 3;+ // Field type uint64.+ TYPE_UINT64 = 4;+ // Field type int32.+ TYPE_INT32 = 5;+ // Field type fixed64.+ TYPE_FIXED64 = 6;+ // Field type fixed32.+ TYPE_FIXED32 = 7;+ // Field type bool.+ TYPE_BOOL = 8;+ // Field type string.+ TYPE_STRING = 9;+ // Field type group. Proto2 syntax only, and deprecated.+ TYPE_GROUP = 10;+ // Field type message.+ TYPE_MESSAGE = 11;+ // Field type bytes.+ TYPE_BYTES = 12;+ // Field type uint32.+ TYPE_UINT32 = 13;+ // Field type enum.+ TYPE_ENUM = 14;+ // Field type sfixed32.+ TYPE_SFIXED32 = 15;+ // Field type sfixed64.+ TYPE_SFIXED64 = 16;+ // Field type sint32.+ TYPE_SINT32 = 17;+ // Field type sint64.+ TYPE_SINT64 = 18;+ }++ // Whether a field is optional, required, or repeated.+ enum Cardinality {+ // For fields with unknown cardinality.+ CARDINALITY_UNKNOWN = 0;+ // For optional fields.+ CARDINALITY_OPTIONAL = 1;+ // For required fields. Proto2 syntax only.+ CARDINALITY_REQUIRED = 2;+ // For repeated fields.+ CARDINALITY_REPEATED = 3;+ }++ // The field type.+ Kind kind = 1;+ // The field cardinality.+ Cardinality cardinality = 2;+ // The field number.+ int32 number = 3;+ // The field name.+ string name = 4;+ // The field type URL, without the scheme, for message or enumeration+ // types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.+ string type_url = 6;+ // The index of the field type in `Type.oneofs`, for message or enumeration+ // types. The first type has index 1; zero means the type is not in the list.+ int32 oneof_index = 7;+ // Whether to use alternative packed wire representation.+ bool packed = 8;+ // The protocol buffer options.+ repeated Option options = 9;+ // The field JSON name.+ string json_name = 10;+ // The string value of the default value of this field. Proto2 syntax only.+ string default_value = 11;+}++// Enum type definition.+message Enum {+ // Enum type name.+ string name = 1;+ // Enum value definitions.+ repeated EnumValue enumvalue = 2;+ // Protocol buffer options.+ repeated Option options = 3;+ // The source context.+ 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.+message EnumValue {+ // Enum value name.+ string name = 1;+ // Enum value number.+ int32 number = 2;+ // Protocol buffer options.+ repeated Option options = 3;+}++// A protocol buffer option, which can be attached to a message, field,+// enumeration, etc.+message Option {+ // The option's name. For protobuf built-in options (options defined in+ // descriptor.proto), this is the short name. For example, `"map_entry"`.+ // For custom options, it should be the fully-qualified name. For example,+ // `"google.api.http"`.+ string name = 1;+ // The option's value packed in an Any message. If the value is a primitive,+ // the corresponding wrapper type defined in google/protobuf/wrappers.proto+ // should be used. If the value is an enum, it should be stored as an int32+ // value using the google.protobuf.Int32Value type.+ Any value = 2;+}++// The syntax in which a protocol buffer element is defined.+enum Syntax {+ // Syntax `proto2`.+ SYNTAX_PROTO2 = 0;+ // Syntax `proto3`.+ SYNTAX_PROTO3 = 1;+ // Syntax `editions`.+ SYNTAX_EDITIONS = 2;+}
proto-src/google/protobuf/wrappers.proto view
@@ -27,23 +27,28 @@ // 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 // typed field and its default value.+//+// These wrappers have no meaningful use within repeated fields as they lack+// the ability to detect presence on individual elements.+// These wrappers have no meaningful use within a map or a oneof since+// individual entries of a map or fields of a oneof can already detect presence. syntax = "proto3"; package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true;-option go_package = "github.com/golang/protobuf/ptypes/wrappers";+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`. //
src/Data/ProtoLens/Any.hs view
@@ -1,5 +1,4 @@ {-# LANGUAGE CPP #-}-{-# LANGUAGE OverloadedLabels #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-}@@ -17,17 +16,16 @@ #endif import qualified Data.Text as Text import Data.Text (Text)-import Data.Typeable (Typeable) import Data.ProtoLens ( decodeMessage , defMessage , encodeMessage , Message(..) )-import Data.ProtoLens.Labels () import Data.Proxy (Proxy(..)) import Lens.Family2 ((&), (.~), (^.)) import Proto.Google.Protobuf.Any+import Proto.Google.Protobuf.Any_Fields (typeUrl, value) -- | Packs the given message into an 'Any' using the default type URL prefix -- "type.googleapis.com".@@ -41,8 +39,8 @@ packWithPrefix :: forall a . Message a => Text -> a -> Any packWithPrefix prefix x = defMessage- & #typeUrl .~ (prefix <> "/" <> name)- & #value .~ encodeMessage x+ & typeUrl .~ (prefix <> "/" <> name)+ & value .~ encodeMessage x where name = messageName (Proxy @a) @@ -54,7 +52,7 @@ , actualUrl :: Text -- ^ The typeUrl in the 'Any' being unpacked } | DecodingError Text -- ^ The error from decodeMessage- deriving (Show, Eq, Typeable)+ deriving (Show, Eq) instance Exception UnpackError @@ -64,12 +62,12 @@ -- Ignores the type URL prefix. unpack :: forall a . Message a => Any -> Either UnpackError a unpack a- | expectedName /= snd (Text.breakOnEnd "/" $ a ^. #typeUrl)+ | expectedName /= snd (Text.breakOnEnd "/" $ a ^. typeUrl) = Left DifferentType { expectedMessageType = expectedName- , actualUrl = a ^. #typeUrl+ , actualUrl = a ^. typeUrl }- | otherwise = case decodeMessage (a ^. #value) of+ | otherwise = case decodeMessage (a ^. value) of Left e -> Left $ DecodingError $ Text.pack e Right x -> Right x where
+ src/Data/ProtoLens/Descriptor.hs view
@@ -0,0 +1,43 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeApplications #-}+-- | Functions for interacting with message descriptors.+module Data.ProtoLens.Descriptor+ ( DescriptorProto+ , messageDescriptor+ , serviceDescriptor+ , fileDescriptor+ ) where++import Data.ProtoLens+import Data.ProtoLens.Service.Types+import Data.Proxy (Proxy(..))+import Proto.Google.Protobuf.Descriptor++-- | The protocol buffer message descriptor for a given type.+--+-- This function should be used with @TypeApplications@, e.g.:+--+-- > messageDescriptor @SomeProtoType+messageDescriptor :: forall a . Message a => DescriptorProto+-- Note: technically decodeMessageOrDie can fail. However, it's+-- unlikely in practice since we encode the message ourselves+-- in proto-lens-protoc; and furthermore proto decoding is robust+-- to unknown/missing fields.+messageDescriptor = decodeMessageOrDie $ packedMessageDescriptor (Proxy @a)++-- | The protocol buffer service descriptor for a given service.+--+-- This function should be used with @TypeApplications@, e.g.:+--+-- > serviceDescriptor @SomeService+serviceDescriptor :: forall a . Service a => ServiceDescriptorProto+serviceDescriptor = decodeMessageOrDie $ packedServiceDescriptor (Proxy @a)++-- | The protocol buffer file descriptor containing a given type.+--+-- This function should be used with @TypeApplications@, e.g.:+--+-- > fileDescriptor @SomeProtoType+fileDescriptor :: forall a . Message a => FileDescriptorProto+fileDescriptor = decodeMessageOrDie $ packedFileDescriptor (Proxy @a)