Add generated stubs for google.protobuf, from its protobufs (#2095)

This fleshes out the auto-generated pieces of `google.protobuf`, by
using the go version of https://github.com/dropbox/mypy-protobuf to
generate mypy stubs from the .proto files in
https://github.com/google/protobuf/tree/master/src/google/protobuf

Generated from current `master` of google/protobuf, 25625b956a.

Ref google/protobuf#3803, python/typeshed#1705

third_party/2/google/protobuf/any_pb2.pyi

@@ -0,0 +1,20 @@
+from google.protobuf.message import (
+    Message,
+)
+from typing import (
+    Optional,
+    Text,
+)
+
+
+class Any(Message):
+    type_url = ...  # type: Text
+    value = ...  # type: str
+
+    def __init__(self,
+                 type_url: Optional[Text] = ...,
+                 value: Optional[str] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> Any: ...

third_party/2/google/protobuf/any_test_pb2.pyi

@@ -0,0 +1,32 @@
+from google.protobuf.any_pb2 import (
+    Any,
+)
+from google.protobuf.internal.containers import (
+    RepeatedCompositeFieldContainer,
+)
+from google.protobuf.message import (
+    Message,
+)
+from typing import (
+    Iterable,
+    Optional,
+)
+
+
+class TestAny(Message):
+    int32_value = ...  # type: int
+
+    @property
+    def any_value(self) -> Any: ...
+
+    @property
+    def repeated_any_value(self) -> RepeatedCompositeFieldContainer[Any]: ...
+
+    def __init__(self,
+                 int32_value: Optional[int] = ...,
+                 any_value: Optional[Any] = ...,
+                 repeated_any_value: Optional[Iterable[Any]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestAny: ...

third_party/2/google/protobuf/api_pb2.pyi

@@ -0,0 +1,87 @@
+from google.protobuf.internal.containers import (
+    RepeatedCompositeFieldContainer,
+)
+from google.protobuf.message import (
+    Message,
+)
+from google.protobuf.source_context_pb2 import (
+    SourceContext,
+)
+from google.protobuf.type_pb2 import (
+    Option,
+    Syntax,
+)
+from typing import (
+    Iterable,
+    Optional,
+    Text,
+)
+
+
+class Api(Message):
+    name = ...  # type: Text
+    version = ...  # type: Text
+    syntax = ...  # type: Syntax
+
+    @property
+    def methods(self) -> RepeatedCompositeFieldContainer[Method]: ...
+
+    @property
+    def options(self) -> RepeatedCompositeFieldContainer[Option]: ...
+
+    @property
+    def source_context(self) -> SourceContext: ...
+
+    @property
+    def mixins(self) -> RepeatedCompositeFieldContainer[Mixin]: ...
+
+    def __init__(self,
+                 name: Optional[Text] = ...,
+                 methods: Optional[Iterable[Method]] = ...,
+                 options: Optional[Iterable[Option]] = ...,
+                 version: Optional[Text] = ...,
+                 source_context: Optional[SourceContext] = ...,
+                 mixins: Optional[Iterable[Mixin]] = ...,
+                 syntax: Optional[Syntax] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> Api: ...
+
+
+class Method(Message):
+    name = ...  # type: Text
+    request_type_url = ...  # type: Text
+    request_streaming = ...  # type: bool
+    response_type_url = ...  # type: Text
+    response_streaming = ...  # type: bool
+    syntax = ...  # type: Syntax
+
+    @property
+    def options(self) -> RepeatedCompositeFieldContainer[Option]: ...
+
+    def __init__(self,
+                 name: Optional[Text] = ...,
+                 request_type_url: Optional[Text] = ...,
+                 request_streaming: Optional[bool] = ...,
+                 response_type_url: Optional[Text] = ...,
+                 response_streaming: Optional[bool] = ...,
+                 options: Optional[Iterable[Option]] = ...,
+                 syntax: Optional[Syntax] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> Method: ...
+
+
+class Mixin(Message):
+    name = ...  # type: Text
+    root = ...  # type: Text
+
+    def __init__(self,
+                 name: Optional[Text] = ...,
+                 root: Optional[Text] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> Mixin: ...

third_party/2/google/protobuf/compiler/plugin_pb2.pyi

@@ -0,0 +1,82 @@
+from google.protobuf.descriptor_pb2 import (
+    FileDescriptorProto,
+)
+from google.protobuf.internal.containers import (
+    RepeatedCompositeFieldContainer,
+    RepeatedScalarFieldContainer,
+)
+from google.protobuf.message import (
+    Message,
+)
+from typing import (
+    Iterable,
+    Optional,
+    Text,
+)
+
+
+class Version(Message):
+    major = ...  # type: int
+    minor = ...  # type: int
+    patch = ...  # type: int
+    suffix = ...  # type: Text
+
+    def __init__(self,
+                 major: Optional[int] = ...,
+                 minor: Optional[int] = ...,
+                 patch: Optional[int] = ...,
+                 suffix: Optional[Text] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> Version: ...
+
+
+class CodeGeneratorRequest(Message):
+    file_to_generate = ...  # type: RepeatedScalarFieldContainer[Text]
+    parameter = ...  # type: Text
+
+    @property
+    def proto_file(self) -> RepeatedCompositeFieldContainer[FileDescriptorProto]: ...
+
+    @property
+    def compiler_version(self) -> Version: ...
+
+    def __init__(self,
+                 file_to_generate: Optional[Iterable[Text]] = ...,
+                 parameter: Optional[Text] = ...,
+                 proto_file: Optional[Iterable[FileDescriptorProto]] = ...,
+                 compiler_version: Optional[Version] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> CodeGeneratorRequest: ...
+
+
+class CodeGeneratorResponse(Message):
+
+    class File(Message):
+        name = ...  # type: Text
+        insertion_point = ...  # type: Text
+        content = ...  # type: Text
+
+        def __init__(self,
+                     name: Optional[Text] = ...,
+                     insertion_point: Optional[Text] = ...,
+                     content: Optional[Text] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> CodeGeneratorResponse.File: ...
+    error = ...  # type: Text
+
+    @property
+    def file(self) -> RepeatedCompositeFieldContainer[CodeGeneratorResponse.File]: ...
+
+    def __init__(self,
+                 error: Optional[Text] = ...,
+                 file: Optional[Iterable[CodeGeneratorResponse.File]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> CodeGeneratorResponse: ...

third_party/2/google/protobuf/descriptor_pb2.pyi

@@ -1,2 +1,732 @@
-class FileOptions(object): ...
-class FieldOptions(object): ...
+from google.protobuf.internal.containers import (
+    RepeatedCompositeFieldContainer,
+    RepeatedScalarFieldContainer,
+)
+from google.protobuf.message import (
+    Message,
+)
+from typing import (
+    Iterable,
+    List,
+    Optional,
+    Text,
+    Tuple,
+    cast,
+)
+
+
+class FileDescriptorSet(Message):
+
+    @property
+    def file(self) -> RepeatedCompositeFieldContainer[FileDescriptorProto]: ...
+
+    def __init__(self,
+                 file: Optional[Iterable[FileDescriptorProto]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> FileDescriptorSet: ...
+
+
+class FileDescriptorProto(Message):
+    name = ...  # type: Text
+    package = ...  # type: Text
+    dependency = ...  # type: RepeatedScalarFieldContainer[Text]
+    public_dependency = ...  # type: RepeatedScalarFieldContainer[int]
+    weak_dependency = ...  # type: RepeatedScalarFieldContainer[int]
+    syntax = ...  # type: Text
+
+    @property
+    def message_type(
+        self) -> RepeatedCompositeFieldContainer[DescriptorProto]: ...
+
+    @property
+    def enum_type(
+        self) -> RepeatedCompositeFieldContainer[EnumDescriptorProto]: ...
+
+    @property
+    def service(
+        self) -> RepeatedCompositeFieldContainer[ServiceDescriptorProto]: ...
+
+    @property
+    def extension(
+        self) -> RepeatedCompositeFieldContainer[FieldDescriptorProto]: ...
+
+    @property
+    def options(self) -> FileOptions: ...
+
+    @property
+    def source_code_info(self) -> SourceCodeInfo: ...
+
+    def __init__(self,
+                 name: Optional[Text] = ...,
+                 package: Optional[Text] = ...,
+                 dependency: Optional[Iterable[Text]] = ...,
+                 public_dependency: Optional[Iterable[int]] = ...,
+                 weak_dependency: Optional[Iterable[int]] = ...,
+                 message_type: Optional[Iterable[DescriptorProto]] = ...,
+                 enum_type: Optional[Iterable[EnumDescriptorProto]] = ...,
+                 service: Optional[Iterable[ServiceDescriptorProto]] = ...,
+                 extension: Optional[Iterable[FieldDescriptorProto]] = ...,
+                 options: Optional[FileOptions] = ...,
+                 source_code_info: Optional[SourceCodeInfo] = ...,
+                 syntax: Optional[Text] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> FileDescriptorProto: ...
+
+
+class DescriptorProto(Message):
+
+    class ExtensionRange(Message):
+        start = ...  # type: int
+        end = ...  # type: int
+
+        @property
+        def options(self) -> ExtensionRangeOptions: ...
+
+        def __init__(self,
+                     start: Optional[int] = ...,
+                     end: Optional[int] = ...,
+                     options: Optional[ExtensionRangeOptions] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> DescriptorProto.ExtensionRange: ...
+
+    class ReservedRange(Message):
+        start = ...  # type: int
+        end = ...  # type: int
+
+        def __init__(self,
+                     start: Optional[int] = ...,
+                     end: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> DescriptorProto.ReservedRange: ...
+    name = ...  # type: Text
+    reserved_name = ...  # type: RepeatedScalarFieldContainer[Text]
+
+    @property
+    def field(
+        self) -> RepeatedCompositeFieldContainer[FieldDescriptorProto]: ...
+
+    @property
+    def extension(
+        self) -> RepeatedCompositeFieldContainer[FieldDescriptorProto]: ...
+
+    @property
+    def nested_type(
+        self) -> RepeatedCompositeFieldContainer[DescriptorProto]: ...
+
+    @property
+    def enum_type(
+        self) -> RepeatedCompositeFieldContainer[EnumDescriptorProto]: ...
+
+    @property
+    def extension_range(
+        self) -> RepeatedCompositeFieldContainer[DescriptorProto.ExtensionRange]: ...
+
+    @property
+    def oneof_decl(
+        self) -> RepeatedCompositeFieldContainer[OneofDescriptorProto]: ...
+
+    @property
+    def options(self) -> MessageOptions: ...
+
+    @property
+    def reserved_range(
+        self) -> RepeatedCompositeFieldContainer[DescriptorProto.ReservedRange]: ...
+
+    def __init__(self,
+                 name: Optional[Text] = ...,
+                 field: Optional[Iterable[FieldDescriptorProto]] = ...,
+                 extension: Optional[Iterable[FieldDescriptorProto]] = ...,
+                 nested_type: Optional[Iterable[DescriptorProto]] = ...,
+                 enum_type: Optional[Iterable[EnumDescriptorProto]] = ...,
+                 extension_range: Optional[Iterable[DescriptorProto.ExtensionRange]] = ...,
+                 oneof_decl: Optional[Iterable[OneofDescriptorProto]] = ...,
+                 options: Optional[MessageOptions] = ...,
+                 reserved_range: Optional[Iterable[DescriptorProto.ReservedRange]] = ...,
+                 reserved_name: Optional[Iterable[Text]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> DescriptorProto: ...
+
+
+class ExtensionRangeOptions(Message):
+
+    @property
+    def uninterpreted_option(
+        self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...
+
+    def __init__(self,
+                 uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> ExtensionRangeOptions: ...
+
+
+class FieldDescriptorProto(Message):
+
+    class Type(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> FieldDescriptorProto.Type: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[FieldDescriptorProto.Type]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str, FieldDescriptorProto.Type]]: ...
+    TYPE_DOUBLE: Type
+    TYPE_FLOAT: Type
+    TYPE_INT64: Type
+    TYPE_UINT64: Type
+    TYPE_INT32: Type
+    TYPE_FIXED64: Type
+    TYPE_FIXED32: Type
+    TYPE_BOOL: Type
+    TYPE_STRING: Type
+    TYPE_GROUP: Type
+    TYPE_MESSAGE: Type
+    TYPE_BYTES: Type
+    TYPE_UINT32: Type
+    TYPE_ENUM: Type
+    TYPE_SFIXED32: Type
+    TYPE_SFIXED64: Type
+    TYPE_SINT32: Type
+    TYPE_SINT64: Type
+
+    class Label(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> FieldDescriptorProto.Label: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[FieldDescriptorProto.Label]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str, FieldDescriptorProto.Label]]: ...
+    LABEL_OPTIONAL: Label
+    LABEL_REQUIRED: Label
+    LABEL_REPEATED: Label
+    name = ...  # type: Text
+    number = ...  # type: int
+    label = ...  # type: FieldDescriptorProto.Label
+    type = ...  # type: FieldDescriptorProto.Type
+    type_name = ...  # type: Text
+    extendee = ...  # type: Text
+    default_value = ...  # type: Text
+    oneof_index = ...  # type: int
+    json_name = ...  # type: Text
+
+    @property
+    def options(self) -> FieldOptions: ...
+
+    def __init__(self,
+                 name: Optional[Text] = ...,
+                 number: Optional[int] = ...,
+                 label: Optional[FieldDescriptorProto.Label] = ...,
+                 type: Optional[FieldDescriptorProto.Type] = ...,
+                 type_name: Optional[Text] = ...,
+                 extendee: Optional[Text] = ...,
+                 default_value: Optional[Text] = ...,
+                 oneof_index: Optional[int] = ...,
+                 json_name: Optional[Text] = ...,
+                 options: Optional[FieldOptions] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> FieldDescriptorProto: ...
+
+
+class OneofDescriptorProto(Message):
+    name = ...  # type: Text
+
+    @property
+    def options(self) -> OneofOptions: ...
+
+    def __init__(self,
+                 name: Optional[Text] = ...,
+                 options: Optional[OneofOptions] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> OneofDescriptorProto: ...
+
+
+class EnumDescriptorProto(Message):
+
+    class EnumReservedRange(Message):
+        start = ...  # type: int
+        end = ...  # type: int
+
+        def __init__(self,
+                     start: Optional[int] = ...,
+                     end: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> EnumDescriptorProto.EnumReservedRange: ...
+    name = ...  # type: Text
+    reserved_name = ...  # type: RepeatedScalarFieldContainer[Text]
+
+    @property
+    def value(
+        self) -> RepeatedCompositeFieldContainer[EnumValueDescriptorProto]: ...
+
+    @property
+    def options(self) -> EnumOptions: ...
+
+    @property
+    def reserved_range(
+        self) -> RepeatedCompositeFieldContainer[EnumDescriptorProto.EnumReservedRange]: ...
+
+    def __init__(self,
+                 name: Optional[Text] = ...,
+                 value: Optional[Iterable[EnumValueDescriptorProto]] = ...,
+                 options: Optional[EnumOptions] = ...,
+                 reserved_range: Optional[Iterable[EnumDescriptorProto.EnumReservedRange]] = ...,
+                 reserved_name: Optional[Iterable[Text]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> EnumDescriptorProto: ...
+
+
+class EnumValueDescriptorProto(Message):
+    name = ...  # type: Text
+    number = ...  # type: int
+
+    @property
+    def options(self) -> EnumValueOptions: ...
+
+    def __init__(self,
+                 name: Optional[Text] = ...,
+                 number: Optional[int] = ...,
+                 options: Optional[EnumValueOptions] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> EnumValueDescriptorProto: ...
+
+
+class ServiceDescriptorProto(Message):
+    name = ...  # type: Text
+
+    @property
+    def method(
+        self) -> RepeatedCompositeFieldContainer[MethodDescriptorProto]: ...
+
+    @property
+    def options(self) -> ServiceOptions: ...
+
+    def __init__(self,
+                 name: Optional[Text] = ...,
+                 method: Optional[Iterable[MethodDescriptorProto]] = ...,
+                 options: Optional[ServiceOptions] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> ServiceDescriptorProto: ...
+
+
+class MethodDescriptorProto(Message):
+    name = ...  # type: Text
+    input_type = ...  # type: Text
+    output_type = ...  # type: Text
+    client_streaming = ...  # type: bool
+    server_streaming = ...  # type: bool
+
+    @property
+    def options(self) -> MethodOptions: ...
+
+    def __init__(self,
+                 name: Optional[Text] = ...,
+                 input_type: Optional[Text] = ...,
+                 output_type: Optional[Text] = ...,
+                 options: Optional[MethodOptions] = ...,
+                 client_streaming: Optional[bool] = ...,
+                 server_streaming: Optional[bool] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> MethodDescriptorProto: ...
+
+
+class FileOptions(Message):
+
+    class OptimizeMode(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> FileOptions.OptimizeMode: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[FileOptions.OptimizeMode]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str, FileOptions.OptimizeMode]]: ...
+    SPEED: OptimizeMode
+    CODE_SIZE: OptimizeMode
+    LITE_RUNTIME: OptimizeMode
+    java_package = ...  # type: Text
+    java_outer_classname = ...  # type: Text
+    java_multiple_files = ...  # type: bool
+    java_generate_equals_and_hash = ...  # type: bool
+    java_string_check_utf8 = ...  # type: bool
+    optimize_for = ...  # type: FileOptions.OptimizeMode
+    go_package = ...  # type: Text
+    cc_generic_services = ...  # type: bool
+    java_generic_services = ...  # type: bool
+    py_generic_services = ...  # type: bool
+    php_generic_services = ...  # type: bool
+    deprecated = ...  # type: bool
+    cc_enable_arenas = ...  # type: bool
+    objc_class_prefix = ...  # type: Text
+    csharp_namespace = ...  # type: Text
+    swift_prefix = ...  # type: Text
+    php_class_prefix = ...  # type: Text
+    php_namespace = ...  # type: Text
+
+    @property
+    def uninterpreted_option(
+        self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...
+
+    def __init__(self,
+                 java_package: Optional[Text] = ...,
+                 java_outer_classname: Optional[Text] = ...,
+                 java_multiple_files: Optional[bool] = ...,
+                 java_generate_equals_and_hash: Optional[bool] = ...,
+                 java_string_check_utf8: Optional[bool] = ...,
+                 optimize_for: Optional[FileOptions.OptimizeMode] = ...,
+                 go_package: Optional[Text] = ...,
+                 cc_generic_services: Optional[bool] = ...,
+                 java_generic_services: Optional[bool] = ...,
+                 py_generic_services: Optional[bool] = ...,
+                 php_generic_services: Optional[bool] = ...,
+                 deprecated: Optional[bool] = ...,
+                 cc_enable_arenas: Optional[bool] = ...,
+                 objc_class_prefix: Optional[Text] = ...,
+                 csharp_namespace: Optional[Text] = ...,
+                 swift_prefix: Optional[Text] = ...,
+                 php_class_prefix: Optional[Text] = ...,
+                 php_namespace: Optional[Text] = ...,
+                 uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> FileOptions: ...
+
+
+class MessageOptions(Message):
+    message_set_wire_format = ...  # type: bool
+    no_standard_descriptor_accessor = ...  # type: bool
+    deprecated = ...  # type: bool
+    map_entry = ...  # type: bool
+
+    @property
+    def uninterpreted_option(
+        self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...
+
+    def __init__(self,
+                 message_set_wire_format: Optional[bool] = ...,
+                 no_standard_descriptor_accessor: Optional[bool] = ...,
+                 deprecated: Optional[bool] = ...,
+                 map_entry: Optional[bool] = ...,
+                 uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> MessageOptions: ...
+
+
+class FieldOptions(Message):
+
+    class CType(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> FieldOptions.CType: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[FieldOptions.CType]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str, FieldOptions.CType]]: ...
+    STRING: CType
+    CORD: CType
+    STRING_PIECE: CType
+
+    class JSType(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> FieldOptions.JSType: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[FieldOptions.JSType]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str, FieldOptions.JSType]]: ...
+    JS_NORMAL: JSType
+    JS_STRING: JSType
+    JS_NUMBER: JSType
+    ctype = ...  # type: FieldOptions.CType
+    packed = ...  # type: bool
+    jstype = ...  # type: FieldOptions.JSType
+    lazy = ...  # type: bool
+    deprecated = ...  # type: bool
+    weak = ...  # type: bool
+
+    @property
+    def uninterpreted_option(
+        self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...
+
+    def __init__(self,
+                 ctype: Optional[FieldOptions.CType] = ...,
+                 packed: Optional[bool] = ...,
+                 jstype: Optional[FieldOptions.JSType] = ...,
+                 lazy: Optional[bool] = ...,
+                 deprecated: Optional[bool] = ...,
+                 weak: Optional[bool] = ...,
+                 uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> FieldOptions: ...
+
+
+class OneofOptions(Message):
+
+    @property
+    def uninterpreted_option(
+        self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...
+
+    def __init__(self,
+                 uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> OneofOptions: ...
+
+
+class EnumOptions(Message):
+    allow_alias = ...  # type: bool
+    deprecated = ...  # type: bool
+
+    @property
+    def uninterpreted_option(
+        self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...
+
+    def __init__(self,
+                 allow_alias: Optional[bool] = ...,
+                 deprecated: Optional[bool] = ...,
+                 uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> EnumOptions: ...
+
+
+class EnumValueOptions(Message):
+    deprecated = ...  # type: bool
+
+    @property
+    def uninterpreted_option(
+        self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...
+
+    def __init__(self,
+                 deprecated: Optional[bool] = ...,
+                 uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> EnumValueOptions: ...
+
+
+class ServiceOptions(Message):
+    deprecated = ...  # type: bool
+
+    @property
+    def uninterpreted_option(
+        self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...
+
+    def __init__(self,
+                 deprecated: Optional[bool] = ...,
+                 uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> ServiceOptions: ...
+
+
+class MethodOptions(Message):
+
+    class IdempotencyLevel(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> MethodOptions.IdempotencyLevel: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[MethodOptions.IdempotencyLevel]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str, MethodOptions.IdempotencyLevel]]: ...
+    IDEMPOTENCY_UNKNOWN: IdempotencyLevel
+    NO_SIDE_EFFECTS: IdempotencyLevel
+    IDEMPOTENT: IdempotencyLevel
+    deprecated = ...  # type: bool
+    idempotency_level = ...  # type: MethodOptions.IdempotencyLevel
+
+    @property
+    def uninterpreted_option(
+        self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...
+
+    def __init__(self,
+                 deprecated: Optional[bool] = ...,
+                 idempotency_level: Optional[MethodOptions.IdempotencyLevel] = ...,
+                 uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> MethodOptions: ...
+
+
+class UninterpretedOption(Message):
+
+    class NamePart(Message):
+        name_part = ...  # type: Text
+        is_extension = ...  # type: bool
+
+        def __init__(self,
+                     name_part: Text,
+                     is_extension: bool,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> UninterpretedOption.NamePart: ...
+    identifier_value = ...  # type: Text
+    positive_int_value = ...  # type: int
+    negative_int_value = ...  # type: int
+    double_value = ...  # type: float
+    string_value = ...  # type: str
+    aggregate_value = ...  # type: Text
+
+    @property
+    def name(
+        self) -> RepeatedCompositeFieldContainer[UninterpretedOption.NamePart]: ...
+
+    def __init__(self,
+                 name: Optional[Iterable[UninterpretedOption.NamePart]] = ...,
+                 identifier_value: Optional[Text] = ...,
+                 positive_int_value: Optional[int] = ...,
+                 negative_int_value: Optional[int] = ...,
+                 double_value: Optional[float] = ...,
+                 string_value: Optional[str] = ...,
+                 aggregate_value: Optional[Text] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> UninterpretedOption: ...
+
+
+class SourceCodeInfo(Message):
+
+    class Location(Message):
+        path = ...  # type: RepeatedScalarFieldContainer[int]
+        span = ...  # type: RepeatedScalarFieldContainer[int]
+        leading_comments = ...  # type: Text
+        trailing_comments = ...  # type: Text
+        leading_detached_comments = ...  # type: RepeatedScalarFieldContainer[Text]
+
+        def __init__(self,
+                     path: Optional[Iterable[int]] = ...,
+                     span: Optional[Iterable[int]] = ...,
+                     leading_comments: Optional[Text] = ...,
+                     trailing_comments: Optional[Text] = ...,
+                     leading_detached_comments: Optional[Iterable[Text]] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> SourceCodeInfo.Location: ...
+
+    @property
+    def location(
+        self) -> RepeatedCompositeFieldContainer[SourceCodeInfo.Location]: ...
+
+    def __init__(self,
+                 location: Optional[Iterable[SourceCodeInfo.Location]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> SourceCodeInfo: ...
+
+
+class GeneratedCodeInfo(Message):
+
+    class Annotation(Message):
+        path = ...  # type: RepeatedScalarFieldContainer[int]
+        source_file = ...  # type: Text
+        begin = ...  # type: int
+        end = ...  # type: int
+
+        def __init__(self,
+                     path: Optional[Iterable[int]] = ...,
+                     source_file: Optional[Text] = ...,
+                     begin: Optional[int] = ...,
+                     end: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> GeneratedCodeInfo.Annotation: ...
+
+    @property
+    def annotation(
+        self) -> RepeatedCompositeFieldContainer[GeneratedCodeInfo.Annotation]: ...
+
+    def __init__(self,
+                 annotation: Optional[Iterable[GeneratedCodeInfo.Annotation]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> GeneratedCodeInfo: ...

third_party/2/google/protobuf/duration_pb2.pyi

@@ -0,0 +1,19 @@
+from google.protobuf.message import (
+    Message,
+)
+from typing import (
+    Optional,
+)
+
+
+class Duration(Message):
+    seconds = ...  # type: int
+    nanos = ...  # type: int
+
+    def __init__(self,
+                 seconds: Optional[int] = ...,
+                 nanos: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> Duration: ...

third_party/2/google/protobuf/empty_pb2.pyi

@@ -0,0 +1,12 @@
+from google.protobuf.message import (
+    Message,
+)
+
+
+class Empty(Message):
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> Empty: ...

third_party/2/google/protobuf/field_mask_pb2.pyi

@@ -0,0 +1,22 @@
+from google.protobuf.internal.containers import (
+    RepeatedScalarFieldContainer,
+)
+from google.protobuf.message import (
+    Message,
+)
+from typing import (
+    Iterable,
+    Optional,
+    Text,
+)
+
+
+class FieldMask(Message):
+    paths = ...  # type: RepeatedScalarFieldContainer[Text]
+
+    def __init__(self,
+                 paths: Optional[Iterable[Text]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> FieldMask: ...

third_party/2/google/protobuf/map_proto2_unittest_pb2.pyi

@@ -0,0 +1,428 @@
+from google.protobuf.message import (
+    Message,
+)
+from google.protobuf.unittest_import_pb2 import (
+    ImportEnumForMap,
+)
+from typing import (
+    List,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Text,
+    Tuple,
+    cast,
+)
+
+
+class Proto2MapEnum(int):
+
+    @classmethod
+    def Name(cls, number: int) -> str: ...
+
+    @classmethod
+    def Value(cls, name: str) -> Proto2MapEnum: ...
+
+    @classmethod
+    def keys(cls) -> List[str]: ...
+
+    @classmethod
+    def values(cls) -> List[Proto2MapEnum]: ...
+
+    @classmethod
+    def items(cls) -> List[Tuple[str, Proto2MapEnum]]: ...
+PROTO2_MAP_ENUM_FOO: Proto2MapEnum
+PROTO2_MAP_ENUM_BAR: Proto2MapEnum
+PROTO2_MAP_ENUM_BAZ: Proto2MapEnum
+
+
+class Proto2MapEnumPlusExtra(int):
+
+    @classmethod
+    def Name(cls, number: int) -> str: ...
+
+    @classmethod
+    def Value(cls, name: str) -> Proto2MapEnumPlusExtra: ...
+
+    @classmethod
+    def keys(cls) -> List[str]: ...
+
+    @classmethod
+    def values(cls) -> List[Proto2MapEnumPlusExtra]: ...
+
+    @classmethod
+    def items(cls) -> List[Tuple[str, Proto2MapEnumPlusExtra]]: ...
+E_PROTO2_MAP_ENUM_FOO: Proto2MapEnumPlusExtra
+E_PROTO2_MAP_ENUM_BAR: Proto2MapEnumPlusExtra
+E_PROTO2_MAP_ENUM_BAZ: Proto2MapEnumPlusExtra
+E_PROTO2_MAP_ENUM_EXTRA: Proto2MapEnumPlusExtra
+
+
+class TestEnumMap(Message):
+
+    class KnownMapFieldEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: Proto2MapEnum
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[Proto2MapEnum] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestEnumMap.KnownMapFieldEntry: ...
+
+    class UnknownMapFieldEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: Proto2MapEnum
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[Proto2MapEnum] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestEnumMap.UnknownMapFieldEntry: ...
+
+    @property
+    def known_map_field(self) -> MutableMapping[int, Proto2MapEnum]: ...
+
+    @property
+    def unknown_map_field(self) -> MutableMapping[int, Proto2MapEnum]: ...
+
+    def __init__(self,
+                 known_map_field: Optional[Mapping[int, Proto2MapEnum]]=...,
+                 unknown_map_field: Optional[Mapping[int, Proto2MapEnum]]=...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestEnumMap: ...
+
+
+class TestEnumMapPlusExtra(Message):
+
+    class KnownMapFieldEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: Proto2MapEnumPlusExtra
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[Proto2MapEnumPlusExtra] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestEnumMapPlusExtra.KnownMapFieldEntry: ...
+
+    class UnknownMapFieldEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: Proto2MapEnumPlusExtra
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[Proto2MapEnumPlusExtra] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestEnumMapPlusExtra.UnknownMapFieldEntry: ...
+
+    @property
+    def known_map_field(self) -> MutableMapping[int, Proto2MapEnumPlusExtra]: ...
+
+    @property
+    def unknown_map_field(self) -> MutableMapping[int, Proto2MapEnumPlusExtra]: ...
+
+    def __init__(self,
+                 known_map_field: Optional[Mapping[int, Proto2MapEnumPlusExtra]]=...,
+                 unknown_map_field: Optional[Mapping[int, Proto2MapEnumPlusExtra]]=...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestEnumMapPlusExtra: ...
+
+
+class TestImportEnumMap(Message):
+
+    class ImportEnumAmpEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: ImportEnumForMap
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[ImportEnumForMap] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestImportEnumMap.ImportEnumAmpEntry: ...
+
+    @property
+    def import_enum_amp(self) -> MutableMapping[int, ImportEnumForMap]: ...
+
+    def __init__(self,
+                 import_enum_amp: Optional[Mapping[int, ImportEnumForMap]]=...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestImportEnumMap: ...
+
+
+class TestIntIntMap(Message):
+
+    class MEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestIntIntMap.MEntry: ...
+
+    @property
+    def m(self) -> MutableMapping[int, int]: ...
+
+    def __init__(self,
+                 m: Optional[Mapping[int, int]]=...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestIntIntMap: ...
+
+
+class TestMaps(Message):
+
+    class MInt32Entry(Message):
+        key = ...  # type: int
+
+        @property
+        def value(self) -> TestIntIntMap: ...
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[TestIntIntMap] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMaps.MInt32Entry: ...
+
+    class MInt64Entry(Message):
+        key = ...  # type: int
+
+        @property
+        def value(self) -> TestIntIntMap: ...
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[TestIntIntMap] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMaps.MInt64Entry: ...
+
+    class MUint32Entry(Message):
+        key = ...  # type: int
+
+        @property
+        def value(self) -> TestIntIntMap: ...
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[TestIntIntMap] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMaps.MUint32Entry: ...
+
+    class MUint64Entry(Message):
+        key = ...  # type: int
+
+        @property
+        def value(self) -> TestIntIntMap: ...
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[TestIntIntMap] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMaps.MUint64Entry: ...
+
+    class MSint32Entry(Message):
+        key = ...  # type: int
+
+        @property
+        def value(self) -> TestIntIntMap: ...
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[TestIntIntMap] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMaps.MSint32Entry: ...
+
+    class MSint64Entry(Message):
+        key = ...  # type: int
+
+        @property
+        def value(self) -> TestIntIntMap: ...
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[TestIntIntMap] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMaps.MSint64Entry: ...
+
+    class MFixed32Entry(Message):
+        key = ...  # type: int
+
+        @property
+        def value(self) -> TestIntIntMap: ...
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[TestIntIntMap] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMaps.MFixed32Entry: ...
+
+    class MFixed64Entry(Message):
+        key = ...  # type: int
+
+        @property
+        def value(self) -> TestIntIntMap: ...
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[TestIntIntMap] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMaps.MFixed64Entry: ...
+
+    class MSfixed32Entry(Message):
+        key = ...  # type: int
+
+        @property
+        def value(self) -> TestIntIntMap: ...
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[TestIntIntMap] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMaps.MSfixed32Entry: ...
+
+    class MSfixed64Entry(Message):
+        key = ...  # type: int
+
+        @property
+        def value(self) -> TestIntIntMap: ...
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[TestIntIntMap] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMaps.MSfixed64Entry: ...
+
+    class MBoolEntry(Message):
+        key = ...  # type: bool
+
+        @property
+        def value(self) -> TestIntIntMap: ...
+
+        def __init__(self,
+                     key: Optional[bool] = ...,
+                     value: Optional[TestIntIntMap] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMaps.MBoolEntry: ...
+
+    class MStringEntry(Message):
+        key = ...  # type: Text
+
+        @property
+        def value(self) -> TestIntIntMap: ...
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[TestIntIntMap] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMaps.MStringEntry: ...
+
+    @property
+    def m_int32(self) -> MutableMapping[int, TestIntIntMap]: ...
+
+    @property
+    def m_int64(self) -> MutableMapping[int, TestIntIntMap]: ...
+
+    @property
+    def m_uint32(self) -> MutableMapping[int, TestIntIntMap]: ...
+
+    @property
+    def m_uint64(self) -> MutableMapping[int, TestIntIntMap]: ...
+
+    @property
+    def m_sint32(self) -> MutableMapping[int, TestIntIntMap]: ...
+
+    @property
+    def m_sint64(self) -> MutableMapping[int, TestIntIntMap]: ...
+
+    @property
+    def m_fixed32(self) -> MutableMapping[int, TestIntIntMap]: ...
+
+    @property
+    def m_fixed64(self) -> MutableMapping[int, TestIntIntMap]: ...
+
+    @property
+    def m_sfixed32(self) -> MutableMapping[int, TestIntIntMap]: ...
+
+    @property
+    def m_sfixed64(self) -> MutableMapping[int, TestIntIntMap]: ...
+
+    @property
+    def m_bool(self) -> MutableMapping[bool, TestIntIntMap]: ...
+
+    @property
+    def m_string(self) -> MutableMapping[Text, TestIntIntMap]: ...
+
+    def __init__(self,
+                 m_int32: Optional[Mapping[int, TestIntIntMap]]=...,
+                 m_int64: Optional[Mapping[int, TestIntIntMap]]=...,
+                 m_uint32: Optional[Mapping[int, TestIntIntMap]]=...,
+                 m_uint64: Optional[Mapping[int, TestIntIntMap]]=...,
+                 m_sint32: Optional[Mapping[int, TestIntIntMap]]=...,
+                 m_sint64: Optional[Mapping[int, TestIntIntMap]]=...,
+                 m_fixed32: Optional[Mapping[int, TestIntIntMap]]=...,
+                 m_fixed64: Optional[Mapping[int, TestIntIntMap]]=...,
+                 m_sfixed32: Optional[Mapping[int, TestIntIntMap]]=...,
+                 m_sfixed64: Optional[Mapping[int, TestIntIntMap]]=...,
+                 m_bool: Optional[Mapping[bool, TestIntIntMap]]=...,
+                 m_string: Optional[Mapping[Text, TestIntIntMap]]=...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestMaps: ...
+
+
+class TestSubmessageMaps(Message):
+
+    @property
+    def m(self) -> TestMaps: ...
+
+    def __init__(self,
+                 m: Optional[TestMaps] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestSubmessageMaps: ...

third_party/2/google/protobuf/map_unittest_pb2.pyi

@@ -0,0 +1,882 @@
+from google.protobuf.message import (
+    Message,
+)
+from google.protobuf.unittest_no_arena_pb2 import (
+    ForeignMessage,
+)
+from google.protobuf.unittest_pb2 import (
+    ForeignMessage as ForeignMessage1,
+    TestAllTypes,
+    TestRequired,
+)
+from typing import (
+    List,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Text,
+    Tuple,
+    cast,
+)
+
+
+class MapEnum(int):
+
+    @classmethod
+    def Name(cls, number: int) -> str: ...
+
+    @classmethod
+    def Value(cls, name: str) -> MapEnum: ...
+
+    @classmethod
+    def keys(cls) -> List[str]: ...
+
+    @classmethod
+    def values(cls) -> List[MapEnum]: ...
+
+    @classmethod
+    def items(cls) -> List[Tuple[str, MapEnum]]: ...
+
+
+MAP_ENUM_FOO: MapEnum
+MAP_ENUM_BAR: MapEnum
+MAP_ENUM_BAZ: MapEnum
+
+
+class TestMap(Message):
+
+    class MapInt32Int32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapInt32Int32Entry: ...
+
+    class MapInt64Int64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapInt64Int64Entry: ...
+
+    class MapUint32Uint32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapUint32Uint32Entry: ...
+
+    class MapUint64Uint64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapUint64Uint64Entry: ...
+
+    class MapSint32Sint32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapSint32Sint32Entry: ...
+
+    class MapSint64Sint64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapSint64Sint64Entry: ...
+
+    class MapFixed32Fixed32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapFixed32Fixed32Entry: ...
+
+    class MapFixed64Fixed64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapFixed64Fixed64Entry: ...
+
+    class MapSfixed32Sfixed32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapSfixed32Sfixed32Entry: ...
+
+    class MapSfixed64Sfixed64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapSfixed64Sfixed64Entry: ...
+
+    class MapInt32FloatEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: float
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[float] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapInt32FloatEntry: ...
+
+    class MapInt32DoubleEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: float
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[float] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapInt32DoubleEntry: ...
+
+    class MapBoolBoolEntry(Message):
+        key = ...  # type: bool
+        value = ...  # type: bool
+
+        def __init__(self,
+                     key: Optional[bool] = ...,
+                     value: Optional[bool] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapBoolBoolEntry: ...
+
+    class MapStringStringEntry(Message):
+        key = ...  # type: Text
+        value = ...  # type: Text
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[Text] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapStringStringEntry: ...
+
+    class MapInt32BytesEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: str
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[str] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapInt32BytesEntry: ...
+
+    class MapInt32EnumEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: MapEnum
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[MapEnum] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapInt32EnumEntry: ...
+
+    class MapInt32ForeignMessageEntry(Message):
+        key = ...  # type: int
+
+        @property
+        def value(self) -> ForeignMessage1: ...
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[ForeignMessage1] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapInt32ForeignMessageEntry: ...
+
+    class MapStringForeignMessageEntry(Message):
+        key = ...  # type: Text
+
+        @property
+        def value(self) -> ForeignMessage1: ...
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[ForeignMessage1] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestMap.MapStringForeignMessageEntry: ...
+
+    class MapInt32AllTypesEntry(Message):
+        key = ...  # type: int
+
+        @property
+        def value(self) -> TestAllTypes: ...
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[TestAllTypes] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.MapInt32AllTypesEntry: ...
+
+    @property
+    def map_int32_int32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_int64_int64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_uint32_uint32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_uint64_uint64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_sint32_sint32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_sint64_sint64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_fixed32_fixed32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_fixed64_fixed64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_sfixed32_sfixed32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_sfixed64_sfixed64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_int32_float(self) -> MutableMapping[int, float]: ...
+
+    @property
+    def map_int32_double(self) -> MutableMapping[int, float]: ...
+
+    @property
+    def map_bool_bool(self) -> MutableMapping[bool, bool]: ...
+
+    @property
+    def map_string_string(self) -> MutableMapping[Text, Text]: ...
+
+    @property
+    def map_int32_bytes(self) -> MutableMapping[int, str]: ...
+
+    @property
+    def map_int32_enum(self) -> MutableMapping[int, MapEnum]: ...
+
+    @property
+    def map_int32_foreign_message(
+        self) -> MutableMapping[int, ForeignMessage1]: ...
+
+    @property
+    def map_string_foreign_message(
+        self) -> MutableMapping[Text, ForeignMessage1]: ...
+
+    @property
+    def map_int32_all_types(self) -> MutableMapping[int, TestAllTypes]: ...
+
+    def __init__(self,
+                 map_int32_int32: Optional[Mapping[int, int]]=...,
+                 map_int64_int64: Optional[Mapping[int, int]]=...,
+                 map_uint32_uint32: Optional[Mapping[int, int]]=...,
+                 map_uint64_uint64: Optional[Mapping[int, int]]=...,
+                 map_sint32_sint32: Optional[Mapping[int, int]]=...,
+                 map_sint64_sint64: Optional[Mapping[int, int]]=...,
+                 map_fixed32_fixed32: Optional[Mapping[int, int]]=...,
+                 map_fixed64_fixed64: Optional[Mapping[int, int]]=...,
+                 map_sfixed32_sfixed32: Optional[Mapping[int, int]]=...,
+                 map_sfixed64_sfixed64: Optional[Mapping[int, int]]=...,
+                 map_int32_float: Optional[Mapping[int, float]]=...,
+                 map_int32_double: Optional[Mapping[int, float]]=...,
+                 map_bool_bool: Optional[Mapping[bool, bool]]=...,
+                 map_string_string: Optional[Mapping[Text, Text]]=...,
+                 map_int32_bytes: Optional[Mapping[int, str]]=...,
+                 map_int32_enum: Optional[Mapping[int, MapEnum]]=...,
+                 map_int32_foreign_message: Optional[Mapping[int, ForeignMessage1]]=...,
+                 map_string_foreign_message: Optional[Mapping[Text, ForeignMessage1]]=...,
+                 map_int32_all_types: Optional[Mapping[int, TestAllTypes]]=...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestMap: ...
+
+
+class TestMapSubmessage(Message):
+
+    @property
+    def test_map(self) -> TestMap: ...
+
+    def __init__(self,
+                 test_map: Optional[TestMap] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestMapSubmessage: ...
+
+
+class TestMessageMap(Message):
+
+    class MapInt32MessageEntry(Message):
+        key = ...  # type: int
+
+        @property
+        def value(self) -> TestAllTypes: ...
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[TestAllTypes] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMessageMap.MapInt32MessageEntry: ...
+
+    @property
+    def map_int32_message(self) -> MutableMapping[int, TestAllTypes]: ...
+
+    def __init__(self,
+                 map_int32_message: Optional[Mapping[int, TestAllTypes]]=...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestMessageMap: ...
+
+
+class TestSameTypeMap(Message):
+
+    class Map1Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestSameTypeMap.Map1Entry: ...
+
+    class Map2Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestSameTypeMap.Map2Entry: ...
+
+    @property
+    def map1(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map2(self) -> MutableMapping[int, int]: ...
+
+    def __init__(self,
+                 map1: Optional[Mapping[int, int]]=...,
+                 map2: Optional[Mapping[int, int]]=...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestSameTypeMap: ...
+
+
+class TestRequiredMessageMap(Message):
+
+    class MapFieldEntry(Message):
+        key = ...  # type: int
+
+        @property
+        def value(self) -> TestRequired: ...
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[TestRequired] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestRequiredMessageMap.MapFieldEntry: ...
+
+    @property
+    def map_field(self) -> MutableMapping[int, TestRequired]: ...
+
+    def __init__(self,
+                 map_field: Optional[Mapping[int, TestRequired]]=...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestRequiredMessageMap: ...
+
+
+class TestArenaMap(Message):
+
+    class MapInt32Int32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestArenaMap.MapInt32Int32Entry: ...
+
+    class MapInt64Int64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestArenaMap.MapInt64Int64Entry: ...
+
+    class MapUint32Uint32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestArenaMap.MapUint32Uint32Entry: ...
+
+    class MapUint64Uint64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestArenaMap.MapUint64Uint64Entry: ...
+
+    class MapSint32Sint32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestArenaMap.MapSint32Sint32Entry: ...
+
+    class MapSint64Sint64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestArenaMap.MapSint64Sint64Entry: ...
+
+    class MapFixed32Fixed32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestArenaMap.MapFixed32Fixed32Entry: ...
+
+    class MapFixed64Fixed64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestArenaMap.MapFixed64Fixed64Entry: ...
+
+    class MapSfixed32Sfixed32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestArenaMap.MapSfixed32Sfixed32Entry: ...
+
+    class MapSfixed64Sfixed64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestArenaMap.MapSfixed64Sfixed64Entry: ...
+
+    class MapInt32FloatEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: float
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[float] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestArenaMap.MapInt32FloatEntry: ...
+
+    class MapInt32DoubleEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: float
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[float] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestArenaMap.MapInt32DoubleEntry: ...
+
+    class MapBoolBoolEntry(Message):
+        key = ...  # type: bool
+        value = ...  # type: bool
+
+        def __init__(self,
+                     key: Optional[bool] = ...,
+                     value: Optional[bool] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestArenaMap.MapBoolBoolEntry: ...
+
+    class MapStringStringEntry(Message):
+        key = ...  # type: Text
+        value = ...  # type: Text
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[Text] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestArenaMap.MapStringStringEntry: ...
+
+    class MapInt32BytesEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: str
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[str] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestArenaMap.MapInt32BytesEntry: ...
+
+    class MapInt32EnumEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: MapEnum
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[MapEnum] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestArenaMap.MapInt32EnumEntry: ...
+
+    class MapInt32ForeignMessageEntry(Message):
+        key = ...  # type: int
+
+        @property
+        def value(self) -> ForeignMessage1: ...
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[ForeignMessage1] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestArenaMap.MapInt32ForeignMessageEntry: ...
+
+    class MapInt32ForeignMessageNoArenaEntry(Message):
+        key = ...  # type: int
+
+        @property
+        def value(self) -> ForeignMessage: ...
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[ForeignMessage] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestArenaMap.MapInt32ForeignMessageNoArenaEntry: ...
+
+    @property
+    def map_int32_int32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_int64_int64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_uint32_uint32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_uint64_uint64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_sint32_sint32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_sint64_sint64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_fixed32_fixed32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_fixed64_fixed64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_sfixed32_sfixed32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_sfixed64_sfixed64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_int32_float(self) -> MutableMapping[int, float]: ...
+
+    @property
+    def map_int32_double(self) -> MutableMapping[int, float]: ...
+
+    @property
+    def map_bool_bool(self) -> MutableMapping[bool, bool]: ...
+
+    @property
+    def map_string_string(self) -> MutableMapping[Text, Text]: ...
+
+    @property
+    def map_int32_bytes(self) -> MutableMapping[int, str]: ...
+
+    @property
+    def map_int32_enum(self) -> MutableMapping[int, MapEnum]: ...
+
+    @property
+    def map_int32_foreign_message(
+        self) -> MutableMapping[int, ForeignMessage1]: ...
+
+    @property
+    def map_int32_foreign_message_no_arena(
+        self) -> MutableMapping[int, ForeignMessage]: ...
+
+    def __init__(self,
+                 map_int32_int32: Optional[Mapping[int, int]]=...,
+                 map_int64_int64: Optional[Mapping[int, int]]=...,
+                 map_uint32_uint32: Optional[Mapping[int, int]]=...,
+                 map_uint64_uint64: Optional[Mapping[int, int]]=...,
+                 map_sint32_sint32: Optional[Mapping[int, int]]=...,
+                 map_sint64_sint64: Optional[Mapping[int, int]]=...,
+                 map_fixed32_fixed32: Optional[Mapping[int, int]]=...,
+                 map_fixed64_fixed64: Optional[Mapping[int, int]]=...,
+                 map_sfixed32_sfixed32: Optional[Mapping[int, int]]=...,
+                 map_sfixed64_sfixed64: Optional[Mapping[int, int]]=...,
+                 map_int32_float: Optional[Mapping[int, float]]=...,
+                 map_int32_double: Optional[Mapping[int, float]]=...,
+                 map_bool_bool: Optional[Mapping[bool, bool]]=...,
+                 map_string_string: Optional[Mapping[Text, Text]]=...,
+                 map_int32_bytes: Optional[Mapping[int, str]]=...,
+                 map_int32_enum: Optional[Mapping[int, MapEnum]]=...,
+                 map_int32_foreign_message: Optional[Mapping[int, ForeignMessage1]]=...,
+                 map_int32_foreign_message_no_arena: Optional[Mapping[int, ForeignMessage]]=...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestArenaMap: ...
+
+
+class MessageContainingEnumCalledType(Message):
+
+    class Type(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> MessageContainingEnumCalledType.Type: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[MessageContainingEnumCalledType.Type]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str,
+                                     MessageContainingEnumCalledType.Type]]: ...
+    TYPE_FOO: Type
+
+    class TypeEntry(Message):
+        key = ...  # type: Text
+
+        @property
+        def value(self) -> MessageContainingEnumCalledType: ...
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[MessageContainingEnumCalledType] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> MessageContainingEnumCalledType.TypeEntry: ...
+
+    @property
+    def type(self) -> MutableMapping[Text,
+                                     MessageContainingEnumCalledType]: ...
+
+    def __init__(self,
+                 type: Optional[Mapping[Text, MessageContainingEnumCalledType]]=...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> MessageContainingEnumCalledType: ...
+
+
+class MessageContainingMapCalledEntry(Message):
+
+    class EntryEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> MessageContainingMapCalledEntry.EntryEntry: ...
+
+    @property
+    def entry(self) -> MutableMapping[int, int]: ...
+
+    def __init__(self,
+                 entry: Optional[Mapping[int, int]]=...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> MessageContainingMapCalledEntry: ...
+
+
+class TestRecursiveMapMessage(Message):
+
+    class AEntry(Message):
+        key = ...  # type: Text
+
+        @property
+        def value(self) -> TestRecursiveMapMessage: ...
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[TestRecursiveMapMessage] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestRecursiveMapMessage.AEntry: ...
+
+    @property
+    def a(self) -> MutableMapping[Text, TestRecursiveMapMessage]: ...
+
+    def __init__(self,
+                 a: Optional[Mapping[Text, TestRecursiveMapMessage]]=...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestRecursiveMapMessage: ...

third_party/2/google/protobuf/source_context_pb2.pyi

@@ -0,0 +1,18 @@
+from google.protobuf.message import (
+    Message,
+)
+from typing import (
+    Optional,
+    Text,
+)
+
+
+class SourceContext(Message):
+    file_name = ...  # type: Text
+
+    def __init__(self,
+                 file_name: Optional[Text] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> SourceContext: ...

third_party/2/google/protobuf/struct_pb2.pyi

@@ -0,0 +1,103 @@
+from google.protobuf.internal.containers import (
+    RepeatedCompositeFieldContainer,
+)
+from google.protobuf.message import (
+    Message,
+)
+from typing import (
+    Iterable,
+    List,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Text,
+    Tuple,
+    cast,
+)
+
+
+class NullValue(int):
+    @classmethod
+    def Name(cls, number: int) -> str: ...
+
+    @classmethod
+    def Value(cls, name: str) -> NullValue: ...
+
+    @classmethod
+    def keys(cls) -> List[str]: ...
+
+    @classmethod
+    def values(cls) -> List[NullValue]: ...
+
+    @classmethod
+    def items(cls) -> List[Tuple[str, NullValue]]: ...
+
+
+NULL_VALUE: NullValue
+
+
+class Struct(Message):
+    class FieldsEntry(Message):
+        key = ...  # type: Text
+
+        @property
+        def value(self) -> Value: ...
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[Value] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> Struct.FieldsEntry: ...
+
+    @property
+    def fields(self) -> MutableMapping[Text, Value]: ...
+
+    def __init__(self,
+                 fields: Optional[Mapping[Text, Value]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> Struct: ...
+
+
+class _Value(Message):
+    null_value = ...  # type: NullValue
+    number_value = ...  # type: float
+    string_value = ...  # type: Text
+    bool_value = ...  # type: bool
+
+    @property
+    def struct_value(self) -> Struct: ...
+
+    @property
+    def list_value(self) -> ListValue: ...
+
+    def __init__(self,
+                 null_value: Optional[NullValue] = ...,
+                 number_value: Optional[float] = ...,
+                 string_value: Optional[Text] = ...,
+                 bool_value: Optional[bool] = ...,
+                 struct_value: Optional[Struct] = ...,
+                 list_value: Optional[ListValue] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> _Value: ...
+
+
+Value = _Value
+
+
+class ListValue(Message):
+
+    @property
+    def values(self) -> RepeatedCompositeFieldContainer[Value]: ...
+
+    def __init__(self,
+                 values: Optional[Iterable[Value]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> ListValue: ...

third_party/2/google/protobuf/test_messages_proto2_pb2.pyi

@@ -0,0 +1,627 @@
+from google.protobuf.internal.containers import (
+    RepeatedCompositeFieldContainer,
+    RepeatedScalarFieldContainer,
+)
+from google.protobuf.message import (
+    Message,
+)
+import builtins
+from typing import (
+    Iterable,
+    List,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Text,
+    Tuple,
+    cast,
+)
+
+
+class ForeignEnumProto2(int):
+
+    @classmethod
+    def Name(cls, number: int) -> str: ...
+
+    @classmethod
+    def Value(cls, name: str) -> ForeignEnumProto2: ...
+
+    @classmethod
+    def keys(cls) -> List[str]: ...
+
+    @classmethod
+    def values(cls) -> List[ForeignEnumProto2]: ...
+
+    @classmethod
+    def items(cls) -> List[Tuple[str, ForeignEnumProto2]]: ...
+
+
+FOREIGN_FOO: ForeignEnumProto2
+FOREIGN_BAR: ForeignEnumProto2
+FOREIGN_BAZ: ForeignEnumProto2
+
+
+class TestAllTypesProto2(Message):
+
+    class NestedEnum(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> TestAllTypesProto2.NestedEnum: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[TestAllTypesProto2.NestedEnum]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str, TestAllTypesProto2.NestedEnum]]: ...
+    FOO: NestedEnum
+    BAR: NestedEnum
+    BAZ: NestedEnum
+    NEG: NestedEnum
+
+    class NestedMessage(Message):
+        a = ...  # type: int
+
+        @property
+        def corecursive(self) -> TestAllTypesProto2: ...
+
+        def __init__(self,
+                     a: Optional[int] = ...,
+                     corecursive: Optional[TestAllTypesProto2] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto2.NestedMessage: ...
+
+    class MapInt32Int32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapInt32Int32Entry: ...
+
+    class MapInt64Int64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapInt64Int64Entry: ...
+
+    class MapUint32Uint32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapUint32Uint32Entry: ...
+
+    class MapUint64Uint64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapUint64Uint64Entry: ...
+
+    class MapSint32Sint32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapSint32Sint32Entry: ...
+
+    class MapSint64Sint64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapSint64Sint64Entry: ...
+
+    class MapFixed32Fixed32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapFixed32Fixed32Entry: ...
+
+    class MapFixed64Fixed64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapFixed64Fixed64Entry: ...
+
+    class MapSfixed32Sfixed32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapSfixed32Sfixed32Entry: ...
+
+    class MapSfixed64Sfixed64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapSfixed64Sfixed64Entry: ...
+
+    class MapInt32FloatEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: float
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[float] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapInt32FloatEntry: ...
+
+    class MapInt32DoubleEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: float
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[float] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapInt32DoubleEntry: ...
+
+    class MapBoolBoolEntry(Message):
+        key = ...  # type: bool
+        value = ...  # type: bool
+
+        def __init__(self,
+                     key: Optional[bool] = ...,
+                     value: Optional[bool] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto2.MapBoolBoolEntry: ...
+
+    class MapStringStringEntry(Message):
+        key = ...  # type: Text
+        value = ...  # type: Text
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[Text] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapStringStringEntry: ...
+
+    class MapStringBytesEntry(Message):
+        key = ...  # type: Text
+        value = ...  # type: str
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[str] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapStringBytesEntry: ...
+
+    class MapStringNestedMessageEntry(Message):
+        key = ...  # type: Text
+
+        @property
+        def value(self) -> TestAllTypesProto2.NestedMessage: ...
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[TestAllTypesProto2.NestedMessage] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapStringNestedMessageEntry: ...
+
+    class MapStringForeignMessageEntry(Message):
+        key = ...  # type: Text
+
+        @property
+        def value(self) -> ForeignMessageProto2: ...
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[ForeignMessageProto2] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapStringForeignMessageEntry: ...
+
+    class MapStringNestedEnumEntry(Message):
+        key = ...  # type: Text
+        value = ...  # type: TestAllTypesProto2.NestedEnum
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[TestAllTypesProto2.NestedEnum] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapStringNestedEnumEntry: ...
+
+    class MapStringForeignEnumEntry(Message):
+        key = ...  # type: Text
+        value = ...  # type: ForeignEnumProto2
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[ForeignEnumProto2] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MapStringForeignEnumEntry: ...
+
+    class Data(Message):
+        group_int32 = ...  # type: int
+        group_uint32 = ...  # type: int
+
+        def __init__(self,
+                     group_int32: Optional[int] = ...,
+                     group_uint32: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto2.Data: ...
+
+    class MessageSetCorrect(Message):
+
+        def __init__(self,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MessageSetCorrect: ...
+
+    class MessageSetCorrectExtension1(Message):
+        str = ...  # type: Text
+
+        def __init__(self,
+                     str: Optional[Text] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: builtins.str) -> TestAllTypesProto2.MessageSetCorrectExtension1: ...
+
+    class MessageSetCorrectExtension2(Message):
+        i = ...  # type: int
+
+        def __init__(self,
+                     i: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> TestAllTypesProto2.MessageSetCorrectExtension2: ...
+    optional_int32 = ...  # type: int
+    optional_int64 = ...  # type: int
+    optional_uint32 = ...  # type: int
+    optional_uint64 = ...  # type: int
+    optional_sint32 = ...  # type: int
+    optional_sint64 = ...  # type: int
+    optional_fixed32 = ...  # type: int
+    optional_fixed64 = ...  # type: int
+    optional_sfixed32 = ...  # type: int
+    optional_sfixed64 = ...  # type: int
+    optional_float = ...  # type: float
+    optional_double = ...  # type: float
+    optional_bool = ...  # type: bool
+    optional_string = ...  # type: Text
+    optional_bytes = ...  # type: str
+    optional_nested_enum = ...  # type: TestAllTypesProto2.NestedEnum
+    optional_foreign_enum = ...  # type: ForeignEnumProto2
+    optional_string_piece = ...  # type: Text
+    optional_cord = ...  # type: Text
+    repeated_int32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_int64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_uint32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_uint64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sint32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sint64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_fixed32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_fixed64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sfixed32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sfixed64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_float = ...  # type: RepeatedScalarFieldContainer[float]
+    repeated_double = ...  # type: RepeatedScalarFieldContainer[float]
+    repeated_bool = ...  # type: RepeatedScalarFieldContainer[bool]
+    repeated_string = ...  # type: RepeatedScalarFieldContainer[Text]
+    repeated_bytes = ...  # type: RepeatedScalarFieldContainer[str]
+    repeated_nested_enum = ...  # type: RepeatedScalarFieldContainer[TestAllTypesProto2.NestedEnum]
+    repeated_foreign_enum = ...  # type: RepeatedScalarFieldContainer[ForeignEnumProto2]
+    repeated_string_piece = ...  # type: RepeatedScalarFieldContainer[Text]
+    repeated_cord = ...  # type: RepeatedScalarFieldContainer[Text]
+    oneof_uint32 = ...  # type: int
+    oneof_string = ...  # type: Text
+    oneof_bytes = ...  # type: str
+    oneof_bool = ...  # type: bool
+    oneof_uint64 = ...  # type: int
+    oneof_float = ...  # type: float
+    oneof_double = ...  # type: float
+    oneof_enum = ...  # type: TestAllTypesProto2.NestedEnum
+    fieldname1 = ...  # type: int
+    field_name2 = ...  # type: int
+    _field_name3 = ...  # type: int
+    field__name4_ = ...  # type: int
+    field0name5 = ...  # type: int
+    field_0_name6 = ...  # type: int
+    fieldName7 = ...  # type: int
+    FieldName8 = ...  # type: int
+    field_Name9 = ...  # type: int
+    Field_Name10 = ...  # type: int
+    FIELD_NAME11 = ...  # type: int
+    FIELD_name12 = ...  # type: int
+    __field_name13 = ...  # type: int
+    __Field_name14 = ...  # type: int
+    field__name15 = ...  # type: int
+    field__Name16 = ...  # type: int
+    field_name17__ = ...  # type: int
+    Field_name18__ = ...  # type: int
+
+    @property
+    def optional_nested_message(self) -> TestAllTypesProto2.NestedMessage: ...
+
+    @property
+    def optional_foreign_message(self) -> ForeignMessageProto2: ...
+
+    @property
+    def recursive_message(self) -> TestAllTypesProto2: ...
+
+    @property
+    def repeated_nested_message(
+        self) -> RepeatedCompositeFieldContainer[TestAllTypesProto2.NestedMessage]: ...
+
+    @property
+    def repeated_foreign_message(
+        self) -> RepeatedCompositeFieldContainer[ForeignMessageProto2]: ...
+
+    @property
+    def map_int32_int32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_int64_int64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_uint32_uint32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_uint64_uint64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_sint32_sint32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_sint64_sint64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_fixed32_fixed32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_fixed64_fixed64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_sfixed32_sfixed32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_sfixed64_sfixed64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_int32_float(self) -> MutableMapping[int, float]: ...
+
+    @property
+    def map_int32_double(self) -> MutableMapping[int, float]: ...
+
+    @property
+    def map_bool_bool(self) -> MutableMapping[bool, bool]: ...
+
+    @property
+    def map_string_string(self) -> MutableMapping[Text, Text]: ...
+
+    @property
+    def map_string_bytes(self) -> MutableMapping[Text, str]: ...
+
+    @property
+    def map_string_nested_message(
+        self) -> MutableMapping[Text, TestAllTypesProto2.NestedMessage]: ...
+
+    @property
+    def map_string_foreign_message(
+        self) -> MutableMapping[Text, ForeignMessageProto2]: ...
+
+    @property
+    def map_string_nested_enum(
+        self) -> MutableMapping[Text, TestAllTypesProto2.NestedEnum]: ...
+
+    @property
+    def map_string_foreign_enum(
+        self) -> MutableMapping[Text, ForeignEnumProto2]: ...
+
+    @property
+    def oneof_nested_message(self) -> TestAllTypesProto2.NestedMessage: ...
+
+    @property
+    def data(self) -> TestAllTypesProto2.Data: ...
+
+    def __init__(self,
+                 optional_int32: Optional[int] = ...,
+                 optional_int64: Optional[int] = ...,
+                 optional_uint32: Optional[int] = ...,
+                 optional_uint64: Optional[int] = ...,
+                 optional_sint32: Optional[int] = ...,
+                 optional_sint64: Optional[int] = ...,
+                 optional_fixed32: Optional[int] = ...,
+                 optional_fixed64: Optional[int] = ...,
+                 optional_sfixed32: Optional[int] = ...,
+                 optional_sfixed64: Optional[int] = ...,
+                 optional_float: Optional[float] = ...,
+                 optional_double: Optional[float] = ...,
+                 optional_bool: Optional[bool] = ...,
+                 optional_string: Optional[Text] = ...,
+                 optional_bytes: Optional[str] = ...,
+                 optional_nested_message: Optional[TestAllTypesProto2.NestedMessage] = ...,
+                 optional_foreign_message: Optional[ForeignMessageProto2] = ...,
+                 optional_nested_enum: Optional[TestAllTypesProto2.NestedEnum] = ...,
+                 optional_foreign_enum: Optional[ForeignEnumProto2] = ...,
+                 optional_string_piece: Optional[Text] = ...,
+                 optional_cord: Optional[Text] = ...,
+                 recursive_message: Optional[TestAllTypesProto2] = ...,
+                 repeated_int32: Optional[Iterable[int]] = ...,
+                 repeated_int64: Optional[Iterable[int]] = ...,
+                 repeated_uint32: Optional[Iterable[int]] = ...,
+                 repeated_uint64: Optional[Iterable[int]] = ...,
+                 repeated_sint32: Optional[Iterable[int]] = ...,
+                 repeated_sint64: Optional[Iterable[int]] = ...,
+                 repeated_fixed32: Optional[Iterable[int]] = ...,
+                 repeated_fixed64: Optional[Iterable[int]] = ...,
+                 repeated_sfixed32: Optional[Iterable[int]] = ...,
+                 repeated_sfixed64: Optional[Iterable[int]] = ...,
+                 repeated_float: Optional[Iterable[float]] = ...,
+                 repeated_double: Optional[Iterable[float]] = ...,
+                 repeated_bool: Optional[Iterable[bool]] = ...,
+                 repeated_string: Optional[Iterable[Text]] = ...,
+                 repeated_bytes: Optional[Iterable[str]] = ...,
+                 repeated_nested_message: Optional[Iterable[TestAllTypesProto2.NestedMessage]] = ...,
+                 repeated_foreign_message: Optional[Iterable[ForeignMessageProto2]] = ...,
+                 repeated_nested_enum: Optional[Iterable[TestAllTypesProto2.NestedEnum]] = ...,
+                 repeated_foreign_enum: Optional[Iterable[ForeignEnumProto2]] = ...,
+                 repeated_string_piece: Optional[Iterable[Text]] = ...,
+                 repeated_cord: Optional[Iterable[Text]] = ...,
+                 map_int32_int32: Optional[Mapping[int, int]]=...,
+                 map_int64_int64: Optional[Mapping[int, int]]=...,
+                 map_uint32_uint32: Optional[Mapping[int, int]]=...,
+                 map_uint64_uint64: Optional[Mapping[int, int]]=...,
+                 map_sint32_sint32: Optional[Mapping[int, int]]=...,
+                 map_sint64_sint64: Optional[Mapping[int, int]]=...,
+                 map_fixed32_fixed32: Optional[Mapping[int, int]]=...,
+                 map_fixed64_fixed64: Optional[Mapping[int, int]]=...,
+                 map_sfixed32_sfixed32: Optional[Mapping[int, int]]=...,
+                 map_sfixed64_sfixed64: Optional[Mapping[int, int]]=...,
+                 map_int32_float: Optional[Mapping[int, float]]=...,
+                 map_int32_double: Optional[Mapping[int, float]]=...,
+                 map_bool_bool: Optional[Mapping[bool, bool]]=...,
+                 map_string_string: Optional[Mapping[Text, Text]]=...,
+                 map_string_bytes: Optional[Mapping[Text, str]]=...,
+                 map_string_nested_message: Optional[Mapping[Text, TestAllTypesProto2.NestedMessage]]=...,
+                 map_string_foreign_message: Optional[Mapping[Text, ForeignMessageProto2]]=...,
+                 map_string_nested_enum: Optional[Mapping[Text, TestAllTypesProto2.NestedEnum]]=...,
+                 map_string_foreign_enum: Optional[Mapping[Text, ForeignEnumProto2]]=...,
+                 oneof_uint32: Optional[int] = ...,
+                 oneof_nested_message: Optional[TestAllTypesProto2.NestedMessage] = ...,
+                 oneof_string: Optional[Text] = ...,
+                 oneof_bytes: Optional[str] = ...,
+                 oneof_bool: Optional[bool] = ...,
+                 oneof_uint64: Optional[int] = ...,
+                 oneof_float: Optional[float] = ...,
+                 oneof_double: Optional[float] = ...,
+                 oneof_enum: Optional[TestAllTypesProto2.NestedEnum] = ...,
+                 data: Optional[TestAllTypesProto2.Data] = ...,
+                 fieldname1: Optional[int] = ...,
+                 field_name2: Optional[int] = ...,
+                 _field_name3: Optional[int] = ...,
+                 field__name4_: Optional[int] = ...,
+                 field0name5: Optional[int] = ...,
+                 field_0_name6: Optional[int] = ...,
+                 fieldName7: Optional[int] = ...,
+                 FieldName8: Optional[int] = ...,
+                 field_Name9: Optional[int] = ...,
+                 Field_Name10: Optional[int] = ...,
+                 FIELD_NAME11: Optional[int] = ...,
+                 FIELD_name12: Optional[int] = ...,
+                 __field_name13: Optional[int] = ...,
+                 __Field_name14: Optional[int] = ...,
+                 field__name15: Optional[int] = ...,
+                 field__Name16: Optional[int] = ...,
+                 field_name17__: Optional[int] = ...,
+                 Field_name18__: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestAllTypesProto2: ...
+
+
+class ForeignMessageProto2(Message):
+    c = ...  # type: int
+
+    def __init__(self,
+                 c: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> ForeignMessageProto2: ...

third_party/2/google/protobuf/test_messages_proto3_pb2.pyi

@@ -0,0 +1,700 @@
+from google.protobuf.any_pb2 import (
+    Any,
+)
+from google.protobuf.duration_pb2 import (
+    Duration,
+)
+from google.protobuf.field_mask_pb2 import (
+    FieldMask,
+)
+from google.protobuf.internal.containers import (
+    RepeatedCompositeFieldContainer,
+    RepeatedScalarFieldContainer,
+)
+from google.protobuf.message import (
+    Message,
+)
+from google.protobuf.struct_pb2 import (
+    Struct,
+    Value,
+)
+from google.protobuf.timestamp_pb2 import (
+    Timestamp,
+)
+from google.protobuf.wrappers_pb2 import (
+    BoolValue,
+    BytesValue,
+    DoubleValue,
+    FloatValue,
+    Int32Value,
+    Int64Value,
+    StringValue,
+    UInt32Value,
+    UInt64Value,
+)
+from typing import (
+    Iterable,
+    List,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Text,
+    Tuple,
+    cast,
+)
+
+
+class ForeignEnum(int):
+
+    @classmethod
+    def Name(cls, number: int) -> str: ...
+
+    @classmethod
+    def Value(cls, name: str) -> ForeignEnum: ...
+
+    @classmethod
+    def keys(cls) -> List[str]: ...
+
+    @classmethod
+    def values(cls) -> List[ForeignEnum]: ...
+
+    @classmethod
+    def items(cls) -> List[Tuple[str, ForeignEnum]]: ...
+FOREIGN_FOO: ForeignEnum
+FOREIGN_BAR: ForeignEnum
+FOREIGN_BAZ: ForeignEnum
+
+
+class TestAllTypesProto3(Message):
+
+    class NestedEnum(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> TestAllTypesProto3.NestedEnum: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[TestAllTypesProto3.NestedEnum]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str, TestAllTypesProto3.NestedEnum]]: ...
+    FOO: NestedEnum
+    BAR: NestedEnum
+    BAZ: NestedEnum
+    NEG: NestedEnum
+
+    class NestedMessage(Message):
+        a = ...  # type: int
+
+        @property
+        def corecursive(self) -> TestAllTypesProto3: ...
+
+        def __init__(self,
+                     a: Optional[int] = ...,
+                     corecursive: Optional[TestAllTypesProto3] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.NestedMessage: ...
+
+    class MapInt32Int32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapInt32Int32Entry: ...
+
+    class MapInt64Int64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapInt64Int64Entry: ...
+
+    class MapUint32Uint32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapUint32Uint32Entry: ...
+
+    class MapUint64Uint64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapUint64Uint64Entry: ...
+
+    class MapSint32Sint32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapSint32Sint32Entry: ...
+
+    class MapSint64Sint64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapSint64Sint64Entry: ...
+
+    class MapFixed32Fixed32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapFixed32Fixed32Entry: ...
+
+    class MapFixed64Fixed64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapFixed64Fixed64Entry: ...
+
+    class MapSfixed32Sfixed32Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapSfixed32Sfixed32Entry: ...
+
+    class MapSfixed64Sfixed64Entry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapSfixed64Sfixed64Entry: ...
+
+    class MapInt32FloatEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: float
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[float] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapInt32FloatEntry: ...
+
+    class MapInt32DoubleEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: float
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[float] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapInt32DoubleEntry: ...
+
+    class MapBoolBoolEntry(Message):
+        key = ...  # type: bool
+        value = ...  # type: bool
+
+        def __init__(self,
+                     key: Optional[bool] = ...,
+                     value: Optional[bool] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapBoolBoolEntry: ...
+
+    class MapStringStringEntry(Message):
+        key = ...  # type: Text
+        value = ...  # type: Text
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[Text] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapStringStringEntry: ...
+
+    class MapStringBytesEntry(Message):
+        key = ...  # type: Text
+        value = ...  # type: str
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[str] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapStringBytesEntry: ...
+
+    class MapStringNestedMessageEntry(Message):
+        key = ...  # type: Text
+
+        @property
+        def value(self) -> TestAllTypesProto3.NestedMessage: ...
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[TestAllTypesProto3.NestedMessage] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapStringNestedMessageEntry: ...
+
+    class MapStringForeignMessageEntry(Message):
+        key = ...  # type: Text
+
+        @property
+        def value(self) -> ForeignMessage: ...
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[ForeignMessage] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapStringForeignMessageEntry: ...
+
+    class MapStringNestedEnumEntry(Message):
+        key = ...  # type: Text
+        value = ...  # type: TestAllTypesProto3.NestedEnum
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[TestAllTypesProto3.NestedEnum] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapStringNestedEnumEntry: ...
+
+    class MapStringForeignEnumEntry(Message):
+        key = ...  # type: Text
+        value = ...  # type: ForeignEnum
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[ForeignEnum] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypesProto3.MapStringForeignEnumEntry: ...
+    optional_int32 = ...  # type: int
+    optional_int64 = ...  # type: int
+    optional_uint32 = ...  # type: int
+    optional_uint64 = ...  # type: int
+    optional_sint32 = ...  # type: int
+    optional_sint64 = ...  # type: int
+    optional_fixed32 = ...  # type: int
+    optional_fixed64 = ...  # type: int
+    optional_sfixed32 = ...  # type: int
+    optional_sfixed64 = ...  # type: int
+    optional_float = ...  # type: float
+    optional_double = ...  # type: float
+    optional_bool = ...  # type: bool
+    optional_string = ...  # type: Text
+    optional_bytes = ...  # type: str
+    optional_nested_enum = ...  # type: TestAllTypesProto3.NestedEnum
+    optional_foreign_enum = ...  # type: ForeignEnum
+    optional_string_piece = ...  # type: Text
+    optional_cord = ...  # type: Text
+    repeated_int32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_int64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_uint32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_uint64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sint32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sint64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_fixed32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_fixed64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sfixed32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sfixed64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_float = ...  # type: RepeatedScalarFieldContainer[float]
+    repeated_double = ...  # type: RepeatedScalarFieldContainer[float]
+    repeated_bool = ...  # type: RepeatedScalarFieldContainer[bool]
+    repeated_string = ...  # type: RepeatedScalarFieldContainer[Text]
+    repeated_bytes = ...  # type: RepeatedScalarFieldContainer[str]
+    repeated_nested_enum = ...  # type: RepeatedScalarFieldContainer[TestAllTypesProto3.NestedEnum]
+    repeated_foreign_enum = ...  # type: RepeatedScalarFieldContainer[ForeignEnum]
+    repeated_string_piece = ...  # type: RepeatedScalarFieldContainer[Text]
+    repeated_cord = ...  # type: RepeatedScalarFieldContainer[Text]
+    oneof_uint32 = ...  # type: int
+    oneof_string = ...  # type: Text
+    oneof_bytes = ...  # type: str
+    oneof_bool = ...  # type: bool
+    oneof_uint64 = ...  # type: int
+    oneof_float = ...  # type: float
+    oneof_double = ...  # type: float
+    oneof_enum = ...  # type: TestAllTypesProto3.NestedEnum
+    fieldname1 = ...  # type: int
+    field_name2 = ...  # type: int
+    _field_name3 = ...  # type: int
+    field__name4_ = ...  # type: int
+    field0name5 = ...  # type: int
+    field_0_name6 = ...  # type: int
+    fieldName7 = ...  # type: int
+    FieldName8 = ...  # type: int
+    field_Name9 = ...  # type: int
+    Field_Name10 = ...  # type: int
+    FIELD_NAME11 = ...  # type: int
+    FIELD_name12 = ...  # type: int
+    __field_name13 = ...  # type: int
+    __Field_name14 = ...  # type: int
+    field__name15 = ...  # type: int
+    field__Name16 = ...  # type: int
+    field_name17__ = ...  # type: int
+    Field_name18__ = ...  # type: int
+
+    @property
+    def optional_nested_message(self) -> TestAllTypesProto3.NestedMessage: ...
+
+    @property
+    def optional_foreign_message(self) -> ForeignMessage: ...
+
+    @property
+    def recursive_message(self) -> TestAllTypesProto3: ...
+
+    @property
+    def repeated_nested_message(self) -> RepeatedCompositeFieldContainer[TestAllTypesProto3.NestedMessage]: ...
+
+    @property
+    def repeated_foreign_message(self) -> RepeatedCompositeFieldContainer[ForeignMessage]: ...
+
+    @property
+    def map_int32_int32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_int64_int64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_uint32_uint32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_uint64_uint64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_sint32_sint32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_sint64_sint64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_fixed32_fixed32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_fixed64_fixed64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_sfixed32_sfixed32(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_sfixed64_sfixed64(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def map_int32_float(self) -> MutableMapping[int, float]: ...
+
+    @property
+    def map_int32_double(self) -> MutableMapping[int, float]: ...
+
+    @property
+    def map_bool_bool(self) -> MutableMapping[bool, bool]: ...
+
+    @property
+    def map_string_string(self) -> MutableMapping[Text, Text]: ...
+
+    @property
+    def map_string_bytes(self) -> MutableMapping[Text, str]: ...
+
+    @property
+    def map_string_nested_message(self) -> MutableMapping[Text, TestAllTypesProto3.NestedMessage]: ...
+
+    @property
+    def map_string_foreign_message(self) -> MutableMapping[Text, ForeignMessage]: ...
+
+    @property
+    def map_string_nested_enum(self) -> MutableMapping[Text, TestAllTypesProto3.NestedEnum]: ...
+
+    @property
+    def map_string_foreign_enum(self) -> MutableMapping[Text, ForeignEnum]: ...
+
+    @property
+    def oneof_nested_message(self) -> TestAllTypesProto3.NestedMessage: ...
+
+    @property
+    def optional_bool_wrapper(self) -> BoolValue: ...
+
+    @property
+    def optional_int32_wrapper(self) -> Int32Value: ...
+
+    @property
+    def optional_int64_wrapper(self) -> Int64Value: ...
+
+    @property
+    def optional_uint32_wrapper(self) -> UInt32Value: ...
+
+    @property
+    def optional_uint64_wrapper(self) -> UInt64Value: ...
+
+    @property
+    def optional_float_wrapper(self) -> FloatValue: ...
+
+    @property
+    def optional_double_wrapper(self) -> DoubleValue: ...
+
+    @property
+    def optional_string_wrapper(self) -> StringValue: ...
+
+    @property
+    def optional_bytes_wrapper(self) -> BytesValue: ...
+
+    @property
+    def repeated_bool_wrapper(self) -> RepeatedCompositeFieldContainer[BoolValue]: ...
+
+    @property
+    def repeated_int32_wrapper(self) -> RepeatedCompositeFieldContainer[Int32Value]: ...
+
+    @property
+    def repeated_int64_wrapper(self) -> RepeatedCompositeFieldContainer[Int64Value]: ...
+
+    @property
+    def repeated_uint32_wrapper(self) -> RepeatedCompositeFieldContainer[UInt32Value]: ...
+
+    @property
+    def repeated_uint64_wrapper(self) -> RepeatedCompositeFieldContainer[UInt64Value]: ...
+
+    @property
+    def repeated_float_wrapper(self) -> RepeatedCompositeFieldContainer[FloatValue]: ...
+
+    @property
+    def repeated_double_wrapper(self) -> RepeatedCompositeFieldContainer[DoubleValue]: ...
+
+    @property
+    def repeated_string_wrapper(self) -> RepeatedCompositeFieldContainer[StringValue]: ...
+
+    @property
+    def repeated_bytes_wrapper(self) -> RepeatedCompositeFieldContainer[BytesValue]: ...
+
+    @property
+    def optional_duration(self) -> Duration: ...
+
+    @property
+    def optional_timestamp(self) -> Timestamp: ...
+
+    @property
+    def optional_field_mask(self) -> FieldMask: ...
+
+    @property
+    def optional_struct(self) -> Struct: ...
+
+    @property
+    def optional_any(self) -> Any: ...
+
+    @property
+    def optional_value(self) -> Value: ...
+
+    @property
+    def repeated_duration(self) -> RepeatedCompositeFieldContainer[Duration]: ...
+
+    @property
+    def repeated_timestamp(self) -> RepeatedCompositeFieldContainer[Timestamp]: ...
+
+    @property
+    def repeated_fieldmask(self) -> RepeatedCompositeFieldContainer[FieldMask]: ...
+
+    @property
+    def repeated_struct(self) -> RepeatedCompositeFieldContainer[Struct]: ...
+
+    @property
+    def repeated_any(self) -> RepeatedCompositeFieldContainer[Any]: ...
+
+    @property
+    def repeated_value(self) -> RepeatedCompositeFieldContainer[Value]: ...
+
+    def __init__(self,
+                 optional_int32: Optional[int] = ...,
+                 optional_int64: Optional[int] = ...,
+                 optional_uint32: Optional[int] = ...,
+                 optional_uint64: Optional[int] = ...,
+                 optional_sint32: Optional[int] = ...,
+                 optional_sint64: Optional[int] = ...,
+                 optional_fixed32: Optional[int] = ...,
+                 optional_fixed64: Optional[int] = ...,
+                 optional_sfixed32: Optional[int] = ...,
+                 optional_sfixed64: Optional[int] = ...,
+                 optional_float: Optional[float] = ...,
+                 optional_double: Optional[float] = ...,
+                 optional_bool: Optional[bool] = ...,
+                 optional_string: Optional[Text] = ...,
+                 optional_bytes: Optional[str] = ...,
+                 optional_nested_message: Optional[TestAllTypesProto3.NestedMessage] = ...,
+                 optional_foreign_message: Optional[ForeignMessage] = ...,
+                 optional_nested_enum: Optional[TestAllTypesProto3.NestedEnum] = ...,
+                 optional_foreign_enum: Optional[ForeignEnum] = ...,
+                 optional_string_piece: Optional[Text] = ...,
+                 optional_cord: Optional[Text] = ...,
+                 recursive_message: Optional[TestAllTypesProto3] = ...,
+                 repeated_int32: Optional[Iterable[int]] = ...,
+                 repeated_int64: Optional[Iterable[int]] = ...,
+                 repeated_uint32: Optional[Iterable[int]] = ...,
+                 repeated_uint64: Optional[Iterable[int]] = ...,
+                 repeated_sint32: Optional[Iterable[int]] = ...,
+                 repeated_sint64: Optional[Iterable[int]] = ...,
+                 repeated_fixed32: Optional[Iterable[int]] = ...,
+                 repeated_fixed64: Optional[Iterable[int]] = ...,
+                 repeated_sfixed32: Optional[Iterable[int]] = ...,
+                 repeated_sfixed64: Optional[Iterable[int]] = ...,
+                 repeated_float: Optional[Iterable[float]] = ...,
+                 repeated_double: Optional[Iterable[float]] = ...,
+                 repeated_bool: Optional[Iterable[bool]] = ...,
+                 repeated_string: Optional[Iterable[Text]] = ...,
+                 repeated_bytes: Optional[Iterable[str]] = ...,
+                 repeated_nested_message: Optional[Iterable[TestAllTypesProto3.NestedMessage]] = ...,
+                 repeated_foreign_message: Optional[Iterable[ForeignMessage]] = ...,
+                 repeated_nested_enum: Optional[Iterable[TestAllTypesProto3.NestedEnum]] = ...,
+                 repeated_foreign_enum: Optional[Iterable[ForeignEnum]] = ...,
+                 repeated_string_piece: Optional[Iterable[Text]] = ...,
+                 repeated_cord: Optional[Iterable[Text]] = ...,
+                 map_int32_int32: Optional[Mapping[int, int]]=...,
+                 map_int64_int64: Optional[Mapping[int, int]]=...,
+                 map_uint32_uint32: Optional[Mapping[int, int]]=...,
+                 map_uint64_uint64: Optional[Mapping[int, int]]=...,
+                 map_sint32_sint32: Optional[Mapping[int, int]]=...,
+                 map_sint64_sint64: Optional[Mapping[int, int]]=...,
+                 map_fixed32_fixed32: Optional[Mapping[int, int]]=...,
+                 map_fixed64_fixed64: Optional[Mapping[int, int]]=...,
+                 map_sfixed32_sfixed32: Optional[Mapping[int, int]]=...,
+                 map_sfixed64_sfixed64: Optional[Mapping[int, int]]=...,
+                 map_int32_float: Optional[Mapping[int, float]]=...,
+                 map_int32_double: Optional[Mapping[int, float]]=...,
+                 map_bool_bool: Optional[Mapping[bool, bool]]=...,
+                 map_string_string: Optional[Mapping[Text, Text]]=...,
+                 map_string_bytes: Optional[Mapping[Text, str]]=...,
+                 map_string_nested_message: Optional[Mapping[Text, TestAllTypesProto3.NestedMessage]]=...,
+                 map_string_foreign_message: Optional[Mapping[Text, ForeignMessage]]=...,
+                 map_string_nested_enum: Optional[Mapping[Text, TestAllTypesProto3.NestedEnum]]=...,
+                 map_string_foreign_enum: Optional[Mapping[Text, ForeignEnum]]=...,
+                 oneof_uint32: Optional[int] = ...,
+                 oneof_nested_message: Optional[TestAllTypesProto3.NestedMessage] = ...,
+                 oneof_string: Optional[Text] = ...,
+                 oneof_bytes: Optional[str] = ...,
+                 oneof_bool: Optional[bool] = ...,
+                 oneof_uint64: Optional[int] = ...,
+                 oneof_float: Optional[float] = ...,
+                 oneof_double: Optional[float] = ...,
+                 oneof_enum: Optional[TestAllTypesProto3.NestedEnum] = ...,
+                 optional_bool_wrapper: Optional[BoolValue] = ...,
+                 optional_int32_wrapper: Optional[Int32Value] = ...,
+                 optional_int64_wrapper: Optional[Int64Value] = ...,
+                 optional_uint32_wrapper: Optional[UInt32Value] = ...,
+                 optional_uint64_wrapper: Optional[UInt64Value] = ...,
+                 optional_float_wrapper: Optional[FloatValue] = ...,
+                 optional_double_wrapper: Optional[DoubleValue] = ...,
+                 optional_string_wrapper: Optional[StringValue] = ...,
+                 optional_bytes_wrapper: Optional[BytesValue] = ...,
+                 repeated_bool_wrapper: Optional[Iterable[BoolValue]] = ...,
+                 repeated_int32_wrapper: Optional[Iterable[Int32Value]] = ...,
+                 repeated_int64_wrapper: Optional[Iterable[Int64Value]] = ...,
+                 repeated_uint32_wrapper: Optional[Iterable[UInt32Value]] = ...,
+                 repeated_uint64_wrapper: Optional[Iterable[UInt64Value]] = ...,
+                 repeated_float_wrapper: Optional[Iterable[FloatValue]] = ...,
+                 repeated_double_wrapper: Optional[Iterable[DoubleValue]] = ...,
+                 repeated_string_wrapper: Optional[Iterable[StringValue]] = ...,
+                 repeated_bytes_wrapper: Optional[Iterable[BytesValue]] = ...,
+                 optional_duration: Optional[Duration] = ...,
+                 optional_timestamp: Optional[Timestamp] = ...,
+                 optional_field_mask: Optional[FieldMask] = ...,
+                 optional_struct: Optional[Struct] = ...,
+                 optional_any: Optional[Any] = ...,
+                 optional_value: Optional[Value] = ...,
+                 repeated_duration: Optional[Iterable[Duration]] = ...,
+                 repeated_timestamp: Optional[Iterable[Timestamp]] = ...,
+                 repeated_fieldmask: Optional[Iterable[FieldMask]] = ...,
+                 repeated_struct: Optional[Iterable[Struct]] = ...,
+                 repeated_any: Optional[Iterable[Any]] = ...,
+                 repeated_value: Optional[Iterable[Value]] = ...,
+                 fieldname1: Optional[int] = ...,
+                 field_name2: Optional[int] = ...,
+                 _field_name3: Optional[int] = ...,
+                 field__name4_: Optional[int] = ...,
+                 field0name5: Optional[int] = ...,
+                 field_0_name6: Optional[int] = ...,
+                 fieldName7: Optional[int] = ...,
+                 FieldName8: Optional[int] = ...,
+                 field_Name9: Optional[int] = ...,
+                 Field_Name10: Optional[int] = ...,
+                 FIELD_NAME11: Optional[int] = ...,
+                 FIELD_name12: Optional[int] = ...,
+                 __field_name13: Optional[int] = ...,
+                 __Field_name14: Optional[int] = ...,
+                 field__name15: Optional[int] = ...,
+                 field__Name16: Optional[int] = ...,
+                 field_name17__: Optional[int] = ...,
+                 Field_name18__: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestAllTypesProto3: ...
+
+
+class ForeignMessage(Message):
+    c = ...  # type: int
+
+    def __init__(self,
+                 c: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> ForeignMessage: ...

third_party/2/google/protobuf/timestamp_pb2.pyi

@@ -0,0 +1,19 @@
+from google.protobuf.message import (
+    Message,
+)
+from typing import (
+    Optional,
+)
+
+
+class Timestamp(Message):
+    seconds = ...  # type: int
+    nanos = ...  # type: int
+
+    def __init__(self,
+                 seconds: Optional[int] = ...,
+                 nanos: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> Timestamp: ...

third_party/2/google/protobuf/type_pb2.pyi

@@ -0,0 +1,215 @@
+from google.protobuf.any_pb2 import (
+    Any,
+)
+from google.protobuf.internal.containers import (
+    RepeatedCompositeFieldContainer,
+    RepeatedScalarFieldContainer,
+)
+from google.protobuf.message import (
+    Message,
+)
+from google.protobuf.source_context_pb2 import (
+    SourceContext,
+)
+from typing import (
+    Iterable,
+    List,
+    Optional,
+    Text,
+    Tuple,
+    cast,
+)
+
+
+class Syntax(int):
+
+    @classmethod
+    def Name(cls, number: int) -> str: ...
+
+    @classmethod
+    def Value(cls, name: str) -> Syntax: ...
+
+    @classmethod
+    def keys(cls) -> List[str]: ...
+
+    @classmethod
+    def values(cls) -> List[Syntax]: ...
+
+    @classmethod
+    def items(cls) -> List[Tuple[str, Syntax]]: ...
+
+
+SYNTAX_PROTO2: Syntax
+SYNTAX_PROTO3: Syntax
+
+
+class Type(Message):
+    name = ...  # type: Text
+    oneofs = ...  # type: RepeatedScalarFieldContainer[Text]
+    syntax = ...  # type: Syntax
+
+    @property
+    def fields(self) -> RepeatedCompositeFieldContainer[Field]: ...
+
+    @property
+    def options(self) -> RepeatedCompositeFieldContainer[Option]: ...
+
+    @property
+    def source_context(self) -> SourceContext: ...
+
+    def __init__(self,
+                 name: Optional[Text] = ...,
+                 fields: Optional[Iterable[Field]] = ...,
+                 oneofs: Optional[Iterable[Text]] = ...,
+                 options: Optional[Iterable[Option]] = ...,
+                 source_context: Optional[SourceContext] = ...,
+                 syntax: Optional[Syntax] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> Type: ...
+
+
+class Field(Message):
+
+    class Kind(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> Field.Kind: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[Field.Kind]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str, Field.Kind]]: ...
+    TYPE_UNKNOWN: Kind
+    TYPE_DOUBLE: Kind
+    TYPE_FLOAT: Kind
+    TYPE_INT64: Kind
+    TYPE_UINT64: Kind
+    TYPE_INT32: Kind
+    TYPE_FIXED64: Kind
+    TYPE_FIXED32: Kind
+    TYPE_BOOL: Kind
+    TYPE_STRING: Kind
+    TYPE_GROUP: Kind
+    TYPE_MESSAGE: Kind
+    TYPE_BYTES: Kind
+    TYPE_UINT32: Kind
+    TYPE_ENUM: Kind
+    TYPE_SFIXED32: Kind
+    TYPE_SFIXED64: Kind
+    TYPE_SINT32: Kind
+    TYPE_SINT64: Kind
+
+    class Cardinality(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> Field.Cardinality: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[Field.Cardinality]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str, Field.Cardinality]]: ...
+    CARDINALITY_UNKNOWN: Cardinality
+    CARDINALITY_OPTIONAL: Cardinality
+    CARDINALITY_REQUIRED: Cardinality
+    CARDINALITY_REPEATED: Cardinality
+    kind = ...  # type: Field.Kind
+    cardinality = ...  # type: Field.Cardinality
+    number = ...  # type: int
+    name = ...  # type: Text
+    type_url = ...  # type: Text
+    oneof_index = ...  # type: int
+    packed = ...  # type: bool
+    json_name = ...  # type: Text
+    default_value = ...  # type: Text
+
+    @property
+    def options(self) -> RepeatedCompositeFieldContainer[Option]: ...
+
+    def __init__(self,
+                 kind: Optional[Field.Kind] = ...,
+                 cardinality: Optional[Field.Cardinality] = ...,
+                 number: Optional[int] = ...,
+                 name: Optional[Text] = ...,
+                 type_url: Optional[Text] = ...,
+                 oneof_index: Optional[int] = ...,
+                 packed: Optional[bool] = ...,
+                 options: Optional[Iterable[Option]] = ...,
+                 json_name: Optional[Text] = ...,
+                 default_value: Optional[Text] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> Field: ...
+
+
+class Enum(Message):
+    name = ...  # type: Text
+    syntax = ...  # type: Syntax
+
+    @property
+    def enumvalue(self) -> RepeatedCompositeFieldContainer[EnumValue]: ...
+
+    @property
+    def options(self) -> RepeatedCompositeFieldContainer[Option]: ...
+
+    @property
+    def source_context(self) -> SourceContext: ...
+
+    def __init__(self,
+                 name: Optional[Text] = ...,
+                 enumvalue: Optional[Iterable[EnumValue]] = ...,
+                 options: Optional[Iterable[Option]] = ...,
+                 source_context: Optional[SourceContext] = ...,
+                 syntax: Optional[Syntax] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> Enum: ...
+
+
+class EnumValue(Message):
+    name = ...  # type: Text
+    number = ...  # type: int
+
+    @property
+    def options(self) -> RepeatedCompositeFieldContainer[Option]: ...
+
+    def __init__(self,
+                 name: Optional[Text] = ...,
+                 number: Optional[int] = ...,
+                 options: Optional[Iterable[Option]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> EnumValue: ...
+
+
+class Option(Message):
+    name = ...  # type: Text
+
+    @property
+    def value(self) -> Any: ...
+
+    def __init__(self,
+                 name: Optional[Text] = ...,
+                 value: Optional[Any] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> Option: ...

third_party/2/google/protobuf/unittest_arena_pb2.pyi

@@ -0,0 +1,43 @@
+from google.protobuf.internal.containers import (
+    RepeatedCompositeFieldContainer,
+)
+from google.protobuf.message import (
+    Message,
+)
+from google.protobuf.unittest_no_arena_import_pb2 import (
+    ImportNoArenaNestedMessage,
+)
+from typing import (
+    Iterable,
+    Optional,
+)
+
+
+class NestedMessage(Message):
+    d = ...  # type: int
+
+    def __init__(self,
+                 d: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> NestedMessage: ...
+
+
+class ArenaMessage(Message):
+
+    @property
+    def repeated_nested_message(
+        self) -> RepeatedCompositeFieldContainer[NestedMessage]: ...
+
+    @property
+    def repeated_import_no_arena_message(
+        self) -> RepeatedCompositeFieldContainer[ImportNoArenaNestedMessage]: ...
+
+    def __init__(self,
+                 repeated_nested_message: Optional[Iterable[NestedMessage]] = ...,
+                 repeated_import_no_arena_message: Optional[Iterable[ImportNoArenaNestedMessage]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> ArenaMessage: ...

third_party/2/google/protobuf/unittest_custom_options_pb2.pyi

@@ -0,0 +1,472 @@
+from google.protobuf.descriptor_pb2 import (
+    FileOptions,
+)
+from google.protobuf.internal.containers import (
+    RepeatedCompositeFieldContainer,
+    RepeatedScalarFieldContainer,
+)
+from google.protobuf.message import (
+    Message,
+)
+from typing import (
+    Iterable,
+    List,
+    Optional,
+    Text,
+    Tuple,
+    cast,
+)
+
+
+class MethodOpt1(int):
+
+    @classmethod
+    def Name(cls, number: int) -> str: ...
+
+    @classmethod
+    def Value(cls, name: str) -> MethodOpt1: ...
+
+    @classmethod
+    def keys(cls) -> List[str]: ...
+
+    @classmethod
+    def values(cls) -> List[MethodOpt1]: ...
+
+    @classmethod
+    def items(cls) -> List[Tuple[str, MethodOpt1]]: ...
+
+
+METHODOPT1_VAL1: MethodOpt1
+METHODOPT1_VAL2: MethodOpt1
+
+
+class AggregateEnum(int):
+
+    @classmethod
+    def Name(cls, number: int) -> str: ...
+
+    @classmethod
+    def Value(cls, name: str) -> AggregateEnum: ...
+
+    @classmethod
+    def keys(cls) -> List[str]: ...
+
+    @classmethod
+    def values(cls) -> List[AggregateEnum]: ...
+
+    @classmethod
+    def items(cls) -> List[Tuple[str, AggregateEnum]]: ...
+
+
+VALUE: AggregateEnum
+
+
+class TestMessageWithCustomOptions(Message):
+
+    class AnEnum(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> TestMessageWithCustomOptions.AnEnum: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[TestMessageWithCustomOptions.AnEnum]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str,
+                                     TestMessageWithCustomOptions.AnEnum]]: ...
+    ANENUM_VAL1: AnEnum
+    ANENUM_VAL2: AnEnum
+    field1 = ...  # type: Text
+    oneof_field = ...  # type: int
+
+    def __init__(self,
+                 field1: Optional[Text] = ...,
+                 oneof_field: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestMessageWithCustomOptions: ...
+
+
+class CustomOptionFooRequest(Message):
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> CustomOptionFooRequest: ...
+
+
+class CustomOptionFooResponse(Message):
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> CustomOptionFooResponse: ...
+
+
+class CustomOptionFooClientMessage(Message):
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> CustomOptionFooClientMessage: ...
+
+
+class CustomOptionFooServerMessage(Message):
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> CustomOptionFooServerMessage: ...
+
+
+class DummyMessageContainingEnum(Message):
+
+    class TestEnumType(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> DummyMessageContainingEnum.TestEnumType: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[DummyMessageContainingEnum.TestEnumType]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str,
+                                     DummyMessageContainingEnum.TestEnumType]]: ...
+    TEST_OPTION_ENUM_TYPE1: TestEnumType
+    TEST_OPTION_ENUM_TYPE2: TestEnumType
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> DummyMessageContainingEnum: ...
+
+
+class DummyMessageInvalidAsOptionType(Message):
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> DummyMessageInvalidAsOptionType: ...
+
+
+class CustomOptionMinIntegerValues(Message):
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> CustomOptionMinIntegerValues: ...
+
+
+class CustomOptionMaxIntegerValues(Message):
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> CustomOptionMaxIntegerValues: ...
+
+
+class CustomOptionOtherValues(Message):
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> CustomOptionOtherValues: ...
+
+
+class SettingRealsFromPositiveInts(Message):
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> SettingRealsFromPositiveInts: ...
+
+
+class SettingRealsFromNegativeInts(Message):
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> SettingRealsFromNegativeInts: ...
+
+
+class ComplexOptionType1(Message):
+    foo = ...  # type: int
+    foo2 = ...  # type: int
+    foo3 = ...  # type: int
+    foo4 = ...  # type: RepeatedScalarFieldContainer[int]
+
+    def __init__(self,
+                 foo: Optional[int] = ...,
+                 foo2: Optional[int] = ...,
+                 foo3: Optional[int] = ...,
+                 foo4: Optional[Iterable[int]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> ComplexOptionType1: ...
+
+
+class ComplexOptionType2(Message):
+
+    class ComplexOptionType4(Message):
+        waldo = ...  # type: int
+
+        def __init__(self,
+                     waldo: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> ComplexOptionType2.ComplexOptionType4: ...
+    baz = ...  # type: int
+
+    @property
+    def bar(self) -> ComplexOptionType1: ...
+
+    @property
+    def fred(self) -> ComplexOptionType2.ComplexOptionType4: ...
+
+    @property
+    def barney(
+        self) -> RepeatedCompositeFieldContainer[ComplexOptionType2.ComplexOptionType4]: ...
+
+    def __init__(self,
+                 bar: Optional[ComplexOptionType1] = ...,
+                 baz: Optional[int] = ...,
+                 fred: Optional[ComplexOptionType2.ComplexOptionType4] = ...,
+                 barney: Optional[Iterable[ComplexOptionType2.ComplexOptionType4]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> ComplexOptionType2: ...
+
+
+class ComplexOptionType3(Message):
+
+    class ComplexOptionType5(Message):
+        plugh = ...  # type: int
+
+        def __init__(self,
+                     plugh: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(
+            cls, s: str) -> ComplexOptionType3.ComplexOptionType5: ...
+    qux = ...  # type: int
+
+    @property
+    def complexoptiontype5(self) -> ComplexOptionType3.ComplexOptionType5: ...
+
+    def __init__(self,
+                 qux: Optional[int] = ...,
+                 complexoptiontype5: Optional[ComplexOptionType3.ComplexOptionType5] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> ComplexOptionType3: ...
+
+
+class ComplexOpt6(Message):
+    xyzzy = ...  # type: int
+
+    def __init__(self,
+                 xyzzy: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> ComplexOpt6: ...
+
+
+class VariousComplexOptions(Message):
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> VariousComplexOptions: ...
+
+
+class AggregateMessageSet(Message):
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> AggregateMessageSet: ...
+
+
+class AggregateMessageSetElement(Message):
+    s = ...  # type: Text
+
+    def __init__(self,
+                 s: Optional[Text] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> AggregateMessageSetElement: ...
+
+
+class Aggregate(Message):
+    i = ...  # type: int
+    s = ...  # type: Text
+
+    @property
+    def sub(self) -> Aggregate: ...
+
+    @property
+    def file(self) -> FileOptions: ...
+
+    @property
+    def mset(self) -> AggregateMessageSet: ...
+
+    def __init__(self,
+                 i: Optional[int] = ...,
+                 s: Optional[Text] = ...,
+                 sub: Optional[Aggregate] = ...,
+                 file: Optional[FileOptions] = ...,
+                 mset: Optional[AggregateMessageSet] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> Aggregate: ...
+
+
+class AggregateMessage(Message):
+    fieldname = ...  # type: int
+
+    def __init__(self,
+                 fieldname: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> AggregateMessage: ...
+
+
+class NestedOptionType(Message):
+
+    class NestedEnum(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> NestedOptionType.NestedEnum: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[NestedOptionType.NestedEnum]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str, NestedOptionType.NestedEnum]]: ...
+    NESTED_ENUM_VALUE: NestedEnum
+
+    class NestedMessage(Message):
+        nested_field = ...  # type: int
+
+        def __init__(self,
+                     nested_field: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> NestedOptionType.NestedMessage: ...
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> NestedOptionType: ...
+
+
+class OldOptionType(Message):
+
+    class TestEnum(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> OldOptionType.TestEnum: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[OldOptionType.TestEnum]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str, OldOptionType.TestEnum]]: ...
+    OLD_VALUE: TestEnum
+    value = ...  # type: OldOptionType.TestEnum
+
+    def __init__(self,
+                 value: OldOptionType.TestEnum,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> OldOptionType: ...
+
+
+class NewOptionType(Message):
+
+    class TestEnum(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> NewOptionType.TestEnum: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[NewOptionType.TestEnum]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str, NewOptionType.TestEnum]]: ...
+    OLD_VALUE: TestEnum
+    NEW_VALUE: TestEnum
+    value = ...  # type: NewOptionType.TestEnum
+
+    def __init__(self,
+                 value: NewOptionType.TestEnum,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> NewOptionType: ...
+
+
+class TestMessageWithRequiredEnumOption(Message):
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestMessageWithRequiredEnumOption: ...

third_party/2/google/protobuf/unittest_import_pb2.pyi

@@ -0,0 +1,66 @@
+from google.protobuf.message import (
+    Message,
+)
+from typing import (
+    List,
+    Optional,
+    Tuple,
+    cast,
+)
+
+
+class ImportEnum(int):
+
+    @classmethod
+    def Name(cls, number: int) -> str: ...
+
+    @classmethod
+    def Value(cls, name: str) -> ImportEnum: ...
+
+    @classmethod
+    def keys(cls) -> List[str]: ...
+
+    @classmethod
+    def values(cls) -> List[ImportEnum]: ...
+
+    @classmethod
+    def items(cls) -> List[Tuple[str, ImportEnum]]: ...
+
+
+IMPORT_FOO: ImportEnum
+IMPORT_BAR: ImportEnum
+IMPORT_BAZ: ImportEnum
+
+
+class ImportEnumForMap(int):
+
+    @classmethod
+    def Name(cls, number: int) -> str: ...
+
+    @classmethod
+    def Value(cls, name: str) -> ImportEnumForMap: ...
+
+    @classmethod
+    def keys(cls) -> List[str]: ...
+
+    @classmethod
+    def values(cls) -> List[ImportEnumForMap]: ...
+
+    @classmethod
+    def items(cls) -> List[Tuple[str, ImportEnumForMap]]: ...
+
+
+UNKNOWN: ImportEnumForMap
+FOO: ImportEnumForMap
+BAR: ImportEnumForMap
+
+
+class ImportMessage(Message):
+    d = ...  # type: int
+
+    def __init__(self,
+                 d: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> ImportMessage: ...

third_party/2/google/protobuf/unittest_import_public_pb2.pyi

@@ -0,0 +1,17 @@
+from google.protobuf.message import (
+    Message,
+)
+from typing import (
+    Optional,
+)
+
+
+class PublicImportMessage(Message):
+    e = ...  # type: int
+
+    def __init__(self,
+                 e: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> PublicImportMessage: ...

third_party/2/google/protobuf/unittest_mset_pb2.pyi

@@ -0,0 +1,75 @@
+from google.protobuf.internal.containers import (
+    RepeatedCompositeFieldContainer,
+)
+from google.protobuf.message import (
+    Message,
+)
+from google.protobuf.unittest_mset_wire_format_pb2 import (
+    TestMessageSet,
+)
+import builtins
+from typing import (
+    Iterable,
+    Optional,
+    Text,
+)
+
+
+class TestMessageSetContainer(Message):
+
+    @property
+    def message_set(self) -> TestMessageSet: ...
+
+    def __init__(self,
+                 message_set: Optional[TestMessageSet] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestMessageSetContainer: ...
+
+
+class TestMessageSetExtension1(Message):
+    i = ...  # type: int
+
+    def __init__(self,
+                 i: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestMessageSetExtension1: ...
+
+
+class TestMessageSetExtension2(Message):
+    str = ...  # type: Text
+
+    def __init__(self,
+                 str: Optional[Text] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: builtins.str) -> TestMessageSetExtension2: ...
+
+
+class RawMessageSet(Message):
+
+    class Item(Message):
+        type_id = ...  # type: int
+        message = ...  # type: str
+
+        def __init__(self,
+                     type_id: int,
+                     message: str,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> RawMessageSet.Item: ...
+
+    @property
+    def item(self) -> RepeatedCompositeFieldContainer[RawMessageSet.Item]: ...
+
+    def __init__(self,
+                 item: Optional[Iterable[RawMessageSet.Item]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> RawMessageSet: ...

third_party/2/google/protobuf/unittest_mset_wire_format_pb2.pyi

@@ -0,0 +1,28 @@
+from google.protobuf.message import (
+    Message,
+)
+from typing import (
+    Optional,
+)
+
+
+class TestMessageSet(Message):
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestMessageSet: ...
+
+
+class TestMessageSetWireFormatContainer(Message):
+
+    @property
+    def message_set(self) -> TestMessageSet: ...
+
+    def __init__(self,
+                 message_set: Optional[TestMessageSet] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestMessageSetWireFormatContainer: ...

third_party/2/google/protobuf/unittest_no_arena_import_pb2.pyi

@@ -0,0 +1,17 @@
+from google.protobuf.message import (
+    Message,
+)
+from typing import (
+    Optional,
+)
+
+
+class ImportNoArenaNestedMessage(Message):
+    d = ...  # type: int
+
+    def __init__(self,
+                 d: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> ImportNoArenaNestedMessage: ...

third_party/2/google/protobuf/unittest_no_arena_pb2.pyi

@@ -0,0 +1,315 @@
+from google.protobuf.internal.containers import (
+    RepeatedCompositeFieldContainer,
+    RepeatedScalarFieldContainer,
+)
+from google.protobuf.message import (
+    Message,
+)
+from google.protobuf.unittest_arena_pb2 import (
+    ArenaMessage,
+)
+from google.protobuf.unittest_import_pb2 import (
+    ImportEnum,
+    ImportMessage,
+)
+from google.protobuf.unittest_import_public_pb2 import (
+    PublicImportMessage,
+)
+from typing import (
+    Iterable,
+    List,
+    Optional,
+    Text,
+    Tuple,
+    cast,
+)
+
+
+class ForeignEnum(int):
+
+    @classmethod
+    def Name(cls, number: int) -> str: ...
+
+    @classmethod
+    def Value(cls, name: str) -> ForeignEnum: ...
+
+    @classmethod
+    def keys(cls) -> List[str]: ...
+
+    @classmethod
+    def values(cls) -> List[ForeignEnum]: ...
+
+    @classmethod
+    def items(cls) -> List[Tuple[str, ForeignEnum]]: ...
+
+
+FOREIGN_FOO: ForeignEnum
+FOREIGN_BAR: ForeignEnum
+FOREIGN_BAZ: ForeignEnum
+
+
+class TestAllTypes(Message):
+
+    class NestedEnum(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> TestAllTypes.NestedEnum: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[TestAllTypes.NestedEnum]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str, TestAllTypes.NestedEnum]]: ...
+    FOO: NestedEnum
+    BAR: NestedEnum
+    BAZ: NestedEnum
+    NEG: NestedEnum
+
+    class NestedMessage(Message):
+        bb = ...  # type: int
+
+        def __init__(self,
+                     bb: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypes.NestedMessage: ...
+
+    class OptionalGroup(Message):
+        a = ...  # type: int
+
+        def __init__(self,
+                     a: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypes.OptionalGroup: ...
+
+    class RepeatedGroup(Message):
+        a = ...  # type: int
+
+        def __init__(self,
+                     a: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypes.RepeatedGroup: ...
+    optional_int32 = ...  # type: int
+    optional_int64 = ...  # type: int
+    optional_uint32 = ...  # type: int
+    optional_uint64 = ...  # type: int
+    optional_sint32 = ...  # type: int
+    optional_sint64 = ...  # type: int
+    optional_fixed32 = ...  # type: int
+    optional_fixed64 = ...  # type: int
+    optional_sfixed32 = ...  # type: int
+    optional_sfixed64 = ...  # type: int
+    optional_float = ...  # type: float
+    optional_double = ...  # type: float
+    optional_bool = ...  # type: bool
+    optional_string = ...  # type: Text
+    optional_bytes = ...  # type: str
+    optional_nested_enum = ...  # type: TestAllTypes.NestedEnum
+    optional_foreign_enum = ...  # type: ForeignEnum
+    optional_import_enum = ...  # type: ImportEnum
+    optional_string_piece = ...  # type: Text
+    optional_cord = ...  # type: Text
+    repeated_int32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_int64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_uint32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_uint64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sint32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sint64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_fixed32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_fixed64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sfixed32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sfixed64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_float = ...  # type: RepeatedScalarFieldContainer[float]
+    repeated_double = ...  # type: RepeatedScalarFieldContainer[float]
+    repeated_bool = ...  # type: RepeatedScalarFieldContainer[bool]
+    repeated_string = ...  # type: RepeatedScalarFieldContainer[Text]
+    repeated_bytes = ...  # type: RepeatedScalarFieldContainer[str]
+    repeated_nested_enum = ...  # type: RepeatedScalarFieldContainer[TestAllTypes.NestedEnum]
+    repeated_foreign_enum = ...  # type: RepeatedScalarFieldContainer[ForeignEnum]
+    repeated_import_enum = ...  # type: RepeatedScalarFieldContainer[ImportEnum]
+    repeated_string_piece = ...  # type: RepeatedScalarFieldContainer[Text]
+    repeated_cord = ...  # type: RepeatedScalarFieldContainer[Text]
+    default_int32 = ...  # type: int
+    default_int64 = ...  # type: int
+    default_uint32 = ...  # type: int
+    default_uint64 = ...  # type: int
+    default_sint32 = ...  # type: int
+    default_sint64 = ...  # type: int
+    default_fixed32 = ...  # type: int
+    default_fixed64 = ...  # type: int
+    default_sfixed32 = ...  # type: int
+    default_sfixed64 = ...  # type: int
+    default_float = ...  # type: float
+    default_double = ...  # type: float
+    default_bool = ...  # type: bool
+    default_string = ...  # type: Text
+    default_bytes = ...  # type: str
+    default_nested_enum = ...  # type: TestAllTypes.NestedEnum
+    default_foreign_enum = ...  # type: ForeignEnum
+    default_import_enum = ...  # type: ImportEnum
+    default_string_piece = ...  # type: Text
+    default_cord = ...  # type: Text
+    oneof_uint32 = ...  # type: int
+    oneof_string = ...  # type: Text
+    oneof_bytes = ...  # type: str
+
+    @property
+    def optionalgroup(self) -> TestAllTypes.OptionalGroup: ...
+
+    @property
+    def optional_nested_message(self) -> TestAllTypes.NestedMessage: ...
+
+    @property
+    def optional_foreign_message(self) -> ForeignMessage: ...
+
+    @property
+    def optional_import_message(self) -> ImportMessage: ...
+
+    @property
+    def optional_public_import_message(self) -> PublicImportMessage: ...
+
+    @property
+    def optional_message(self) -> TestAllTypes.NestedMessage: ...
+
+    @property
+    def repeatedgroup(
+        self) -> RepeatedCompositeFieldContainer[TestAllTypes.RepeatedGroup]: ...
+
+    @property
+    def repeated_nested_message(
+        self) -> RepeatedCompositeFieldContainer[TestAllTypes.NestedMessage]: ...
+
+    @property
+    def repeated_foreign_message(
+        self) -> RepeatedCompositeFieldContainer[ForeignMessage]: ...
+
+    @property
+    def repeated_import_message(
+        self) -> RepeatedCompositeFieldContainer[ImportMessage]: ...
+
+    @property
+    def repeated_lazy_message(
+        self) -> RepeatedCompositeFieldContainer[TestAllTypes.NestedMessage]: ...
+
+    @property
+    def oneof_nested_message(self) -> TestAllTypes.NestedMessage: ...
+
+    @property
+    def lazy_oneof_nested_message(self) -> TestAllTypes.NestedMessage: ...
+
+    def __init__(self,
+                 optional_int32: Optional[int] = ...,
+                 optional_int64: Optional[int] = ...,
+                 optional_uint32: Optional[int] = ...,
+                 optional_uint64: Optional[int] = ...,
+                 optional_sint32: Optional[int] = ...,
+                 optional_sint64: Optional[int] = ...,
+                 optional_fixed32: Optional[int] = ...,
+                 optional_fixed64: Optional[int] = ...,
+                 optional_sfixed32: Optional[int] = ...,
+                 optional_sfixed64: Optional[int] = ...,
+                 optional_float: Optional[float] = ...,
+                 optional_double: Optional[float] = ...,
+                 optional_bool: Optional[bool] = ...,
+                 optional_string: Optional[Text] = ...,
+                 optional_bytes: Optional[str] = ...,
+                 optionalgroup: Optional[TestAllTypes.OptionalGroup] = ...,
+                 optional_nested_message: Optional[TestAllTypes.NestedMessage] = ...,
+                 optional_foreign_message: Optional[ForeignMessage] = ...,
+                 optional_import_message: Optional[ImportMessage] = ...,
+                 optional_nested_enum: Optional[TestAllTypes.NestedEnum] = ...,
+                 optional_foreign_enum: Optional[ForeignEnum] = ...,
+                 optional_import_enum: Optional[ImportEnum] = ...,
+                 optional_string_piece: Optional[Text] = ...,
+                 optional_cord: Optional[Text] = ...,
+                 optional_public_import_message: Optional[PublicImportMessage] = ...,
+                 optional_message: Optional[TestAllTypes.NestedMessage] = ...,
+                 repeated_int32: Optional[Iterable[int]] = ...,
+                 repeated_int64: Optional[Iterable[int]] = ...,
+                 repeated_uint32: Optional[Iterable[int]] = ...,
+                 repeated_uint64: Optional[Iterable[int]] = ...,
+                 repeated_sint32: Optional[Iterable[int]] = ...,
+                 repeated_sint64: Optional[Iterable[int]] = ...,
+                 repeated_fixed32: Optional[Iterable[int]] = ...,
+                 repeated_fixed64: Optional[Iterable[int]] = ...,
+                 repeated_sfixed32: Optional[Iterable[int]] = ...,
+                 repeated_sfixed64: Optional[Iterable[int]] = ...,
+                 repeated_float: Optional[Iterable[float]] = ...,
+                 repeated_double: Optional[Iterable[float]] = ...,
+                 repeated_bool: Optional[Iterable[bool]] = ...,
+                 repeated_string: Optional[Iterable[Text]] = ...,
+                 repeated_bytes: Optional[Iterable[str]] = ...,
+                 repeatedgroup: Optional[Iterable[TestAllTypes.RepeatedGroup]] = ...,
+                 repeated_nested_message: Optional[Iterable[TestAllTypes.NestedMessage]] = ...,
+                 repeated_foreign_message: Optional[Iterable[ForeignMessage]] = ...,
+                 repeated_import_message: Optional[Iterable[ImportMessage]] = ...,
+                 repeated_nested_enum: Optional[Iterable[TestAllTypes.NestedEnum]] = ...,
+                 repeated_foreign_enum: Optional[Iterable[ForeignEnum]] = ...,
+                 repeated_import_enum: Optional[Iterable[ImportEnum]] = ...,
+                 repeated_string_piece: Optional[Iterable[Text]] = ...,
+                 repeated_cord: Optional[Iterable[Text]] = ...,
+                 repeated_lazy_message: Optional[Iterable[TestAllTypes.NestedMessage]] = ...,
+                 default_int32: Optional[int] = ...,
+                 default_int64: Optional[int] = ...,
+                 default_uint32: Optional[int] = ...,
+                 default_uint64: Optional[int] = ...,
+                 default_sint32: Optional[int] = ...,
+                 default_sint64: Optional[int] = ...,
+                 default_fixed32: Optional[int] = ...,
+                 default_fixed64: Optional[int] = ...,
+                 default_sfixed32: Optional[int] = ...,
+                 default_sfixed64: Optional[int] = ...,
+                 default_float: Optional[float] = ...,
+                 default_double: Optional[float] = ...,
+                 default_bool: Optional[bool] = ...,
+                 default_string: Optional[Text] = ...,
+                 default_bytes: Optional[str] = ...,
+                 default_nested_enum: Optional[TestAllTypes.NestedEnum] = ...,
+                 default_foreign_enum: Optional[ForeignEnum] = ...,
+                 default_import_enum: Optional[ImportEnum] = ...,
+                 default_string_piece: Optional[Text] = ...,
+                 default_cord: Optional[Text] = ...,
+                 oneof_uint32: Optional[int] = ...,
+                 oneof_nested_message: Optional[TestAllTypes.NestedMessage] = ...,
+                 oneof_string: Optional[Text] = ...,
+                 oneof_bytes: Optional[str] = ...,
+                 lazy_oneof_nested_message: Optional[TestAllTypes.NestedMessage] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestAllTypes: ...
+
+
+class ForeignMessage(Message):
+    c = ...  # type: int
+
+    def __init__(self,
+                 c: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> ForeignMessage: ...
+
+
+class TestNoArenaMessage(Message):
+
+    @property
+    def arena_message(self) -> ArenaMessage: ...
+
+    def __init__(self,
+                 arena_message: Optional[ArenaMessage] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestNoArenaMessage: ...

third_party/2/google/protobuf/unittest_no_generic_services_pb2.pyi

@@ -0,0 +1,40 @@
+from google.protobuf.message import (
+    Message,
+)
+from typing import (
+    List,
+    Optional,
+    Tuple,
+    cast,
+)
+
+
+class TestEnum(int):
+    @classmethod
+    def Name(cls, number: int) -> str: ...
+
+    @classmethod
+    def Value(cls, name: str) -> TestEnum: ...
+
+    @classmethod
+    def keys(cls) -> List[str]: ...
+
+    @classmethod
+    def values(cls) -> List[TestEnum]: ...
+
+    @classmethod
+    def items(cls) -> List[Tuple[str, TestEnum]]: ...
+
+
+FOO: TestEnum
+
+
+class TestMessage(Message):
+    a = ...  # type: int
+
+    def __init__(self,
+                 a: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestMessage: ...

third_party/2/google/protobuf/unittest_proto3_arena_pb2.pyi

@@ -0,0 +1,332 @@
+from google.protobuf.internal.containers import (
+    RepeatedCompositeFieldContainer,
+    RepeatedScalarFieldContainer,
+)
+from google.protobuf.message import (
+    Message,
+)
+from google.protobuf.unittest_import_pb2 import (
+    ImportMessage,
+)
+from google.protobuf.unittest_import_public_pb2 import (
+    PublicImportMessage,
+)
+from typing import (
+    Iterable,
+    List,
+    Optional,
+    Text,
+    Tuple,
+    cast,
+)
+
+
+class ForeignEnum(int):
+
+    @classmethod
+    def Name(cls, number: int) -> str: ...
+
+    @classmethod
+    def Value(cls, name: str) -> ForeignEnum: ...
+
+    @classmethod
+    def keys(cls) -> List[str]: ...
+
+    @classmethod
+    def values(cls) -> List[ForeignEnum]: ...
+
+    @classmethod
+    def items(cls) -> List[Tuple[str, ForeignEnum]]: ...
+
+
+FOREIGN_ZERO: ForeignEnum
+FOREIGN_FOO: ForeignEnum
+FOREIGN_BAR: ForeignEnum
+FOREIGN_BAZ: ForeignEnum
+
+
+class TestAllTypes(Message):
+
+    class NestedEnum(int):
+
+        @classmethod
+        def Name(cls, number: int) -> str: ...
+
+        @classmethod
+        def Value(cls, name: str) -> TestAllTypes.NestedEnum: ...
+
+        @classmethod
+        def keys(cls) -> List[str]: ...
+
+        @classmethod
+        def values(cls) -> List[TestAllTypes.NestedEnum]: ...
+
+        @classmethod
+        def items(cls) -> List[Tuple[str, TestAllTypes.NestedEnum]]: ...
+    ZERO: NestedEnum
+    FOO: NestedEnum
+    BAR: NestedEnum
+    BAZ: NestedEnum
+    NEG: NestedEnum
+
+    class NestedMessage(Message):
+        bb = ...  # type: int
+
+        def __init__(self,
+                     bb: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestAllTypes.NestedMessage: ...
+    optional_int32 = ...  # type: int
+    optional_int64 = ...  # type: int
+    optional_uint32 = ...  # type: int
+    optional_uint64 = ...  # type: int
+    optional_sint32 = ...  # type: int
+    optional_sint64 = ...  # type: int
+    optional_fixed32 = ...  # type: int
+    optional_fixed64 = ...  # type: int
+    optional_sfixed32 = ...  # type: int
+    optional_sfixed64 = ...  # type: int
+    optional_float = ...  # type: float
+    optional_double = ...  # type: float
+    optional_bool = ...  # type: bool
+    optional_string = ...  # type: Text
+    optional_bytes = ...  # type: str
+    optional_nested_enum = ...  # type: TestAllTypes.NestedEnum
+    optional_foreign_enum = ...  # type: ForeignEnum
+    optional_string_piece = ...  # type: Text
+    optional_cord = ...  # type: Text
+    repeated_int32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_int64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_uint32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_uint64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sint32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sint64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_fixed32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_fixed64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sfixed32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sfixed64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_float = ...  # type: RepeatedScalarFieldContainer[float]
+    repeated_double = ...  # type: RepeatedScalarFieldContainer[float]
+    repeated_bool = ...  # type: RepeatedScalarFieldContainer[bool]
+    repeated_string = ...  # type: RepeatedScalarFieldContainer[Text]
+    repeated_bytes = ...  # type: RepeatedScalarFieldContainer[str]
+    repeated_nested_enum = ...  # type: RepeatedScalarFieldContainer[TestAllTypes.NestedEnum]
+    repeated_foreign_enum = ...  # type: RepeatedScalarFieldContainer[ForeignEnum]
+    repeated_string_piece = ...  # type: RepeatedScalarFieldContainer[Text]
+    repeated_cord = ...  # type: RepeatedScalarFieldContainer[Text]
+    oneof_uint32 = ...  # type: int
+    oneof_string = ...  # type: Text
+    oneof_bytes = ...  # type: str
+
+    @property
+    def optional_nested_message(self) -> TestAllTypes.NestedMessage: ...
+
+    @property
+    def optional_foreign_message(self) -> ForeignMessage: ...
+
+    @property
+    def optional_import_message(self) -> ImportMessage: ...
+
+    @property
+    def optional_public_import_message(self) -> PublicImportMessage: ...
+
+    @property
+    def optional_lazy_message(self) -> TestAllTypes.NestedMessage: ...
+
+    @property
+    def optional_lazy_import_message(self) -> ImportMessage: ...
+
+    @property
+    def repeated_nested_message(
+        self) -> RepeatedCompositeFieldContainer[TestAllTypes.NestedMessage]: ...
+
+    @property
+    def repeated_foreign_message(
+        self) -> RepeatedCompositeFieldContainer[ForeignMessage]: ...
+
+    @property
+    def repeated_import_message(
+        self) -> RepeatedCompositeFieldContainer[ImportMessage]: ...
+
+    @property
+    def repeated_lazy_message(
+        self) -> RepeatedCompositeFieldContainer[TestAllTypes.NestedMessage]: ...
+
+    @property
+    def oneof_nested_message(self) -> TestAllTypes.NestedMessage: ...
+
+    def __init__(self,
+                 optional_int32: Optional[int] = ...,
+                 optional_int64: Optional[int] = ...,
+                 optional_uint32: Optional[int] = ...,
+                 optional_uint64: Optional[int] = ...,
+                 optional_sint32: Optional[int] = ...,
+                 optional_sint64: Optional[int] = ...,
+                 optional_fixed32: Optional[int] = ...,
+                 optional_fixed64: Optional[int] = ...,
+                 optional_sfixed32: Optional[int] = ...,
+                 optional_sfixed64: Optional[int] = ...,
+                 optional_float: Optional[float] = ...,
+                 optional_double: Optional[float] = ...,
+                 optional_bool: Optional[bool] = ...,
+                 optional_string: Optional[Text] = ...,
+                 optional_bytes: Optional[str] = ...,
+                 optional_nested_message: Optional[TestAllTypes.NestedMessage] = ...,
+                 optional_foreign_message: Optional[ForeignMessage] = ...,
+                 optional_import_message: Optional[ImportMessage] = ...,
+                 optional_nested_enum: Optional[TestAllTypes.NestedEnum] = ...,
+                 optional_foreign_enum: Optional[ForeignEnum] = ...,
+                 optional_string_piece: Optional[Text] = ...,
+                 optional_cord: Optional[Text] = ...,
+                 optional_public_import_message: Optional[PublicImportMessage] = ...,
+                 optional_lazy_message: Optional[TestAllTypes.NestedMessage] = ...,
+                 optional_lazy_import_message: Optional[ImportMessage] = ...,
+                 repeated_int32: Optional[Iterable[int]] = ...,
+                 repeated_int64: Optional[Iterable[int]] = ...,
+                 repeated_uint32: Optional[Iterable[int]] = ...,
+                 repeated_uint64: Optional[Iterable[int]] = ...,
+                 repeated_sint32: Optional[Iterable[int]] = ...,
+                 repeated_sint64: Optional[Iterable[int]] = ...,
+                 repeated_fixed32: Optional[Iterable[int]] = ...,
+                 repeated_fixed64: Optional[Iterable[int]] = ...,
+                 repeated_sfixed32: Optional[Iterable[int]] = ...,
+                 repeated_sfixed64: Optional[Iterable[int]] = ...,
+                 repeated_float: Optional[Iterable[float]] = ...,
+                 repeated_double: Optional[Iterable[float]] = ...,
+                 repeated_bool: Optional[Iterable[bool]] = ...,
+                 repeated_string: Optional[Iterable[Text]] = ...,
+                 repeated_bytes: Optional[Iterable[str]] = ...,
+                 repeated_nested_message: Optional[Iterable[TestAllTypes.NestedMessage]] = ...,
+                 repeated_foreign_message: Optional[Iterable[ForeignMessage]] = ...,
+                 repeated_import_message: Optional[Iterable[ImportMessage]] = ...,
+                 repeated_nested_enum: Optional[Iterable[TestAllTypes.NestedEnum]] = ...,
+                 repeated_foreign_enum: Optional[Iterable[ForeignEnum]] = ...,
+                 repeated_string_piece: Optional[Iterable[Text]] = ...,
+                 repeated_cord: Optional[Iterable[Text]] = ...,
+                 repeated_lazy_message: Optional[Iterable[TestAllTypes.NestedMessage]] = ...,
+                 oneof_uint32: Optional[int] = ...,
+                 oneof_nested_message: Optional[TestAllTypes.NestedMessage] = ...,
+                 oneof_string: Optional[Text] = ...,
+                 oneof_bytes: Optional[str] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestAllTypes: ...
+
+
+class TestPackedTypes(Message):
+    packed_int32 = ...  # type: RepeatedScalarFieldContainer[int]
+    packed_int64 = ...  # type: RepeatedScalarFieldContainer[int]
+    packed_uint32 = ...  # type: RepeatedScalarFieldContainer[int]
+    packed_uint64 = ...  # type: RepeatedScalarFieldContainer[int]
+    packed_sint32 = ...  # type: RepeatedScalarFieldContainer[int]
+    packed_sint64 = ...  # type: RepeatedScalarFieldContainer[int]
+    packed_fixed32 = ...  # type: RepeatedScalarFieldContainer[int]
+    packed_fixed64 = ...  # type: RepeatedScalarFieldContainer[int]
+    packed_sfixed32 = ...  # type: RepeatedScalarFieldContainer[int]
+    packed_sfixed64 = ...  # type: RepeatedScalarFieldContainer[int]
+    packed_float = ...  # type: RepeatedScalarFieldContainer[float]
+    packed_double = ...  # type: RepeatedScalarFieldContainer[float]
+    packed_bool = ...  # type: RepeatedScalarFieldContainer[bool]
+    packed_enum = ...  # type: RepeatedScalarFieldContainer[ForeignEnum]
+
+    def __init__(self,
+                 packed_int32: Optional[Iterable[int]] = ...,
+                 packed_int64: Optional[Iterable[int]] = ...,
+                 packed_uint32: Optional[Iterable[int]] = ...,
+                 packed_uint64: Optional[Iterable[int]] = ...,
+                 packed_sint32: Optional[Iterable[int]] = ...,
+                 packed_sint64: Optional[Iterable[int]] = ...,
+                 packed_fixed32: Optional[Iterable[int]] = ...,
+                 packed_fixed64: Optional[Iterable[int]] = ...,
+                 packed_sfixed32: Optional[Iterable[int]] = ...,
+                 packed_sfixed64: Optional[Iterable[int]] = ...,
+                 packed_float: Optional[Iterable[float]] = ...,
+                 packed_double: Optional[Iterable[float]] = ...,
+                 packed_bool: Optional[Iterable[bool]] = ...,
+                 packed_enum: Optional[Iterable[ForeignEnum]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestPackedTypes: ...
+
+
+class TestUnpackedTypes(Message):
+    repeated_int32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_int64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_uint32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_uint64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sint32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sint64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_fixed32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_fixed64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sfixed32 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_sfixed64 = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_float = ...  # type: RepeatedScalarFieldContainer[float]
+    repeated_double = ...  # type: RepeatedScalarFieldContainer[float]
+    repeated_bool = ...  # type: RepeatedScalarFieldContainer[bool]
+    repeated_nested_enum = ...  # type: RepeatedScalarFieldContainer[TestAllTypes.NestedEnum]
+
+    def __init__(self,
+                 repeated_int32: Optional[Iterable[int]] = ...,
+                 repeated_int64: Optional[Iterable[int]] = ...,
+                 repeated_uint32: Optional[Iterable[int]] = ...,
+                 repeated_uint64: Optional[Iterable[int]] = ...,
+                 repeated_sint32: Optional[Iterable[int]] = ...,
+                 repeated_sint64: Optional[Iterable[int]] = ...,
+                 repeated_fixed32: Optional[Iterable[int]] = ...,
+                 repeated_fixed64: Optional[Iterable[int]] = ...,
+                 repeated_sfixed32: Optional[Iterable[int]] = ...,
+                 repeated_sfixed64: Optional[Iterable[int]] = ...,
+                 repeated_float: Optional[Iterable[float]] = ...,
+                 repeated_double: Optional[Iterable[float]] = ...,
+                 repeated_bool: Optional[Iterable[bool]] = ...,
+                 repeated_nested_enum: Optional[Iterable[TestAllTypes.NestedEnum]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestUnpackedTypes: ...
+
+
+class NestedTestAllTypes(Message):
+
+    @property
+    def child(self) -> NestedTestAllTypes: ...
+
+    @property
+    def payload(self) -> TestAllTypes: ...
+
+    @property
+    def repeated_child(
+        self) -> RepeatedCompositeFieldContainer[NestedTestAllTypes]: ...
+
+    def __init__(self,
+                 child: Optional[NestedTestAllTypes] = ...,
+                 payload: Optional[TestAllTypes] = ...,
+                 repeated_child: Optional[Iterable[NestedTestAllTypes]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> NestedTestAllTypes: ...
+
+
+class ForeignMessage(Message):
+    c = ...  # type: int
+
+    def __init__(self,
+                 c: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> ForeignMessage: ...
+
+
+class TestEmptyMessage(Message):
+
+    def __init__(self,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestEmptyMessage: ...

third_party/2/google/protobuf/util/json_format_proto3_pb2.pyi

@@ -0,0 +1,659 @@
+from google.protobuf.any_pb2 import (
+    Any,
+)
+from google.protobuf.duration_pb2 import (
+    Duration,
+)
+from google.protobuf.field_mask_pb2 import (
+    FieldMask,
+)
+from google.protobuf.internal.containers import (
+    RepeatedCompositeFieldContainer,
+    RepeatedScalarFieldContainer,
+)
+from google.protobuf.message import (
+    Message,
+)
+from google.protobuf.struct_pb2 import (
+    ListValue,
+    Struct,
+    Value,
+)
+from google.protobuf.timestamp_pb2 import (
+    Timestamp,
+)
+from google.protobuf.unittest_pb2 import (
+    TestAllExtensions,
+)
+from google.protobuf.wrappers_pb2 import (
+    BoolValue,
+    BytesValue,
+    DoubleValue,
+    FloatValue,
+    Int32Value,
+    Int64Value,
+    StringValue,
+    UInt32Value,
+    UInt64Value,
+)
+from typing import (
+    Iterable,
+    List,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Text,
+    Tuple,
+    cast,
+)
+
+
+class EnumType(int):
+
+    @classmethod
+    def Name(cls, number: int) -> str: ...
+
+    @classmethod
+    def Value(cls, name: str) -> EnumType: ...
+
+    @classmethod
+    def keys(cls) -> List[str]: ...
+
+    @classmethod
+    def values(cls) -> List[EnumType]: ...
+
+    @classmethod
+    def items(cls) -> List[Tuple[str, EnumType]]: ...
+
+
+FOO: EnumType
+BAR: EnumType
+
+
+class MessageType(Message):
+    value = ...  # type: int
+
+    def __init__(self,
+                 value: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> MessageType: ...
+
+
+class TestMessage(Message):
+    bool_value = ...  # type: bool
+    int32_value = ...  # type: int
+    int64_value = ...  # type: int
+    uint32_value = ...  # type: int
+    uint64_value = ...  # type: int
+    float_value = ...  # type: float
+    double_value = ...  # type: float
+    string_value = ...  # type: Text
+    bytes_value = ...  # type: str
+    enum_value = ...  # type: EnumType
+    repeated_bool_value = ...  # type: RepeatedScalarFieldContainer[bool]
+    repeated_int32_value = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_int64_value = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_uint32_value = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_uint64_value = ...  # type: RepeatedScalarFieldContainer[int]
+    repeated_float_value = ...  # type: RepeatedScalarFieldContainer[float]
+    repeated_double_value = ...  # type: RepeatedScalarFieldContainer[float]
+    repeated_string_value = ...  # type: RepeatedScalarFieldContainer[Text]
+    repeated_bytes_value = ...  # type: RepeatedScalarFieldContainer[str]
+    repeated_enum_value = ...  # type: RepeatedScalarFieldContainer[EnumType]
+
+    @property
+    def message_value(self) -> MessageType: ...
+
+    @property
+    def repeated_message_value(
+        self) -> RepeatedCompositeFieldContainer[MessageType]: ...
+
+    def __init__(self,
+                 bool_value: Optional[bool] = ...,
+                 int32_value: Optional[int] = ...,
+                 int64_value: Optional[int] = ...,
+                 uint32_value: Optional[int] = ...,
+                 uint64_value: Optional[int] = ...,
+                 float_value: Optional[float] = ...,
+                 double_value: Optional[float] = ...,
+                 string_value: Optional[Text] = ...,
+                 bytes_value: Optional[str] = ...,
+                 enum_value: Optional[EnumType] = ...,
+                 message_value: Optional[MessageType] = ...,
+                 repeated_bool_value: Optional[Iterable[bool]] = ...,
+                 repeated_int32_value: Optional[Iterable[int]] = ...,
+                 repeated_int64_value: Optional[Iterable[int]] = ...,
+                 repeated_uint32_value: Optional[Iterable[int]] = ...,
+                 repeated_uint64_value: Optional[Iterable[int]] = ...,
+                 repeated_float_value: Optional[Iterable[float]] = ...,
+                 repeated_double_value: Optional[Iterable[float]] = ...,
+                 repeated_string_value: Optional[Iterable[Text]] = ...,
+                 repeated_bytes_value: Optional[Iterable[str]] = ...,
+                 repeated_enum_value: Optional[Iterable[EnumType]] = ...,
+                 repeated_message_value: Optional[Iterable[MessageType]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestMessage: ...
+
+
+class TestOneof(Message):
+    oneof_int32_value = ...  # type: int
+    oneof_string_value = ...  # type: Text
+    oneof_bytes_value = ...  # type: str
+    oneof_enum_value = ...  # type: EnumType
+
+    @property
+    def oneof_message_value(self) -> MessageType: ...
+
+    def __init__(self,
+                 oneof_int32_value: Optional[int] = ...,
+                 oneof_string_value: Optional[Text] = ...,
+                 oneof_bytes_value: Optional[str] = ...,
+                 oneof_enum_value: Optional[EnumType] = ...,
+                 oneof_message_value: Optional[MessageType] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestOneof: ...
+
+
+class TestMap(Message):
+
+    class BoolMapEntry(Message):
+        key = ...  # type: bool
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[bool] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.BoolMapEntry: ...
+
+    class Int32MapEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.Int32MapEntry: ...
+
+    class Int64MapEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.Int64MapEntry: ...
+
+    class Uint32MapEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.Uint32MapEntry: ...
+
+    class Uint64MapEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.Uint64MapEntry: ...
+
+    class StringMapEntry(Message):
+        key = ...  # type: Text
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestMap.StringMapEntry: ...
+
+    @property
+    def bool_map(self) -> MutableMapping[bool, int]: ...
+
+    @property
+    def int32_map(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def int64_map(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def uint32_map(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def uint64_map(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def string_map(self) -> MutableMapping[Text, int]: ...
+
+    def __init__(self,
+                 bool_map: Optional[Mapping[bool, int]]=...,
+                 int32_map: Optional[Mapping[int, int]]=...,
+                 int64_map: Optional[Mapping[int, int]]=...,
+                 uint32_map: Optional[Mapping[int, int]]=...,
+                 uint64_map: Optional[Mapping[int, int]]=...,
+                 string_map: Optional[Mapping[Text, int]]=...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestMap: ...
+
+
+class TestNestedMap(Message):
+
+    class BoolMapEntry(Message):
+        key = ...  # type: bool
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[bool] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestNestedMap.BoolMapEntry: ...
+
+    class Int32MapEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestNestedMap.Int32MapEntry: ...
+
+    class Int64MapEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestNestedMap.Int64MapEntry: ...
+
+    class Uint32MapEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestNestedMap.Uint32MapEntry: ...
+
+    class Uint64MapEntry(Message):
+        key = ...  # type: int
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[int] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestNestedMap.Uint64MapEntry: ...
+
+    class StringMapEntry(Message):
+        key = ...  # type: Text
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestNestedMap.StringMapEntry: ...
+
+    class MapMapEntry(Message):
+        key = ...  # type: Text
+
+        @property
+        def value(self) -> TestNestedMap: ...
+
+        def __init__(self,
+                     key: Optional[Text] = ...,
+                     value: Optional[TestNestedMap] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestNestedMap.MapMapEntry: ...
+
+    @property
+    def bool_map(self) -> MutableMapping[bool, int]: ...
+
+    @property
+    def int32_map(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def int64_map(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def uint32_map(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def uint64_map(self) -> MutableMapping[int, int]: ...
+
+    @property
+    def string_map(self) -> MutableMapping[Text, int]: ...
+
+    @property
+    def map_map(self) -> MutableMapping[Text, TestNestedMap]: ...
+
+    def __init__(self,
+                 bool_map: Optional[Mapping[bool, int]]=...,
+                 int32_map: Optional[Mapping[int, int]]=...,
+                 int64_map: Optional[Mapping[int, int]]=...,
+                 uint32_map: Optional[Mapping[int, int]]=...,
+                 uint64_map: Optional[Mapping[int, int]]=...,
+                 string_map: Optional[Mapping[Text, int]]=...,
+                 map_map: Optional[Mapping[Text, TestNestedMap]]=...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestNestedMap: ...
+
+
+class TestWrapper(Message):
+
+    @property
+    def bool_value(self) -> BoolValue: ...
+
+    @property
+    def int32_value(self) -> Int32Value: ...
+
+    @property
+    def int64_value(self) -> Int64Value: ...
+
+    @property
+    def uint32_value(self) -> UInt32Value: ...
+
+    @property
+    def uint64_value(self) -> UInt64Value: ...
+
+    @property
+    def float_value(self) -> FloatValue: ...
+
+    @property
+    def double_value(self) -> DoubleValue: ...
+
+    @property
+    def string_value(self) -> StringValue: ...
+
+    @property
+    def bytes_value(self) -> BytesValue: ...
+
+    @property
+    def repeated_bool_value(
+        self) -> RepeatedCompositeFieldContainer[BoolValue]: ...
+
+    @property
+    def repeated_int32_value(
+        self) -> RepeatedCompositeFieldContainer[Int32Value]: ...
+
+    @property
+    def repeated_int64_value(
+        self) -> RepeatedCompositeFieldContainer[Int64Value]: ...
+
+    @property
+    def repeated_uint32_value(
+        self) -> RepeatedCompositeFieldContainer[UInt32Value]: ...
+
+    @property
+    def repeated_uint64_value(
+        self) -> RepeatedCompositeFieldContainer[UInt64Value]: ...
+
+    @property
+    def repeated_float_value(
+        self) -> RepeatedCompositeFieldContainer[FloatValue]: ...
+
+    @property
+    def repeated_double_value(
+        self) -> RepeatedCompositeFieldContainer[DoubleValue]: ...
+
+    @property
+    def repeated_string_value(
+        self) -> RepeatedCompositeFieldContainer[StringValue]: ...
+
+    @property
+    def repeated_bytes_value(
+        self) -> RepeatedCompositeFieldContainer[BytesValue]: ...
+
+    def __init__(self,
+                 bool_value: Optional[BoolValue] = ...,
+                 int32_value: Optional[Int32Value] = ...,
+                 int64_value: Optional[Int64Value] = ...,
+                 uint32_value: Optional[UInt32Value] = ...,
+                 uint64_value: Optional[UInt64Value] = ...,
+                 float_value: Optional[FloatValue] = ...,
+                 double_value: Optional[DoubleValue] = ...,
+                 string_value: Optional[StringValue] = ...,
+                 bytes_value: Optional[BytesValue] = ...,
+                 repeated_bool_value: Optional[Iterable[BoolValue]] = ...,
+                 repeated_int32_value: Optional[Iterable[Int32Value]] = ...,
+                 repeated_int64_value: Optional[Iterable[Int64Value]] = ...,
+                 repeated_uint32_value: Optional[Iterable[UInt32Value]] = ...,
+                 repeated_uint64_value: Optional[Iterable[UInt64Value]] = ...,
+                 repeated_float_value: Optional[Iterable[FloatValue]] = ...,
+                 repeated_double_value: Optional[Iterable[DoubleValue]] = ...,
+                 repeated_string_value: Optional[Iterable[StringValue]] = ...,
+                 repeated_bytes_value: Optional[Iterable[BytesValue]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestWrapper: ...
+
+
+class TestTimestamp(Message):
+
+    @property
+    def value(self) -> Timestamp: ...
+
+    @property
+    def repeated_value(self) -> RepeatedCompositeFieldContainer[Timestamp]: ...
+
+    def __init__(self,
+                 value: Optional[Timestamp] = ...,
+                 repeated_value: Optional[Iterable[Timestamp]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestTimestamp: ...
+
+
+class TestDuration(Message):
+
+    @property
+    def value(self) -> Duration: ...
+
+    @property
+    def repeated_value(self) -> RepeatedCompositeFieldContainer[Duration]: ...
+
+    def __init__(self,
+                 value: Optional[Duration] = ...,
+                 repeated_value: Optional[Iterable[Duration]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestDuration: ...
+
+
+class TestFieldMask(Message):
+
+    @property
+    def value(self) -> FieldMask: ...
+
+    def __init__(self,
+                 value: Optional[FieldMask] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestFieldMask: ...
+
+
+class TestStruct(Message):
+
+    @property
+    def value(self) -> Struct: ...
+
+    @property
+    def repeated_value(self) -> RepeatedCompositeFieldContainer[Struct]: ...
+
+    def __init__(self,
+                 value: Optional[Struct] = ...,
+                 repeated_value: Optional[Iterable[Struct]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestStruct: ...
+
+
+class TestAny(Message):
+
+    @property
+    def value(self) -> Any: ...
+
+    @property
+    def repeated_value(self) -> RepeatedCompositeFieldContainer[Any]: ...
+
+    def __init__(self,
+                 value: Optional[Any] = ...,
+                 repeated_value: Optional[Iterable[Any]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestAny: ...
+
+
+class TestValue(Message):
+
+    @property
+    def value(self) -> Value: ...
+
+    @property
+    def repeated_value(self) -> RepeatedCompositeFieldContainer[Value]: ...
+
+    def __init__(self,
+                 value: Optional[Value] = ...,
+                 repeated_value: Optional[Iterable[Value]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestValue: ...
+
+
+class TestListValue(Message):
+
+    @property
+    def value(self) -> ListValue: ...
+
+    @property
+    def repeated_value(self) -> RepeatedCompositeFieldContainer[ListValue]: ...
+
+    def __init__(self,
+                 value: Optional[ListValue] = ...,
+                 repeated_value: Optional[Iterable[ListValue]] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestListValue: ...
+
+
+class TestBoolValue(Message):
+
+    class BoolMapEntry(Message):
+        key = ...  # type: bool
+        value = ...  # type: int
+
+        def __init__(self,
+                     key: Optional[bool] = ...,
+                     value: Optional[int] = ...,
+                     ) -> None: ...
+
+        @classmethod
+        def FromString(cls, s: str) -> TestBoolValue.BoolMapEntry: ...
+    bool_value = ...  # type: bool
+
+    @property
+    def bool_map(self) -> MutableMapping[bool, int]: ...
+
+    def __init__(self,
+                 bool_value: Optional[bool] = ...,
+                 bool_map: Optional[Mapping[bool, int]]=...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestBoolValue: ...
+
+
+class TestCustomJsonName(Message):
+    value = ...  # type: int
+
+    def __init__(self,
+                 value: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestCustomJsonName: ...
+
+
+class TestExtensions(Message):
+
+    @property
+    def extensions(self) -> TestAllExtensions: ...
+
+    def __init__(self,
+                 extensions: Optional[TestAllExtensions] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestExtensions: ...
+
+
+class TestEnumValue(Message):
+    enum_value1 = ...  # type: EnumType
+    enum_value2 = ...  # type: EnumType
+    enum_value3 = ...  # type: EnumType
+
+    def __init__(self,
+                 enum_value1: Optional[EnumType] = ...,
+                 enum_value2: Optional[EnumType] = ...,
+                 enum_value3: Optional[EnumType] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> TestEnumValue: ...

third_party/2/google/protobuf/wrappers_pb2.pyi

@@ -0,0 +1,106 @@
+from google.protobuf.message import (
+    Message,
+)
+from typing import (
+    Optional,
+    Text,
+)
+
+
+class DoubleValue(Message):
+    value = ...  # type: float
+
+    def __init__(self,
+                 value: Optional[float] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> DoubleValue: ...
+
+
+class FloatValue(Message):
+    value = ...  # type: float
+
+    def __init__(self,
+                 value: Optional[float] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> FloatValue: ...
+
+
+class Int64Value(Message):
+    value = ...  # type: int
+
+    def __init__(self,
+                 value: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> Int64Value: ...
+
+
+class UInt64Value(Message):
+    value = ...  # type: int
+
+    def __init__(self,
+                 value: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> UInt64Value: ...
+
+
+class Int32Value(Message):
+    value = ...  # type: int
+
+    def __init__(self,
+                 value: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> Int32Value: ...
+
+
+class UInt32Value(Message):
+    value = ...  # type: int
+
+    def __init__(self,
+                 value: Optional[int] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> UInt32Value: ...
+
+
+class BoolValue(Message):
+    value = ...  # type: bool
+
+    def __init__(self,
+                 value: Optional[bool] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> BoolValue: ...
+
+
+class StringValue(Message):
+    value = ...  # type: Text
+
+    def __init__(self,
+                 value: Optional[Text] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> StringValue: ...
+
+
+class BytesValue(Message):
+    value = ...  # type: str
+
+    def __init__(self,
+                 value: Optional[str] = ...,
+                 ) -> None: ...
+
+    @classmethod
+    def FromString(cls, s: str) -> BytesValue: ...