betterproto2-compiler 0.0.1__py3-none-any.whl

betterproto2_compiler/lib/std/google/protobuf/__init__.py

@@ -0,0 +1,2517 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# sources: google/protobuf/any.proto, google/protobuf/api.proto, google/protobuf/descriptor.proto,
+# google/protobuf/duration.proto, google/protobuf/empty.proto, google/protobuf/field_mask.proto,
+# google/protobuf/source_context.proto, google/protobuf/struct.proto, google/protobuf/timestamp.proto,
+# google/protobuf/type.proto, google/protobuf/wrappers.proto
+# plugin: python-betterproto
+# This file has been @generated
+
+__all__ = (
+    "Syntax",
+    "FieldKind",
+    "FieldCardinality",
+    "FieldDescriptorProtoType",
+    "FieldDescriptorProtoLabel",
+    "FileOptionsOptimizeMode",
+    "FieldOptionsCType",
+    "FieldOptionsJsType",
+    "MethodOptionsIdempotencyLevel",
+    "NullValue",
+    "Any",
+    "SourceContext",
+    "Type",
+    "Field",
+    "Enum",
+    "EnumValue",
+    "Option",
+    "Api",
+    "Method",
+    "Mixin",
+    "FileDescriptorSet",
+    "FileDescriptorProto",
+    "DescriptorProto",
+    "DescriptorProtoExtensionRange",
+    "DescriptorProtoReservedRange",
+    "ExtensionRangeOptions",
+    "FieldDescriptorProto",
+    "OneofDescriptorProto",
+    "EnumDescriptorProto",
+    "EnumDescriptorProtoEnumReservedRange",
+    "EnumValueDescriptorProto",
+    "ServiceDescriptorProto",
+    "MethodDescriptorProto",
+    "FileOptions",
+    "MessageOptions",
+    "FieldOptions",
+    "OneofOptions",
+    "EnumOptions",
+    "EnumValueOptions",
+    "ServiceOptions",
+    "MethodOptions",
+    "UninterpretedOption",
+    "UninterpretedOptionNamePart",
+    "SourceCodeInfo",
+    "SourceCodeInfoLocation",
+    "GeneratedCodeInfo",
+    "GeneratedCodeInfoAnnotation",
+    "Duration",
+    "Empty",
+    "FieldMask",
+    "Struct",
+    "Value",
+    "ListValue",
+    "Timestamp",
+    "DoubleValue",
+    "FloatValue",
+    "Int64Value",
+    "UInt64Value",
+    "Int32Value",
+    "UInt32Value",
+    "BoolValue",
+    "StringValue",
+    "BytesValue",
+)
+
+import warnings
+from dataclasses import dataclass
+from typing import (
+    Dict,
+    List,
+    Mapping,
+    Optional,
+)
+
+import betterproto
+from betterproto.utils import hybridmethod
+from typing_extensions import Self
+
+
+class Syntax(betterproto.Enum):
+    """The syntax in which a protocol buffer element is defined."""
+
+    PROTO2 = 0
+    """Syntax `proto2`."""
+
+    PROTO3 = 1
+    """Syntax `proto3`."""
+
+
+class FieldKind(betterproto.Enum):
+    """Basic field types."""
+
+    TYPE_UNKNOWN = 0
+    """Field type unknown."""
+
+    TYPE_DOUBLE = 1
+    """Field type double."""
+
+    TYPE_FLOAT = 2
+    """Field type float."""
+
+    TYPE_INT64 = 3
+    """Field type int64."""
+
+    TYPE_UINT64 = 4
+    """Field type uint64."""
+
+    TYPE_INT32 = 5
+    """Field type int32."""
+
+    TYPE_FIXED64 = 6
+    """Field type fixed64."""
+
+    TYPE_FIXED32 = 7
+    """Field type fixed32."""
+
+    TYPE_BOOL = 8
+    """Field type bool."""
+
+    TYPE_STRING = 9
+    """Field type string."""
+
+    TYPE_GROUP = 10
+    """Field type group. Proto2 syntax only, and deprecated."""
+
+    TYPE_MESSAGE = 11
+    """Field type message."""
+
+    TYPE_BYTES = 12
+    """Field type bytes."""
+
+    TYPE_UINT32 = 13
+    """Field type uint32."""
+
+    TYPE_ENUM = 14
+    """Field type enum."""
+
+    TYPE_SFIXED32 = 15
+    """Field type sfixed32."""
+
+    TYPE_SFIXED64 = 16
+    """Field type sfixed64."""
+
+    TYPE_SINT32 = 17
+    """Field type sint32."""
+
+    TYPE_SINT64 = 18
+    """Field type sint64."""
+
+
+class FieldCardinality(betterproto.Enum):
+    """Whether a field is optional, required, or repeated."""
+
+    CARDINALITY_UNKNOWN = 0
+    """For fields with unknown cardinality."""
+
+    CARDINALITY_OPTIONAL = 1
+    """For optional fields."""
+
+    CARDINALITY_REQUIRED = 2
+    """For required fields. Proto2 syntax only."""
+
+    CARDINALITY_REPEATED = 3
+    """For repeated fields."""
+
+
+class FieldDescriptorProtoType(betterproto.Enum):
+    """ """
+
+    TYPE_DOUBLE = 1
+    """
+    0 is reserved for errors.
+    Order is weird for historical reasons.
+    """
+
+    TYPE_FLOAT = 2
+    """
+    
+    """
+
+    TYPE_INT64 = 3
+    """
+    Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
+    negative values are likely.
+    """
+
+    TYPE_UINT64 = 4
+    """
+    
+    """
+
+    TYPE_INT32 = 5
+    """
+    Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
+    negative values are likely.
+    """
+
+    TYPE_FIXED64 = 6
+    """
+    
+    """
+
+    TYPE_FIXED32 = 7
+    """
+    
+    """
+
+    TYPE_BOOL = 8
+    """
+    
+    """
+
+    TYPE_STRING = 9
+    """
+    
+    """
+
+    TYPE_GROUP = 10
+    """
+    Tag-delimited aggregate.
+    Group type is deprecated and not supported in proto3. However, Proto3
+    implementations should still be able to parse the group wire format and
+    treat group fields as unknown fields.
+    """
+
+    TYPE_MESSAGE = 11
+    """Length-delimited aggregate."""
+
+    TYPE_BYTES = 12
+    """New in version 2."""
+
+    TYPE_UINT32 = 13
+    """
+    
+    """
+
+    TYPE_ENUM = 14
+    """
+    
+    """
+
+    TYPE_SFIXED32 = 15
+    """
+    
+    """
+
+    TYPE_SFIXED64 = 16
+    """
+    
+    """
+
+    TYPE_SINT32 = 17
+    """Uses ZigZag encoding."""
+
+    TYPE_SINT64 = 18
+    """Uses ZigZag encoding."""
+
+
+class FieldDescriptorProtoLabel(betterproto.Enum):
+    """ """
+
+    LABEL_OPTIONAL = 1
+    """0 is reserved for errors"""
+
+    LABEL_REQUIRED = 2
+    """
+    
+    """
+
+    LABEL_REPEATED = 3
+    """
+    
+    """
+
+
+class FileOptionsOptimizeMode(betterproto.Enum):
+    """Generated classes can be optimized for speed or code size."""
+
+    SPEED = 1
+    """Generate complete code for parsing, serialization,"""
+
+    CODE_SIZE = 2
+    """
+    etc.
+    
+    Use ReflectionOps to implement these methods.
+    """
+
+    LITE_RUNTIME = 3
+    """Generate code using MessageLite and the lite runtime."""
+
+
+class FieldOptionsCType(betterproto.Enum):
+    """ """
+
+    STRING = 0
+    """Default mode."""
+
+    CORD = 1
+    """
+    
+    """
+
+    STRING_PIECE = 2
+    """
+    
+    """
+
+
+class FieldOptionsJsType(betterproto.Enum):
+    """ """
+
+    JS_NORMAL = 0
+    """Use the default type."""
+
+    JS_STRING = 1
+    """Use JavaScript strings."""
+
+    JS_NUMBER = 2
+    """Use JavaScript numbers."""
+
+
+class MethodOptionsIdempotencyLevel(betterproto.Enum):
+    """
+    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.
+    """
+
+    IDEMPOTENCY_UNKNOWN = 0
+    """
+    
+    """
+
+    NO_SIDE_EFFECTS = 1
+    """implies idempotent"""
+
+    IDEMPOTENT = 2
+    """idempotent, but may have side effects"""
+
+
+class NullValue(betterproto.Enum):
+    """
+    `NullValue` is a singleton enumeration to represent the null value for the
+    `Value` type union.
+
+     The JSON representation for `NullValue` is JSON `null`.
+    """
+
+    _ = 0
+    """Null value."""
+
+
+@dataclass(eq=False, repr=False)
+class Any(betterproto.Message):
+    """
+    `Any` contains an arbitrary serialized protocol buffer message along with a
+    URL that describes the type of the serialized message.
+
+    Protobuf library provides support to pack/unpack Any values in the form
+    of utility functions or additional generated methods of the Any type.
+
+    Example 1: Pack and unpack a message in C++.
+
+        Foo foo = ...;
+        Any any;
+        any.PackFrom(foo);
+        ...
+        if (any.UnpackTo(&foo)) {
+          ...
+        }
+
+    Example 2: Pack and unpack a message in Java.
+
+        Foo foo = ...;
+        Any any = Any.pack(foo);
+        ...
+        if (any.is(Foo.class)) {
+          foo = any.unpack(Foo.class);
+        }
+
+     Example 3: Pack and unpack a message in Python.
+
+        foo = Foo(...)
+        any = Any()
+        any.Pack(foo)
+        ...
+        if any.Is(Foo.DESCRIPTOR):
+          any.Unpack(foo)
+          ...
+
+     Example 4: Pack and unpack a message in Go
+
+         foo := &pb.Foo{...}
+         any, err := ptypes.MarshalAny(foo)
+         ...
+         foo := &pb.Foo{}
+         if err := ptypes.UnmarshalAny(any, foo); err != nil {
+           ...
+         }
+
+    The pack methods provided by protobuf library will by default use
+    'type.googleapis.com/full.type.name' as the type URL and the unpack
+    methods only use the fully qualified type name after the last '/'
+    in the type URL, for example "foo.bar.com/x/y.z" will yield type
+    name "y.z".
+
+    JSON
+    ====
+    The JSON representation of an `Any` value uses the regular
+    representation of the deserialized, embedded message, with an
+    additional field `@type` which contains the type URL. Example:
+
+        package google.profile;
+        message Person {
+          string first_name = 1;
+          string last_name = 2;
+        }
+
+        {
+          "@type": "type.googleapis.com/google.profile.Person",
+          "firstName": <string>,
+          "lastName": <string>
+        }
+
+    If the embedded message type is well-known and has a custom JSON
+    representation, that representation will be embedded adding a field
+    `value` which holds the custom JSON in addition to the `@type`
+    field. Example (for message [google.protobuf.Duration][]):
+
+        {
+          "@type": "type.googleapis.com/google.protobuf.Duration",
+          "value": "1.212s"
+        }
+    """
+
+    type_url: str = betterproto.string_field(1)
+    """
+    A URL/resource name that uniquely identifies the type of the serialized
+    protocol buffer message. This string must contain at least
+    one "/" character. The last segment of the URL's path must represent
+    the fully qualified name of the type (as in
+    `path/google.protobuf.Duration`). The name should be in a canonical form
+    (e.g., leading "." is not accepted).
+    
+    In practice, teams usually precompile into the binary all types that they
+    expect it to use in the context of Any. However, for URLs which use the
+    scheme `http`, `https`, or no scheme, one can optionally set up a type
+    server that maps type URLs to message definitions as follows:
+    
+    * If no scheme is provided, `https` is assumed.
+    * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+      value in binary format, or produce an error.
+    * Applications are allowed to cache lookup results based on the
+      URL, or have them precompiled into a binary to avoid any
+      lookup. Therefore, binary compatibility needs to be preserved
+      on changes to types. (Use versioned type names to manage
+      breaking changes.)
+    
+    Note: this functionality is not currently available in the official
+    protobuf release, and it is not used for type URLs beginning with
+    type.googleapis.com.
+    
+    Schemes other than `http`, `https` (or the empty scheme) might be
+    used with implementation specific semantics.
+    """
+
+    value: bytes = betterproto.bytes_field(2)
+    """
+    Must be a valid serialized protocol buffer of the above specified type.
+    """
+
+
+@dataclass(eq=False, repr=False)
+class SourceContext(betterproto.Message):
+    """
+    `SourceContext` represents information about the source of a
+    protobuf element, like the file in which it is defined.
+    """
+
+    file_name: str = betterproto.string_field(1)
+    """
+    The path-qualified name of the .proto file that contained the associated
+    protobuf element.  For example: `"google/protobuf/source_context.proto"`.
+    """
+
+
+@dataclass(eq=False, repr=False)
+class Type(betterproto.Message):
+    """A protocol buffer message type."""
+
+    name: str = betterproto.string_field(1)
+    """The fully qualified message name."""
+
+    fields: List["Field"] = betterproto.message_field(2, repeated=True)
+    """The list of fields."""
+
+    oneofs: List[str] = betterproto.string_field(3, repeated=True)
+    """The list of types appearing in `oneof` definitions in this type."""
+
+    options: List["Option"] = betterproto.message_field(4, repeated=True)
+    """The protocol buffer options."""
+
+    source_context: "SourceContext" = betterproto.message_field(5)
+    """The source context."""
+
+    syntax: "Syntax" = betterproto.enum_field(6, enum_default_value=lambda: Syntax.try_value(0))
+    """The source syntax."""
+
+
+@dataclass(eq=False, repr=False)
+class Field(betterproto.Message):
+    """A single field of a message type."""
+
+    kind: "FieldKind" = betterproto.enum_field(1, enum_default_value=lambda: FieldKind.try_value(0))
+    """The field type."""
+
+    cardinality: "FieldCardinality" = betterproto.enum_field(
+        2, enum_default_value=lambda: FieldCardinality.try_value(0)
+    )
+    """The field cardinality."""
+
+    number: int = betterproto.int32_field(3)
+    """The field number."""
+
+    name: str = betterproto.string_field(4)
+    """The field name."""
+
+    type_url: str = betterproto.string_field(6)
+    """
+    The field type URL, without the scheme, for message or enumeration
+    types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
+    """
+
+    oneof_index: int = betterproto.int32_field(7)
+    """
+    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.
+    """
+
+    packed: bool = betterproto.bool_field(8)
+    """Whether to use alternative packed wire representation."""
+
+    options: List["Option"] = betterproto.message_field(9, repeated=True)
+    """The protocol buffer options."""
+
+    json_name: str = betterproto.string_field(10)
+    """The field JSON name."""
+
+    default_value: str = betterproto.string_field(11)
+    """
+    The string value of the default value of this field. Proto2 syntax only.
+    """
+
+
+@dataclass(eq=False, repr=False)
+class Enum(betterproto.Message):
+    """Enum type definition."""
+
+    name: str = betterproto.string_field(1)
+    """Enum type name."""
+
+    enumvalue: List["EnumValue"] = betterproto.message_field(2, wraps=betterproto.TYPE_ENUM, repeated=True)
+    """Enum value definitions."""
+
+    options: List["Option"] = betterproto.message_field(3, repeated=True)
+    """Protocol buffer options."""
+
+    source_context: "SourceContext" = betterproto.message_field(4)
+    """The source context."""
+
+    syntax: "Syntax" = betterproto.enum_field(5, enum_default_value=lambda: Syntax.try_value(0))
+    """The source syntax."""
+
+
+@dataclass(eq=False, repr=False)
+class EnumValue(betterproto.Message):
+    """Enum value definition."""
+
+    name: str = betterproto.string_field(1)
+    """Enum value name."""
+
+    number: int = betterproto.int32_field(2)
+    """Enum value number."""
+
+    options: List["Option"] = betterproto.message_field(3, repeated=True)
+    """Protocol buffer options."""
+
+
+@dataclass(eq=False, repr=False)
+class Option(betterproto.Message):
+    """
+    A protocol buffer option, which can be attached to a message, field,
+    enumeration, etc.
+    """
+
+    name: str = betterproto.string_field(1)
+    """
+    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"`.
+    """
+
+    value: "Any" = betterproto.message_field(2)
+    """
+    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.
+    """
+
+
+@dataclass(eq=False, repr=False)
+class Api(betterproto.Message):
+    """
+    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.
+    """
+
+    name: str = betterproto.string_field(1)
+    """
+    The fully qualified name of this interface, including package name
+    followed by the interface's simple name.
+    """
+
+    methods: List["Method"] = betterproto.message_field(2, repeated=True)
+    """The methods of this interface, in unspecified order."""
+
+    options: List["Option"] = betterproto.message_field(3, repeated=True)
+    """Any metadata attached to the interface."""
+
+    version: str = betterproto.string_field(4)
+    """
+    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.
+    """
+
+    source_context: "SourceContext" = betterproto.message_field(5)
+    """
+    Source context for the protocol buffer service represented by this
+    message.
+    """
+
+    mixins: List["Mixin"] = betterproto.message_field(6, repeated=True)
+    """Included interfaces. See [Mixin][]."""
+
+    syntax: "Syntax" = betterproto.enum_field(7, enum_default_value=lambda: Syntax.try_value(0))
+    """The source syntax of the service."""
+
+
+@dataclass(eq=False, repr=False)
+class Method(betterproto.Message):
+    """Method represents a method of an API interface."""
+
+    name: str = betterproto.string_field(1)
+    """The simple name of this method."""
+
+    request_type_url: str = betterproto.string_field(2)
+    """A URL of the input message type."""
+
+    request_streaming: bool = betterproto.bool_field(3)
+    """If true, the request is streamed."""
+
+    response_type_url: str = betterproto.string_field(4)
+    """The URL of the output message type."""
+
+    response_streaming: bool = betterproto.bool_field(5)
+    """If true, the response is streamed."""
+
+    options: List["Option"] = betterproto.message_field(6, repeated=True)
+    """Any metadata attached to the method."""
+
+    syntax: "Syntax" = betterproto.enum_field(7, enum_default_value=lambda: Syntax.try_value(0))
+    """The source syntax of this method."""
+
+
+@dataclass(eq=False, repr=False)
+class Mixin(betterproto.Message):
+    """
+    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";
+          }
+          ...
+        }
+    """
+
+    name: str = betterproto.string_field(1)
+    """The fully qualified name of the interface which is included."""
+
+    root: str = betterproto.string_field(2)
+    """
+    If non-empty specifies a path under which inherited HTTP paths
+    are rooted.
+    """
+
+
+@dataclass(eq=False, repr=False)
+class FileDescriptorSet(betterproto.Message):
+    """
+    The protocol compiler can output a FileDescriptorSet containing the .proto
+    files it parses.
+    """
+
+    file: List["FileDescriptorProto"] = betterproto.message_field(1, repeated=True)
+    """
+    
+    """
+
+
+@dataclass(eq=False, repr=False)
+class FileDescriptorProto(betterproto.Message):
+    """Describes a complete .proto file."""
+
+    name: str = betterproto.string_field(1)
+    """file name, relative to root of source tree"""
+
+    package: str = betterproto.string_field(2)
+    """e.g. "foo", "foo.bar", etc."""
+
+    dependency: List[str] = betterproto.string_field(3, repeated=True)
+    """Names of files imported by this file."""
+
+    public_dependency: List[int] = betterproto.int32_field(10, repeated=True)
+    """Indexes of the public imported files in the dependency list above."""
+
+    weak_dependency: List[int] = betterproto.int32_field(11, repeated=True)
+    """
+    Indexes of the weak imported files in the dependency list.
+    For Google-internal migration only. Do not use.
+    """
+
+    message_type: List["DescriptorProto"] = betterproto.message_field(4, repeated=True)
+    """All top-level definitions in this file."""
+
+    enum_type: List["EnumDescriptorProto"] = betterproto.message_field(5, repeated=True)
+    """
+    
+    """
+
+    service: List["ServiceDescriptorProto"] = betterproto.message_field(6, repeated=True)
+    """
+    
+    """
+
+    extension: List["FieldDescriptorProto"] = betterproto.message_field(7, repeated=True)
+    """
+    
+    """
+
+    options: "FileOptions" = betterproto.message_field(8)
+    """
+    
+    """
+
+    source_code_info: "SourceCodeInfo" = betterproto.message_field(9)
+    """
+    This field contains optional information about the original source code.
+    You may safely remove this entire field without harming runtime
+    functionality of the descriptors -- the information is needed only by
+    development tools.
+    """
+
+    syntax: str = betterproto.string_field(12)
+    """
+    The syntax of the proto file.
+    The supported values are "proto2" and "proto3".
+    """
+
+
+@dataclass(eq=False, repr=False)
+class DescriptorProto(betterproto.Message):
+    """Describes a message type."""
+
+    name: str = betterproto.string_field(1)
+    """
+    
+    """
+
+    field: List["FieldDescriptorProto"] = betterproto.message_field(2, repeated=True)
+    """
+    
+    """
+
+    extension: List["FieldDescriptorProto"] = betterproto.message_field(6, repeated=True)
+    """
+    
+    """
+
+    nested_type: List["DescriptorProto"] = betterproto.message_field(3, repeated=True)
+    """
+    
+    """
+
+    enum_type: List["EnumDescriptorProto"] = betterproto.message_field(4, repeated=True)
+    """
+    
+    """
+
+    extension_range: List["DescriptorProtoExtensionRange"] = betterproto.message_field(5, repeated=True)
+    """
+    
+    """
+
+    oneof_decl: List["OneofDescriptorProto"] = betterproto.message_field(8, repeated=True)
+    """
+    
+    """
+
+    options: "MessageOptions" = betterproto.message_field(7)
+    """
+    
+    """
+
+    reserved_range: List["DescriptorProtoReservedRange"] = betterproto.message_field(9, repeated=True)
+    """
+    
+    """
+
+    reserved_name: List[str] = betterproto.string_field(10, repeated=True)
+    """
+    Reserved field names, which may not be used by fields in the same message.
+    A given name may only be reserved once.
+    """
+
+
+@dataclass(eq=False, repr=False)
+class DescriptorProtoExtensionRange(betterproto.Message):
+    """ """
+
+    start: int = betterproto.int32_field(1)
+    """Inclusive."""
+
+    end: int = betterproto.int32_field(2)
+    """Exclusive."""
+
+    options: "ExtensionRangeOptions" = betterproto.message_field(3)
+    """
+    
+    """
+
+
+@dataclass(eq=False, repr=False)
+class DescriptorProtoReservedRange(betterproto.Message):
+    """
+    Range of reserved tag numbers. Reserved tag numbers may not be used by
+    fields or extension ranges in the same message. Reserved ranges may
+    not overlap.
+    """
+
+    start: int = betterproto.int32_field(1)
+    """Inclusive."""
+
+    end: int = betterproto.int32_field(2)
+    """Exclusive."""
+
+
+@dataclass(eq=False, repr=False)
+class ExtensionRangeOptions(betterproto.Message):
+    """ """
+
+    uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999, repeated=True)
+    """The parser stores options it doesn't recognize here. See above."""
+
+
+@dataclass(eq=False, repr=False)
+class FieldDescriptorProto(betterproto.Message):
+    """Describes a field within a message."""
+
+    name: str = betterproto.string_field(1)
+    """
+    
+    """
+
+    number: int = betterproto.int32_field(3)
+    """
+    
+    """
+
+    label: "FieldDescriptorProtoLabel" = betterproto.enum_field(
+        4, enum_default_value=lambda: FieldDescriptorProtoLabel.try_value(0)
+    )
+    """
+    
+    """
+
+    type: "FieldDescriptorProtoType" = betterproto.enum_field(
+        5, enum_default_value=lambda: FieldDescriptorProtoType.try_value(0)
+    )
+    """
+    If type_name is set, this need not be set.  If both this and type_name
+    are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
+    """
+
+    type_name: str = betterproto.string_field(6)
+    """
+    For message and enum types, this is the name of the type.  If the name
+    starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
+    rules are used to find the type (i.e. first the nested types within this
+    message are searched, then within the parent, on up to the root
+    namespace).
+    """
+
+    extendee: str = betterproto.string_field(2)
+    """
+    For extensions, this is the name of the type being extended.  It is
+    resolved in the same manner as type_name.
+    """
+
+    default_value: str = betterproto.string_field(7)
+    """
+    For numeric types, contains the original text representation of the value.
+    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?
+    """
+
+    oneof_index: Optional[int] = betterproto.int32_field(9, optional=True)
+    """
+    If set, gives the index of a oneof in the containing type's oneof_decl
+    list.  This field is a member of that oneof.
+    """
+
+    json_name: str = betterproto.string_field(10)
+    """
+    JSON name of this field. The value is set by protocol compiler. If the
+    user has set a "json_name" option on this field, that option's value
+    will be used. Otherwise, it's deduced from the field's name by converting
+    it to camelCase.
+    """
+
+    options: "FieldOptions" = betterproto.message_field(8)
+    """
+    
+    """
+
+    proto3_optional: bool = betterproto.bool_field(17)
+    """
+    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.
+    
+    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`.
+    """
+
+
+@dataclass(eq=False, repr=False)
+class OneofDescriptorProto(betterproto.Message):
+    """Describes a oneof."""
+
+    name: str = betterproto.string_field(1)
+    """
+    
+    """
+
+    options: "OneofOptions" = betterproto.message_field(2)
+    """
+    
+    """
+
+
+@dataclass(eq=False, repr=False)
+class EnumDescriptorProto(betterproto.Message):
+    """Describes an enum type."""
+
+    name: str = betterproto.string_field(1)
+    """
+    
+    """
+
+    value: List["EnumValueDescriptorProto"] = betterproto.message_field(2, repeated=True)
+    """
+    
+    """
+
+    options: "EnumOptions" = betterproto.message_field(3)
+    """
+    
+    """
+
+    reserved_range: List["EnumDescriptorProtoEnumReservedRange"] = betterproto.message_field(4, repeated=True)
+    """
+    Range of reserved numeric values. Reserved numeric values may not be used
+    by enum values in the same enum declaration. Reserved ranges may not
+    overlap.
+    """
+
+    reserved_name: List[str] = betterproto.string_field(5, repeated=True)
+    """
+    Reserved enum value names, which may not be reused. A given name may only
+    be reserved once.
+    """
+
+
+@dataclass(eq=False, repr=False)
+class EnumDescriptorProtoEnumReservedRange(betterproto.Message):
+    """
+    Range of reserved numeric values. Reserved values may not be used by
+    entries in the same enum. Reserved ranges may not overlap.
+
+    Note that this is distinct from DescriptorProto.ReservedRange in that it
+    is inclusive such that it can appropriately represent the entire int32
+    domain.
+    """
+
+    start: int = betterproto.int32_field(1)
+    """Inclusive."""
+
+    end: int = betterproto.int32_field(2)
+    """Inclusive."""
+
+
+@dataclass(eq=False, repr=False)
+class EnumValueDescriptorProto(betterproto.Message):
+    """Describes a value within an enum."""
+
+    name: str = betterproto.string_field(1)
+    """
+    
+    """
+
+    number: int = betterproto.int32_field(2)
+    """
+    
+    """
+
+    options: "EnumValueOptions" = betterproto.message_field(3)
+    """
+    
+    """
+
+
+@dataclass(eq=False, repr=False)
+class ServiceDescriptorProto(betterproto.Message):
+    """Describes a service."""
+
+    name: str = betterproto.string_field(1)
+    """
+    
+    """
+
+    method: List["MethodDescriptorProto"] = betterproto.message_field(2, repeated=True)
+    """
+    
+    """
+
+    options: "ServiceOptions" = betterproto.message_field(3)
+    """
+    
+    """
+
+
+@dataclass(eq=False, repr=False)
+class MethodDescriptorProto(betterproto.Message):
+    """Describes a method of a service."""
+
+    name: str = betterproto.string_field(1)
+    """
+    
+    """
+
+    input_type: str = betterproto.string_field(2)
+    """
+    Input and output type names.  These are resolved in the same way as
+    FieldDescriptorProto.type_name, but must refer to a message type.
+    """
+
+    output_type: str = betterproto.string_field(3)
+    """
+    
+    """
+
+    options: "MethodOptions" = betterproto.message_field(4)
+    """
+    
+    """
+
+    client_streaming: bool = betterproto.bool_field(5)
+    """Identifies if client streams multiple client messages"""
+
+    server_streaming: bool = betterproto.bool_field(6)
+    """Identifies if server streams multiple server messages"""
+
+
+@dataclass(eq=False, repr=False)
+class FileOptions(betterproto.Message):
+    """
+    ===================================================================
+    Options
+
+    Each of the definitions above may have "options" attached.  These are
+    just annotations which may cause code to be generated slightly differently
+    or may contain hints for code that manipulates protocol messages.
+
+    Clients may define custom options as extensions of the *Options messages.
+    These extensions may not yet be known at parsing time, so the parser cannot
+    store the values in them.  Instead it stores them in a field in the *Options
+    message called uninterpreted_option. This field must have the same name
+    across all *Options messages. We then use this field to populate the
+    extensions when we build a descriptor, at which point all protos have been
+    parsed and so all extensions are known.
+
+    Extension numbers for custom options may be chosen as follows:
+    * For options which will only be used within a single application or
+      organization, or for experimental options, use field numbers 50000
+      through 99999.  It is up to you to ensure that you do not use the
+      same number for multiple options.
+    * For options which will be published and used publicly by multiple
+      independent entities, e-mail protobuf-global-extension-registry@google.com
+      to reserve extension numbers. Simply provide your project name (e.g.
+      Objective-C plugin) and your project website (if available) -- there's no
+      need to explain how you intend to use them. Usually you only need one
+      extension number. You can declare multiple options with only one extension
+      number by putting them in a sub-message. See the Custom Options section of
+      the docs for examples:
+      https://developers.google.com/protocol-buffers/docs/proto#options
+      If this turns out to be popular, a web service will be set up
+      to automatically assign option numbers.
+    """
+
+    java_package: str = betterproto.string_field(1)
+    """
+    Sets the Java package where classes generated from this .proto will be
+    placed.  By default, the proto package is used, but this is often
+    inappropriate because proto packages do not normally start with backwards
+    domain names.
+    """
+
+    java_outer_classname: str = betterproto.string_field(8)
+    """
+    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).
+    """
+
+    java_multiple_files: bool = betterproto.bool_field(10)
+    """
+    If set true, 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
+    generated to contain the file's getDescriptor() method as well as any
+    top-level extensions defined in the file.
+    """
+
+    java_generate_equals_and_hash: bool = betterproto.bool_field(20)
+    """This option does nothing."""
+
+    java_string_check_utf8: bool = betterproto.bool_field(27)
+    """
+    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.
+    """
+
+    optimize_for: "FileOptionsOptimizeMode" = betterproto.enum_field(
+        9, enum_default_value=lambda: FileOptionsOptimizeMode.try_value(0)
+    )
+    """
+    
+    """
+
+    go_package: str = betterproto.string_field(11)
+    """
+    Sets the Go package where structs generated from this .proto will be
+    placed. If omitted, the Go package will be derived from the following:
+      - The basename of the package import path, if provided.
+      - Otherwise, the package statement in the .proto file, if present.
+      - Otherwise, the basename of the .proto file, without extension.
+    """
+
+    cc_generic_services: bool = betterproto.bool_field(16)
+    """
+    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).
+    Generic services were the only kind of service generation supported by
+    early versions of google.protobuf.
+    
+    Generic services are now considered deprecated in favor of using plugins
+    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.
+    """
+
+    java_generic_services: bool = betterproto.bool_field(17)
+    """
+    
+    """
+
+    py_generic_services: bool = betterproto.bool_field(18)
+    """
+    
+    """
+
+    php_generic_services: bool = betterproto.bool_field(42)
+    """
+    
+    """
+
+    deprecated: bool = betterproto.bool_field(23)
+    """
+    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.
+    """
+
+    cc_enable_arenas: bool = betterproto.bool_field(31)
+    """
+    Enables the use of arenas for the proto messages in this file. This applies
+    only to generated classes for C++.
+    """
+
+    objc_class_prefix: str = betterproto.string_field(36)
+    """
+    Sets the objective c class prefix which is prepended to all objective c
+    generated classes from this .proto. There is no default.
+    """
+
+    csharp_namespace: str = betterproto.string_field(37)
+    """Namespace for generated classes; defaults to the package."""
+
+    swift_prefix: str = betterproto.string_field(39)
+    """
+    By default Swift generators will take the proto package and CamelCase it
+    replacing '.' with underscore and use that to prefix the types/symbols
+    defined. When this options is provided, they will use this value instead
+    to prefix the types/symbols defined.
+    """
+
+    php_class_prefix: str = betterproto.string_field(40)
+    """
+    Sets the php class prefix which is prepended to all php generated classes
+    from this .proto. Default is empty.
+    """
+
+    php_namespace: str = betterproto.string_field(41)
+    """
+    Use this option to change the namespace of php generated classes. Default
+    is empty. When this option is empty, the package name will be used for
+    determining the namespace.
+    """
+
+    php_metadata_namespace: str = betterproto.string_field(44)
+    """
+    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.
+    """
+
+    ruby_package: str = betterproto.string_field(45)
+    """
+    Use this option to change the package of ruby generated classes. Default
+    is empty. When this option is not set, the package name will be used for
+    determining the ruby package.
+    """
+
+    uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999, repeated=True)
+    """
+    The parser stores options it doesn't recognize here.
+    See the documentation for the "Options" section above.
+    """
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        if self.is_set("java_generate_equals_and_hash"):
+            warnings.warn(
+                "FileOptions.java_generate_equals_and_hash is deprecated",
+                DeprecationWarning,
+            )
+
+
+@dataclass(eq=False, repr=False)
+class MessageOptions(betterproto.Message):
+    """ """
+
+    message_set_wire_format: bool = betterproto.bool_field(1)
+    """
+    Set true to use the old proto1 MessageSet wire format for extensions.
+    This is provided for backwards-compatibility with the MessageSet wire
+    format.  You should not use this for any other reason:  It's less
+    efficient, has fewer features, and is more complicated.
+    
+    The message must be defined exactly as follows:
+      message Foo {
+        option message_set_wire_format = true;
+        extensions 4 to max;
+      }
+    Note that the message cannot have any defined fields; MessageSets only
+    have extensions.
+    
+    All extensions of your type must be singular messages; e.g. they cannot
+    be int32s, enums, or repeated messages.
+    
+    Because this is an option, the above two restrictions are not enforced by
+    the protocol compiler.
+    """
+
+    no_standard_descriptor_accessor: bool = betterproto.bool_field(2)
+    """
+    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".
+    """
+
+    deprecated: bool = betterproto.bool_field(3)
+    """
+    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.
+    """
+
+    map_entry: bool = betterproto.bool_field(7)
+    """
+    Whether the message is an automatically generated map entry type for the
+    maps field.
+    
+    For maps fields:
+        map<KeyType, ValueType> map_field = 1;
+    The parsed descriptor looks like:
+        message MapFieldEntry {
+            option map_entry = true;
+            optional KeyType key = 1;
+            optional ValueType value = 2;
+        }
+        repeated MapFieldEntry map_field = 1;
+    
+    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 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
+    instead. The option should only be implicitly set by the proto compiler
+    parser.
+    """
+
+    uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999, repeated=True)
+    """The parser stores options it doesn't recognize here. See above."""
+
+
+@dataclass(eq=False, repr=False)
+class FieldOptions(betterproto.Message):
+    """ """
+
+    ctype: "FieldOptionsCType" = betterproto.enum_field(1, enum_default_value=lambda: FieldOptionsCType.try_value(0))
+    """
+    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!
+    """
+
+    packed: bool = betterproto.bool_field(2)
+    """
+    The packed option can be enabled for repeated primitive fields to enable
+    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.
+    """
+
+    jstype: "FieldOptionsJsType" = betterproto.enum_field(6, enum_default_value=lambda: FieldOptionsJsType.try_value(0))
+    """
+    The jstype option determines the JavaScript type used for values of the
+    field.  The option is permitted only for 64 bit integral and fixed types
+    (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
+    is represented as JavaScript string, which avoids loss of precision that
+    can happen when a large value is converted to a floating point JavaScript.
+    Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
+    use the JavaScript "number" type.  The behavior of the default option
+    JS_NORMAL is implementation dependent.
+    
+    This option is an enum to permit additional types to be added, e.g.
+    goog.math.Integer.
+    """
+
+    lazy: bool = betterproto.bool_field(5)
+    """
+    Should this field be parsed lazily?  Lazy applies only to message-type
+    fields.  It means that when the outer message is initially parsed, the
+    inner message's contents will not be parsed but instead stored in encoded
+    form.  The inner message will actually be parsed when it is first accessed.
+    
+    This is only a hint.  Implementations are free to choose whether to use
+    eager or lazy parsing regardless of the value of this option.  However,
+    setting this option true suggests that the protocol author believes that
+    using lazy parsing on this field is worth the additional bookkeeping
+    overhead typically needed to implement it.
+    
+    This option does not affect the public interface of any generated code;
+    all method signatures remain the same.  Furthermore, thread-safety of the
+    interface is not affected by this option; const methods remain safe to
+    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.
+    """
+
+    deprecated: bool = betterproto.bool_field(3)
+    """
+    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.
+    """
+
+    weak: bool = betterproto.bool_field(10)
+    """For Google-internal migration only. Do not use."""
+
+    uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999, repeated=True)
+    """The parser stores options it doesn't recognize here. See above."""
+
+
+@dataclass(eq=False, repr=False)
+class OneofOptions(betterproto.Message):
+    """ """
+
+    uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999, repeated=True)
+    """The parser stores options it doesn't recognize here. See above."""
+
+
+@dataclass(eq=False, repr=False)
+class EnumOptions(betterproto.Message):
+    """ """
+
+    allow_alias: bool = betterproto.bool_field(2)
+    """
+    Set this option to true to allow mapping different tag names to the same
+    value.
+    """
+
+    deprecated: bool = betterproto.bool_field(3)
+    """
+    Is this enum deprecated?
+    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.
+    """
+
+    uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999, repeated=True)
+    """The parser stores options it doesn't recognize here. See above."""
+
+
+@dataclass(eq=False, repr=False)
+class EnumValueOptions(betterproto.Message):
+    """ """
+
+    deprecated: bool = betterproto.bool_field(1)
+    """
+    Is this enum value deprecated?
+    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.
+    """
+
+    uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999, repeated=True)
+    """The parser stores options it doesn't recognize here. See above."""
+
+
+@dataclass(eq=False, repr=False)
+class ServiceOptions(betterproto.Message):
+    """ """
+
+    deprecated: bool = betterproto.bool_field(33)
+    """
+    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
+      Buffers.
+    
+    Is this service deprecated?
+    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.
+    """
+
+    uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999, repeated=True)
+    """The parser stores options it doesn't recognize here. See above."""
+
+
+@dataclass(eq=False, repr=False)
+class MethodOptions(betterproto.Message):
+    """ """
+
+    deprecated: bool = betterproto.bool_field(33)
+    """
+    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
+      Buffers.
+    
+    Is this method deprecated?
+    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.
+    """
+
+    idempotency_level: "MethodOptionsIdempotencyLevel" = betterproto.enum_field(
+        34, enum_default_value=lambda: MethodOptionsIdempotencyLevel.try_value(0)
+    )
+    """
+    
+    """
+
+    uninterpreted_option: List["UninterpretedOption"] = betterproto.message_field(999, repeated=True)
+    """The parser stores options it doesn't recognize here. See above."""
+
+
+@dataclass(eq=False, repr=False)
+class UninterpretedOption(betterproto.Message):
+    """
+    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,
+    options protos in descriptor objects (e.g. returned by Descriptor::options(),
+    or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
+    in them.
+    """
+
+    name: List["UninterpretedOptionNamePart"] = betterproto.message_field(2, repeated=True)
+    """
+    
+    """
+
+    identifier_value: str = betterproto.string_field(3)
+    """
+    The value of the uninterpreted option, in whatever type the tokenizer
+    identified it as during parsing. Exactly one of these should be set.
+    """
+
+    positive_int_value: int = betterproto.uint64_field(4)
+    """
+    
+    """
+
+    negative_int_value: int = betterproto.int64_field(5)
+    """
+    
+    """
+
+    double_value: float = betterproto.double_field(6)
+    """
+    
+    """
+
+    string_value: bytes = betterproto.bytes_field(7)
+    """
+    
+    """
+
+    aggregate_value: str = betterproto.string_field(8)
+    """
+    
+    """
+
+
+@dataclass(eq=False, repr=False)
+class UninterpretedOptionNamePart(betterproto.Message):
+    """
+    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".
+    """
+
+    name_part: str = betterproto.string_field(1)
+    """
+    
+    """
+
+    is_extension: bool = betterproto.bool_field(2)
+    """
+    
+    """
+
+
+@dataclass(eq=False, repr=False)
+class SourceCodeInfo(betterproto.Message):
+    """
+    ===================================================================
+    Optional source code info
+
+    Encapsulates information about the original source file from which a
+    FileDescriptorProto was generated.
+    """
+
+    location: List["SourceCodeInfoLocation"] = betterproto.message_field(1, repeated=True)
+    """
+    A Location identifies a piece of source code in a .proto file which
+    corresponds to a particular definition.  This information is intended
+    to be useful to IDEs, code indexers, documentation generators, and similar
+    tools.
+    
+    For example, say we have a file like:
+      message Foo {
+        optional string foo = 1;
+      }
+    Let's look at just the field definition:
+      optional string foo = 1;
+      ^       ^^     ^^  ^  ^^^
+      a       bc     de  f  ghi
+    We have the following locations:
+      span   path               represents
+      [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
+      [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
+      [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
+      [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
+      [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
+    
+    Notes:
+    - A location may refer to a repeated field itself (i.e. not to any
+      particular index within it).  This is used whenever a set of elements are
+      logically enclosed in a single code segment.  For example, an entire
+      extend block (possibly containing multiple extension definitions) will
+      have an outer location whose path refers to the "extensions" repeated
+      field without an index.
+    - Multiple locations may have the same path.  This happens when a single
+      logical declaration is spread out across multiple places.  The most
+      obvious example is the "extend" block again -- there may be multiple
+      extend blocks in the same scope, each of which will have the same path.
+    - A location's span is not always a subset of its parent's span.  For
+      example, the "extendee" of an extension declaration appears at the
+      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 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
+      ignore those that it doesn't understand, as more types of locations could
+      be recorded in the future.
+    """
+
+
+@dataclass(eq=False, repr=False)
+class SourceCodeInfoLocation(betterproto.Message):
+    """ """
+
+    path: List[int] = betterproto.int32_field(1, repeated=True)
+    """
+    Identifies which part of the FileDescriptorProto was defined at this
+    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:
+      [ 4, 3, 2, 7, 1 ]
+    refers to:
+      file.message_type(3)  // 4, 3
+          .field(7)         // 2, 7
+          .name()           // 1
+    This is because FileDescriptorProto.message_type has field number 4:
+      repeated DescriptorProto message_type = 4;
+    and DescriptorProto.field has field number 2:
+      repeated FieldDescriptorProto field = 2;
+    and FieldDescriptorProto.name has field number 1:
+      optional string name = 1;
+    
+    Thus, the above path gives the location of a field name.  If we removed
+    the last element:
+      [ 4, 3, 2, 7 ]
+    this path refers to the whole field declaration (from the beginning
+    of the label to the terminating semicolon).
+    """
+
+    span: List[int] = betterproto.int32_field(2, repeated=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.
+    """
+
+    leading_comments: str = betterproto.string_field(3)
+    """
+    If this SourceCodeInfo represents a complete declaration, these are any
+    comments appearing before and after the declaration which appear to be
+    attached to the declaration.
+    
+    A series of line comments appearing on consecutive lines, with no other
+    tokens appearing on those lines, will be treated as a single comment.
+    
+    leading_detached_comments will keep paragraphs of comments that appear
+    before (but not connected to) the current element. Each paragraph,
+    separated by empty lines, will be one comment element in the repeated
+    field.
+    
+    Only the comment content is provided; comment markers (e.g. //) are
+    stripped out.  For block comments, leading whitespace and an asterisk
+    will be stripped from the beginning of each line other than the first.
+    Newlines are included in the output.
+    
+    Examples:
+    
+      optional int32 foo = 1;  // Comment attached to foo.
+      // Comment attached to bar.
+      optional int32 bar = 2;
+    
+      optional string baz = 3;
+      // Comment attached to baz.
+      // Another line attached to baz.
+    
+      // Comment attached to qux.
+      //
+      // Another line attached to qux.
+      optional double qux = 4;
+    
+      // Detached comment for corge. This is not leading or trailing comments
+      // to qux or corge because there are blank lines separating it from
+      // both.
+    
+      // Detached comment for corge paragraph 2.
+    
+      optional string corge = 5;
+      /* Block comment attached
+       * to corge.  Leading asterisks
+       * will be removed. */
+      /* Block comment attached to
+       * grault. */
+      optional int32 grault = 6;
+    
+      // ignored detached comments.
+    """
+
+    trailing_comments: str = betterproto.string_field(4)
+    """
+    
+    """
+
+    leading_detached_comments: List[str] = betterproto.string_field(6, repeated=True)
+    """
+    
+    """
+
+
+@dataclass(eq=False, repr=False)
+class GeneratedCodeInfo(betterproto.Message):
+    """
+    Describes the relationship between generated code and its original source
+    file. A GeneratedCodeInfo message is associated with only one generated
+    source file, but may contain references to different source .proto files.
+    """
+
+    annotation: List["GeneratedCodeInfoAnnotation"] = betterproto.message_field(1, repeated=True)
+    """
+    An Annotation connects some span of text in generated code to an element
+    of its generating .proto file.
+    """
+
+
+@dataclass(eq=False, repr=False)
+class GeneratedCodeInfoAnnotation(betterproto.Message):
+    """ """
+
+    path: List[int] = betterproto.int32_field(1, repeated=True)
+    """
+    Identifies the element in the original source .proto file. This field
+    is formatted the same as SourceCodeInfo.Location.path.
+    """
+
+    source_file: str = betterproto.string_field(2)
+    """Identifies the filesystem path to the original source .proto."""
+
+    begin: int = betterproto.int32_field(3)
+    """
+    Identifies the starting offset in bytes in the generated code
+    that relates to the identified object.
+    """
+
+    end: int = betterproto.int32_field(4)
+    """
+    Identifies the ending offset in bytes in the generated code that
+    relates to the identified offset. The end offset should be one past
+    the last relevant byte (so the length of the text = end - begin).
+    """
+
+
+@dataclass(eq=False, repr=False)
+class Duration(betterproto.Message):
+    """
+    A Duration represents a signed, fixed-length span of time represented
+    as a count of seconds and fractions of seconds at nanosecond
+    resolution. It is independent of any calendar and concepts like "day"
+    or "month". It is related to Timestamp in that the difference between
+    two Timestamp values is a Duration and it can be added or subtracted
+    from a Timestamp. Range is approximately +-10,000 years.
+
+    # Examples
+
+    Example 1: Compute Duration from two Timestamps in pseudo code.
+
+        Timestamp start = ...;
+        Timestamp end = ...;
+        Duration duration = ...;
+
+        duration.seconds = end.seconds - start.seconds;
+        duration.nanos = end.nanos - start.nanos;
+
+        if (duration.seconds < 0 && duration.nanos > 0) {
+          duration.seconds += 1;
+          duration.nanos -= 1000000000;
+        } else if (duration.seconds > 0 && duration.nanos < 0) {
+          duration.seconds -= 1;
+          duration.nanos += 1000000000;
+        }
+
+    Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+
+        Timestamp start = ...;
+        Duration duration = ...;
+        Timestamp end = ...;
+
+        end.seconds = start.seconds + duration.seconds;
+        end.nanos = start.nanos + duration.nanos;
+
+        if (end.nanos < 0) {
+          end.seconds -= 1;
+          end.nanos += 1000000000;
+        } else if (end.nanos >= 1000000000) {
+          end.seconds += 1;
+          end.nanos -= 1000000000;
+        }
+
+    Example 3: Compute Duration from datetime.timedelta in Python.
+
+        td = datetime.timedelta(days=3, minutes=10)
+        duration = Duration()
+        duration.FromTimedelta(td)
+
+    # JSON Mapping
+
+    In JSON format, the Duration type is encoded as a string rather than an
+    object, where the string ends in the suffix "s" (indicating seconds) and
+    is preceded by the number of seconds, with nanoseconds expressed as
+    fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+    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".
+    """
+
+    seconds: int = betterproto.int64_field(1)
+    """
+    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
+    """
+
+    nanos: int = betterproto.int32_field(2)
+    """
+    Signed fractions of a second at nanosecond resolution of the span
+    of time. Durations less than one second are represented with a 0
+    `seconds` field and a positive or negative `nanos` field. For durations
+    of one second or more, a non-zero value for the `nanos` field must be
+    of the same sign as the `seconds` field. Must be from -999,999,999
+    to +999,999,999 inclusive.
+    """
+
+
+@dataclass(eq=False, repr=False)
+class Empty(betterproto.Message):
+    """
+    A generic empty message that you can re-use to avoid defining duplicated
+    empty messages in your APIs. A typical example is to use it as the request
+    or the response type of an API method. For instance:
+
+        service Foo {
+          rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+        }
+
+    The JSON representation for `Empty` is empty JSON object `{}`.
+    """
+
+    pass
+
+
+@dataclass(eq=False, repr=False)
+class FieldMask(betterproto.Message):
+    """
+    `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.
+    """
+
+    paths: List[str] = betterproto.string_field(1, repeated=True)
+    """The set of field mask paths."""
+
+
+@dataclass(eq=False, repr=False)
+class Struct(betterproto.Message):
+    """
+    `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.
+    """
+
+    fields: Dict[str, "Value"] = betterproto.map_field(1, betterproto.TYPE_STRING, betterproto.TYPE_MESSAGE)
+    """Unordered map of dynamically typed values."""
+
+    @hybridmethod
+    def from_dict(cls: "type[Self]", value: Mapping[str, Any]) -> Self:  # type: ignore
+        self = cls()
+        return self.from_dict(value)
+
+    @from_dict.instancemethod
+    def from_dict(self, value: Mapping[str, Any]) -> Self:
+        fields = {**value}
+        for k in fields:
+            if hasattr(fields[k], "from_dict"):
+                fields[k] = fields[k].from_dict()
+
+        self.fields = fields
+        return self
+
+    def to_dict(
+        self,
+        casing: betterproto.Casing = betterproto.Casing.CAMEL,
+        include_default_values: bool = False,
+    ) -> Dict[str, Any]:
+        output = {**self.fields}
+        for k in self.fields:
+            if hasattr(self.fields[k], "to_dict"):
+                output[k] = self.fields[k].to_dict(casing, include_default_values)
+        return output
+
+
+@dataclass(eq=False, repr=False)
+class Value(betterproto.Message):
+    """
+    `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.
+
+    The JSON representation for `Value` is JSON value.
+    """
+
+    null_value: "NullValue" = betterproto.enum_field(1, enum_default_value=lambda: NullValue.try_value(0), group="kind")
+    """Represents a null value."""
+
+    number_value: float = betterproto.double_field(2, group="kind")
+    """Represents a double value."""
+
+    string_value: str = betterproto.string_field(3, group="kind")
+    """Represents a string value."""
+
+    bool_value: bool = betterproto.bool_field(4, group="kind")
+    """Represents a boolean value."""
+
+    struct_value: "Struct" = betterproto.message_field(5, group="kind")
+    """Represents a structured value."""
+
+    list_value: "ListValue" = betterproto.message_field(6, group="kind")
+    """Represents a repeated `Value`."""
+
+
+@dataclass(eq=False, repr=False)
+class ListValue(betterproto.Message):
+    """
+    `ListValue` is a wrapper around a repeated field of values.
+
+    The JSON representation for `ListValue` is JSON array.
+    """
+
+    values: List["Value"] = betterproto.message_field(1, repeated=True)
+    """Repeated field of dynamically typed values."""
+
+
+@dataclass(eq=False, repr=False)
+class Timestamp(betterproto.Message):
+    """
+    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()`.
+
+        Timestamp timestamp;
+        timestamp.set_seconds(time(NULL));
+        timestamp.set_nanos(0);
+
+    Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+
+        struct timeval tv;
+        gettimeofday(&tv, NULL);
+
+        Timestamp timestamp;
+        timestamp.set_seconds(tv.tv_sec);
+        timestamp.set_nanos(tv.tv_usec * 1000);
+
+    Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+
+        FILETIME ft;
+        GetSystemTimeAsFileTime(&ft);
+        UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+
+        // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+        // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+        Timestamp timestamp;
+        timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+        timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+
+    Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+
+        long millis = System.currentTimeMillis();
+
+        Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+            .setNanos((int) ((millis % 1000) * 1000000)).build();
+
+    Example 5: Compute Timestamp from current time in Python.
+
+        timestamp = Timestamp()
+        timestamp.GetCurrentTime()
+
+    # JSON Mapping
+
+    In JSON format, the Timestamp type is encoded as a string in the
+    [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+    format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+    where {year} is always expressed using four digits while {month}, {day},
+    {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+    seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+    are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+    is required. A proto3 JSON serializer should always use UTC (as indicated by
+    "Z") when printing the Timestamp type and a proto3 JSON parser should be
+    able to accept both UTC and other timezones (as indicated by an offset).
+
+    For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+    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)
+    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%2D%2D
+    ) to obtain a formatter capable of generating timestamps in this format.
+    """
+
+    seconds: int = betterproto.int64_field(1)
+    """
+    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.
+    """
+
+    nanos: int = betterproto.int32_field(2)
+    """
+    Non-negative fractions of a second at nanosecond resolution. Negative
+    second values with fractions must still have non-negative nanos values
+    that count forward in time. Must be from 0 to 999,999,999
+    inclusive.
+    """
+
+
+@dataclass(eq=False, repr=False)
+class DoubleValue(betterproto.Message):
+    """
+    Wrapper message for `double`.
+
+    The JSON representation for `DoubleValue` is JSON number.
+    """
+
+    value: float = betterproto.double_field(1)
+    """The double value."""
+
+
+@dataclass(eq=False, repr=False)
+class FloatValue(betterproto.Message):
+    """
+    Wrapper message for `float`.
+
+    The JSON representation for `FloatValue` is JSON number.
+    """
+
+    value: float = betterproto.float_field(1)
+    """The float value."""
+
+
+@dataclass(eq=False, repr=False)
+class Int64Value(betterproto.Message):
+    """
+    Wrapper message for `int64`.
+
+    The JSON representation for `Int64Value` is JSON string.
+    """
+
+    value: int = betterproto.int64_field(1)
+    """The int64 value."""
+
+
+@dataclass(eq=False, repr=False)
+class UInt64Value(betterproto.Message):
+    """
+    Wrapper message for `uint64`.
+
+    The JSON representation for `UInt64Value` is JSON string.
+    """
+
+    value: int = betterproto.uint64_field(1)
+    """The uint64 value."""
+
+
+@dataclass(eq=False, repr=False)
+class Int32Value(betterproto.Message):
+    """
+    Wrapper message for `int32`.
+
+    The JSON representation for `Int32Value` is JSON number.
+    """
+
+    value: int = betterproto.int32_field(1)
+    """The int32 value."""
+
+
+@dataclass(eq=False, repr=False)
+class UInt32Value(betterproto.Message):
+    """
+    Wrapper message for `uint32`.
+
+    The JSON representation for `UInt32Value` is JSON number.
+    """
+
+    value: int = betterproto.uint32_field(1)
+    """The uint32 value."""
+
+
+@dataclass(eq=False, repr=False)
+class BoolValue(betterproto.Message):
+    """
+    Wrapper message for `bool`.
+
+    The JSON representation for `BoolValue` is JSON `true` and `false`.
+    """
+
+    value: bool = betterproto.bool_field(1)
+    """The bool value."""
+
+
+@dataclass(eq=False, repr=False)
+class StringValue(betterproto.Message):
+    """
+    Wrapper message for `string`.
+
+    The JSON representation for `StringValue` is JSON string.
+    """
+
+    value: str = betterproto.string_field(1)
+    """The string value."""
+
+
+@dataclass(eq=False, repr=False)
+class BytesValue(betterproto.Message):
+    """
+    Wrapper message for `bytes`.
+
+    The JSON representation for `BytesValue` is JSON string.
+    """
+
+    value: bytes = betterproto.bytes_field(1)
+    """The bytes value."""