.config/coc/extensions/coc-python-data/languageServer.0.5.59/Typeshed/third_party/2and3/google/protobuf/test_messages_proto2_pb2.pyi

   1 from google.protobuf.internal.containers import (\r
   2     RepeatedCompositeFieldContainer,\r
   3     RepeatedScalarFieldContainer,\r
   4 )\r
   5 from google.protobuf.message import (\r
   6     Message,\r
   7 )\r
   8 import builtins\r
   9 from typing import (\r
  10     Iterable,\r
  11     List,\r
  12     Mapping,\r
  13     MutableMapping,\r
  14     Optional,\r
  15     Text,\r
  16     Tuple,\r
  17     cast,\r
  18 )\r
  19 \r
  20 \r
  21 class ForeignEnumProto2(int):\r
  22 \r
  23     @classmethod\r
  24     def Name(cls, number: int) -> bytes: ...\r
  25 \r
  26     @classmethod\r
  27     def Value(cls, name: bytes) -> ForeignEnumProto2: ...\r
  28 \r
  29     @classmethod\r
  30     def keys(cls) -> List[bytes]: ...\r
  31 \r
  32     @classmethod\r
  33     def values(cls) -> List[ForeignEnumProto2]: ...\r
  34 \r
  35     @classmethod\r
  36     def items(cls) -> List[Tuple[bytes, ForeignEnumProto2]]: ...\r
  37 \r
  38 \r
  39 FOREIGN_FOO: ForeignEnumProto2\r
  40 FOREIGN_BAR: ForeignEnumProto2\r
  41 FOREIGN_BAZ: ForeignEnumProto2\r
  42 \r
  43 \r
  44 class TestAllTypesProto2(Message):\r
  45 \r
  46     class NestedEnum(int):\r
  47 \r
  48         @classmethod\r
  49         def Name(cls, number: int) -> bytes: ...\r
  50 \r
  51         @classmethod\r
  52         def Value(cls, name: bytes) -> TestAllTypesProto2.NestedEnum: ...\r
  53 \r
  54         @classmethod\r
  55         def keys(cls) -> List[bytes]: ...\r
  56 \r
  57         @classmethod\r
  58         def values(cls) -> List[TestAllTypesProto2.NestedEnum]: ...\r
  59 \r
  60         @classmethod\r
  61         def items(cls) -> List[Tuple[bytes, TestAllTypesProto2.NestedEnum]]: ...\r
  62     FOO: NestedEnum\r
  63     BAR: NestedEnum\r
  64     BAZ: NestedEnum\r
  65     NEG: NestedEnum\r
  66 \r
  67     class NestedMessage(Message):\r
  68         a = ...  # type: int\r
  69 \r
  70         @property\r
  71         def corecursive(self) -> TestAllTypesProto2: ...\r
  72 \r
  73         def __init__(self,\r
  74                      a: Optional[int] = ...,\r
  75                      corecursive: Optional[TestAllTypesProto2] = ...,\r
  76                      ) -> None: ...\r
  77 \r
  78         @classmethod\r
  79         def FromString(cls, s: bytes) -> TestAllTypesProto2.NestedMessage: ...\r
  80 \r
  81     class MapInt32Int32Entry(Message):\r
  82         key = ...  # type: int\r
  83         value = ...  # type: int\r
  84 \r
  85         def __init__(self,\r
  86                      key: Optional[int] = ...,\r
  87                      value: Optional[int] = ...,\r
  88                      ) -> None: ...\r
  89 \r
  90         @classmethod\r
  91         def FromString(\r
  92             cls, s: bytes) -> TestAllTypesProto2.MapInt32Int32Entry: ...\r
  93 \r
  94     class MapInt64Int64Entry(Message):\r
  95         key = ...  # type: int\r
  96         value = ...  # type: int\r
  97 \r
  98         def __init__(self,\r
  99                      key: Optional[int] = ...,\r
 100                      value: Optional[int] = ...,\r
 101                      ) -> None: ...\r
 102 \r
 103         @classmethod\r
 104         def FromString(\r
 105             cls, s: bytes) -> TestAllTypesProto2.MapInt64Int64Entry: ...\r
 106 \r
 107     class MapUint32Uint32Entry(Message):\r
 108         key = ...  # type: int\r
 109         value = ...  # type: int\r
 110 \r
 111         def __init__(self,\r
 112                      key: Optional[int] = ...,\r
 113                      value: Optional[int] = ...,\r
 114                      ) -> None: ...\r
 115 \r
 116         @classmethod\r
 117         def FromString(\r
 118             cls, s: bytes) -> TestAllTypesProto2.MapUint32Uint32Entry: ...\r
 119 \r
 120     class MapUint64Uint64Entry(Message):\r
 121         key = ...  # type: int\r
 122         value = ...  # type: int\r
 123 \r
 124         def __init__(self,\r
 125                      key: Optional[int] = ...,\r
 126                      value: Optional[int] = ...,\r
 127                      ) -> None: ...\r
 128 \r
 129         @classmethod\r
 130         def FromString(\r
 131             cls, s: bytes) -> TestAllTypesProto2.MapUint64Uint64Entry: ...\r
 132 \r
 133     class MapSint32Sint32Entry(Message):\r
 134         key = ...  # type: int\r
 135         value = ...  # type: int\r
 136 \r
 137         def __init__(self,\r
 138                      key: Optional[int] = ...,\r
 139                      value: Optional[int] = ...,\r
 140                      ) -> None: ...\r
 141 \r
 142         @classmethod\r
 143         def FromString(\r
 144             cls, s: bytes) -> TestAllTypesProto2.MapSint32Sint32Entry: ...\r
 145 \r
 146     class MapSint64Sint64Entry(Message):\r
 147         key = ...  # type: int\r
 148         value = ...  # type: int\r
 149 \r
 150         def __init__(self,\r
 151                      key: Optional[int] = ...,\r
 152                      value: Optional[int] = ...,\r
 153                      ) -> None: ...\r
 154 \r
 155         @classmethod\r
 156         def FromString(\r
 157             cls, s: bytes) -> TestAllTypesProto2.MapSint64Sint64Entry: ...\r
 158 \r
 159     class MapFixed32Fixed32Entry(Message):\r
 160         key = ...  # type: int\r
 161         value = ...  # type: int\r
 162 \r
 163         def __init__(self,\r
 164                      key: Optional[int] = ...,\r
 165                      value: Optional[int] = ...,\r
 166                      ) -> None: ...\r
 167 \r
 168         @classmethod\r
 169         def FromString(\r
 170             cls, s: bytes) -> TestAllTypesProto2.MapFixed32Fixed32Entry: ...\r
 171 \r
 172     class MapFixed64Fixed64Entry(Message):\r
 173         key = ...  # type: int\r
 174         value = ...  # type: int\r
 175 \r
 176         def __init__(self,\r
 177                      key: Optional[int] = ...,\r
 178                      value: Optional[int] = ...,\r
 179                      ) -> None: ...\r
 180 \r
 181         @classmethod\r
 182         def FromString(\r
 183             cls, s: bytes) -> TestAllTypesProto2.MapFixed64Fixed64Entry: ...\r
 184 \r
 185     class MapSfixed32Sfixed32Entry(Message):\r
 186         key = ...  # type: int\r
 187         value = ...  # type: int\r
 188 \r
 189         def __init__(self,\r
 190                      key: Optional[int] = ...,\r
 191                      value: Optional[int] = ...,\r
 192                      ) -> None: ...\r
 193 \r
 194         @classmethod\r
 195         def FromString(\r
 196             cls, s: bytes) -> TestAllTypesProto2.MapSfixed32Sfixed32Entry: ...\r
 197 \r
 198     class MapSfixed64Sfixed64Entry(Message):\r
 199         key = ...  # type: int\r
 200         value = ...  # type: int\r
 201 \r
 202         def __init__(self,\r
 203                      key: Optional[int] = ...,\r
 204                      value: Optional[int] = ...,\r
 205                      ) -> None: ...\r
 206 \r
 207         @classmethod\r
 208         def FromString(\r
 209             cls, s: bytes) -> TestAllTypesProto2.MapSfixed64Sfixed64Entry: ...\r
 210 \r
 211     class MapInt32FloatEntry(Message):\r
 212         key = ...  # type: int\r
 213         value = ...  # type: float\r
 214 \r
 215         def __init__(self,\r
 216                      key: Optional[int] = ...,\r
 217                      value: Optional[float] = ...,\r
 218                      ) -> None: ...\r
 219 \r
 220         @classmethod\r
 221         def FromString(\r
 222             cls, s: bytes) -> TestAllTypesProto2.MapInt32FloatEntry: ...\r
 223 \r
 224     class MapInt32DoubleEntry(Message):\r
 225         key = ...  # type: int\r
 226         value = ...  # type: float\r
 227 \r
 228         def __init__(self,\r
 229                      key: Optional[int] = ...,\r
 230                      value: Optional[float] = ...,\r
 231                      ) -> None: ...\r
 232 \r
 233         @classmethod\r
 234         def FromString(\r
 235             cls, s: bytes) -> TestAllTypesProto2.MapInt32DoubleEntry: ...\r
 236 \r
 237     class MapBoolBoolEntry(Message):\r
 238         key = ...  # type: bool\r
 239         value = ...  # type: bool\r
 240 \r
 241         def __init__(self,\r
 242                      key: Optional[bool] = ...,\r
 243                      value: Optional[bool] = ...,\r
 244                      ) -> None: ...\r
 245 \r
 246         @classmethod\r
 247         def FromString(cls, s: bytes) -> TestAllTypesProto2.MapBoolBoolEntry: ...\r
 248 \r
 249     class MapStringStringEntry(Message):\r
 250         key = ...  # type: Text\r
 251         value = ...  # type: Text\r
 252 \r
 253         def __init__(self,\r
 254                      key: Optional[Text] = ...,\r
 255                      value: Optional[Text] = ...,\r
 256                      ) -> None: ...\r
 257 \r
 258         @classmethod\r
 259         def FromString(\r
 260             cls, s: bytes) -> TestAllTypesProto2.MapStringStringEntry: ...\r
 261 \r
 262     class MapStringBytesEntry(Message):\r
 263         key = ...  # type: Text\r
 264         value = ...  # type: bytes\r
 265 \r
 266         def __init__(self,\r
 267                      key: Optional[Text] = ...,\r
 268                      value: Optional[bytes] = ...,\r
 269                      ) -> None: ...\r
 270 \r
 271         @classmethod\r
 272         def FromString(\r
 273             cls, s: bytes) -> TestAllTypesProto2.MapStringBytesEntry: ...\r
 274 \r
 275     class MapStringNestedMessageEntry(Message):\r
 276         key = ...  # type: Text\r
 277 \r
 278         @property\r
 279         def value(self) -> TestAllTypesProto2.NestedMessage: ...\r
 280 \r
 281         def __init__(self,\r
 282                      key: Optional[Text] = ...,\r
 283                      value: Optional[TestAllTypesProto2.NestedMessage] = ...,\r
 284                      ) -> None: ...\r
 285 \r
 286         @classmethod\r
 287         def FromString(\r
 288             cls, s: bytes) -> TestAllTypesProto2.MapStringNestedMessageEntry: ...\r
 289 \r
 290     class MapStringForeignMessageEntry(Message):\r
 291         key = ...  # type: Text\r
 292 \r
 293         @property\r
 294         def value(self) -> ForeignMessageProto2: ...\r
 295 \r
 296         def __init__(self,\r
 297                      key: Optional[Text] = ...,\r
 298                      value: Optional[ForeignMessageProto2] = ...,\r
 299                      ) -> None: ...\r
 300 \r
 301         @classmethod\r
 302         def FromString(\r
 303             cls, s: bytes) -> TestAllTypesProto2.MapStringForeignMessageEntry: ...\r
 304 \r
 305     class MapStringNestedEnumEntry(Message):\r
 306         key = ...  # type: Text\r
 307         value = ...  # type: TestAllTypesProto2.NestedEnum\r
 308 \r
 309         def __init__(self,\r
 310                      key: Optional[Text] = ...,\r
 311                      value: Optional[TestAllTypesProto2.NestedEnum] = ...,\r
 312                      ) -> None: ...\r
 313 \r
 314         @classmethod\r
 315         def FromString(\r
 316             cls, s: bytes) -> TestAllTypesProto2.MapStringNestedEnumEntry: ...\r
 317 \r
 318     class MapStringForeignEnumEntry(Message):\r
 319         key = ...  # type: Text\r
 320         value = ...  # type: ForeignEnumProto2\r
 321 \r
 322         def __init__(self,\r
 323                      key: Optional[Text] = ...,\r
 324                      value: Optional[ForeignEnumProto2] = ...,\r
 325                      ) -> None: ...\r
 326 \r
 327         @classmethod\r
 328         def FromString(\r
 329             cls, s: bytes) -> TestAllTypesProto2.MapStringForeignEnumEntry: ...\r
 330 \r
 331     class Data(Message):\r
 332         group_int32 = ...  # type: int\r
 333         group_uint32 = ...  # type: int\r
 334 \r
 335         def __init__(self,\r
 336                      group_int32: Optional[int] = ...,\r
 337                      group_uint32: Optional[int] = ...,\r
 338                      ) -> None: ...\r
 339 \r
 340         @classmethod\r
 341         def FromString(cls, s: bytes) -> TestAllTypesProto2.Data: ...\r
 342 \r
 343     class MessageSetCorrect(Message):\r
 344 \r
 345         def __init__(self,\r
 346                      ) -> None: ...\r
 347 \r
 348         @classmethod\r
 349         def FromString(\r
 350             cls, s: bytes) -> TestAllTypesProto2.MessageSetCorrect: ...\r
 351 \r
 352     class MessageSetCorrectExtension1(Message):\r
 353         bytes = ...  # type: Text\r
 354 \r
 355         def __init__(self,\r
 356                      bytes: Optional[Text] = ...,\r
 357                      ) -> None: ...\r
 358 \r
 359         @classmethod\r
 360         def FromString(\r
 361             cls, s: builtins.bytes) -> TestAllTypesProto2.MessageSetCorrectExtension1: ...\r
 362 \r
 363     class MessageSetCorrectExtension2(Message):\r
 364         i = ...  # type: int\r
 365 \r
 366         def __init__(self,\r
 367                      i: Optional[int] = ...,\r
 368                      ) -> None: ...\r
 369 \r
 370         @classmethod\r
 371         def FromString(\r
 372             cls, s: bytes) -> TestAllTypesProto2.MessageSetCorrectExtension2: ...\r
 373     optional_int32 = ...  # type: int\r
 374     optional_int64 = ...  # type: int\r
 375     optional_uint32 = ...  # type: int\r
 376     optional_uint64 = ...  # type: int\r
 377     optional_sint32 = ...  # type: int\r
 378     optional_sint64 = ...  # type: int\r
 379     optional_fixed32 = ...  # type: int\r
 380     optional_fixed64 = ...  # type: int\r
 381     optional_sfixed32 = ...  # type: int\r
 382     optional_sfixed64 = ...  # type: int\r
 383     optional_float = ...  # type: float\r
 384     optional_double = ...  # type: float\r
 385     optional_bool = ...  # type: bool\r
 386     optional_string = ...  # type: Text\r
 387     optional_bytes = ...  # type: bytes\r
 388     optional_nested_enum = ...  # type: TestAllTypesProto2.NestedEnum\r
 389     optional_foreign_enum = ...  # type: ForeignEnumProto2\r
 390     optional_string_piece = ...  # type: Text\r
 391     optional_cord = ...  # type: Text\r
 392     repeated_int32 = ...  # type: RepeatedScalarFieldContainer[int]\r
 393     repeated_int64 = ...  # type: RepeatedScalarFieldContainer[int]\r
 394     repeated_uint32 = ...  # type: RepeatedScalarFieldContainer[int]\r
 395     repeated_uint64 = ...  # type: RepeatedScalarFieldContainer[int]\r
 396     repeated_sint32 = ...  # type: RepeatedScalarFieldContainer[int]\r
 397     repeated_sint64 = ...  # type: RepeatedScalarFieldContainer[int]\r
 398     repeated_fixed32 = ...  # type: RepeatedScalarFieldContainer[int]\r
 399     repeated_fixed64 = ...  # type: RepeatedScalarFieldContainer[int]\r
 400     repeated_sfixed32 = ...  # type: RepeatedScalarFieldContainer[int]\r
 401     repeated_sfixed64 = ...  # type: RepeatedScalarFieldContainer[int]\r
 402     repeated_float = ...  # type: RepeatedScalarFieldContainer[float]\r
 403     repeated_double = ...  # type: RepeatedScalarFieldContainer[float]\r
 404     repeated_bool = ...  # type: RepeatedScalarFieldContainer[bool]\r
 405     repeated_string = ...  # type: RepeatedScalarFieldContainer[Text]\r
 406     repeated_bytes = ...  # type: RepeatedScalarFieldContainer[bytes]\r
 407     repeated_nested_enum = ...  # type: RepeatedScalarFieldContainer[TestAllTypesProto2.NestedEnum]\r
 408     repeated_foreign_enum = ...  # type: RepeatedScalarFieldContainer[ForeignEnumProto2]\r
 409     repeated_string_piece = ...  # type: RepeatedScalarFieldContainer[Text]\r
 410     repeated_cord = ...  # type: RepeatedScalarFieldContainer[Text]\r
 411     oneof_uint32 = ...  # type: int\r
 412     oneof_string = ...  # type: Text\r
 413     oneof_bytes = ...  # type: bytes\r
 414     oneof_bool = ...  # type: bool\r
 415     oneof_uint64 = ...  # type: int\r
 416     oneof_float = ...  # type: float\r
 417     oneof_double = ...  # type: float\r
 418     oneof_enum = ...  # type: TestAllTypesProto2.NestedEnum\r
 419     fieldname1 = ...  # type: int\r
 420     field_name2 = ...  # type: int\r
 421     _field_name3 = ...  # type: int\r
 422     field__name4_ = ...  # type: int\r
 423     field0name5 = ...  # type: int\r
 424     field_0_name6 = ...  # type: int\r
 425     fieldName7 = ...  # type: int\r
 426     FieldName8 = ...  # type: int\r
 427     field_Name9 = ...  # type: int\r
 428     Field_Name10 = ...  # type: int\r
 429     FIELD_NAME11 = ...  # type: int\r
 430     FIELD_name12 = ...  # type: int\r
 431     __field_name13 = ...  # type: int\r
 432     __Field_name14 = ...  # type: int\r
 433     field__name15 = ...  # type: int\r
 434     field__Name16 = ...  # type: int\r
 435     field_name17__ = ...  # type: int\r
 436     Field_name18__ = ...  # type: int\r
 437 \r
 438     @property\r
 439     def optional_nested_message(self) -> TestAllTypesProto2.NestedMessage: ...\r
 440 \r
 441     @property\r
 442     def optional_foreign_message(self) -> ForeignMessageProto2: ...\r
 443 \r
 444     @property\r
 445     def recursive_message(self) -> TestAllTypesProto2: ...\r
 446 \r
 447     @property\r
 448     def repeated_nested_message(\r
 449         self) -> RepeatedCompositeFieldContainer[TestAllTypesProto2.NestedMessage]: ...\r
 450 \r
 451     @property\r
 452     def repeated_foreign_message(\r
 453         self) -> RepeatedCompositeFieldContainer[ForeignMessageProto2]: ...\r
 454 \r
 455     @property\r
 456     def map_int32_int32(self) -> MutableMapping[int, int]: ...\r
 457 \r
 458     @property\r
 459     def map_int64_int64(self) -> MutableMapping[int, int]: ...\r
 460 \r
 461     @property\r
 462     def map_uint32_uint32(self) -> MutableMapping[int, int]: ...\r
 463 \r
 464     @property\r
 465     def map_uint64_uint64(self) -> MutableMapping[int, int]: ...\r
 466 \r
 467     @property\r
 468     def map_sint32_sint32(self) -> MutableMapping[int, int]: ...\r
 469 \r
 470     @property\r
 471     def map_sint64_sint64(self) -> MutableMapping[int, int]: ...\r
 472 \r
 473     @property\r
 474     def map_fixed32_fixed32(self) -> MutableMapping[int, int]: ...\r
 475 \r
 476     @property\r
 477     def map_fixed64_fixed64(self) -> MutableMapping[int, int]: ...\r
 478 \r
 479     @property\r
 480     def map_sfixed32_sfixed32(self) -> MutableMapping[int, int]: ...\r
 481 \r
 482     @property\r
 483     def map_sfixed64_sfixed64(self) -> MutableMapping[int, int]: ...\r
 484 \r
 485     @property\r
 486     def map_int32_float(self) -> MutableMapping[int, float]: ...\r
 487 \r
 488     @property\r
 489     def map_int32_double(self) -> MutableMapping[int, float]: ...\r
 490 \r
 491     @property\r
 492     def map_bool_bool(self) -> MutableMapping[bool, bool]: ...\r
 493 \r
 494     @property\r
 495     def map_string_string(self) -> MutableMapping[Text, Text]: ...\r
 496 \r
 497     @property\r
 498     def map_string_bytes(self) -> MutableMapping[Text, bytes]: ...\r
 499 \r
 500     @property\r
 501     def map_string_nested_message(\r
 502         self) -> MutableMapping[Text, TestAllTypesProto2.NestedMessage]: ...\r
 503 \r
 504     @property\r
 505     def map_string_foreign_message(\r
 506         self) -> MutableMapping[Text, ForeignMessageProto2]: ...\r
 507 \r
 508     @property\r
 509     def map_string_nested_enum(\r
 510         self) -> MutableMapping[Text, TestAllTypesProto2.NestedEnum]: ...\r
 511 \r
 512     @property\r
 513     def map_string_foreign_enum(\r
 514         self) -> MutableMapping[Text, ForeignEnumProto2]: ...\r
 515 \r
 516     @property\r
 517     def oneof_nested_message(self) -> TestAllTypesProto2.NestedMessage: ...\r
 518 \r
 519     @property\r
 520     def data(self) -> TestAllTypesProto2.Data: ...\r
 521 \r
 522     def __init__(self,\r
 523                  optional_int32: Optional[int] = ...,\r
 524                  optional_int64: Optional[int] = ...,\r
 525                  optional_uint32: Optional[int] = ...,\r
 526                  optional_uint64: Optional[int] = ...,\r
 527                  optional_sint32: Optional[int] = ...,\r
 528                  optional_sint64: Optional[int] = ...,\r
 529                  optional_fixed32: Optional[int] = ...,\r
 530                  optional_fixed64: Optional[int] = ...,\r
 531                  optional_sfixed32: Optional[int] = ...,\r
 532                  optional_sfixed64: Optional[int] = ...,\r
 533                  optional_float: Optional[float] = ...,\r
 534                  optional_double: Optional[float] = ...,\r
 535                  optional_bool: Optional[bool] = ...,\r
 536                  optional_string: Optional[Text] = ...,\r
 537                  optional_bytes: Optional[bytes] = ...,\r
 538                  optional_nested_message: Optional[TestAllTypesProto2.NestedMessage] = ...,\r
 539                  optional_foreign_message: Optional[ForeignMessageProto2] = ...,\r
 540                  optional_nested_enum: Optional[TestAllTypesProto2.NestedEnum] = ...,\r
 541                  optional_foreign_enum: Optional[ForeignEnumProto2] = ...,\r
 542                  optional_string_piece: Optional[Text] = ...,\r
 543                  optional_cord: Optional[Text] = ...,\r
 544                  recursive_message: Optional[TestAllTypesProto2] = ...,\r
 545                  repeated_int32: Optional[Iterable[int]] = ...,\r
 546                  repeated_int64: Optional[Iterable[int]] = ...,\r
 547                  repeated_uint32: Optional[Iterable[int]] = ...,\r
 548                  repeated_uint64: Optional[Iterable[int]] = ...,\r
 549                  repeated_sint32: Optional[Iterable[int]] = ...,\r
 550                  repeated_sint64: Optional[Iterable[int]] = ...,\r
 551                  repeated_fixed32: Optional[Iterable[int]] = ...,\r
 552                  repeated_fixed64: Optional[Iterable[int]] = ...,\r
 553                  repeated_sfixed32: Optional[Iterable[int]] = ...,\r
 554                  repeated_sfixed64: Optional[Iterable[int]] = ...,\r
 555                  repeated_float: Optional[Iterable[float]] = ...,\r
 556                  repeated_double: Optional[Iterable[float]] = ...,\r
 557                  repeated_bool: Optional[Iterable[bool]] = ...,\r
 558                  repeated_string: Optional[Iterable[Text]] = ...,\r
 559                  repeated_bytes: Optional[Iterable[bytes]] = ...,\r
 560                  repeated_nested_message: Optional[Iterable[TestAllTypesProto2.NestedMessage]] = ...,\r
 561                  repeated_foreign_message: Optional[Iterable[ForeignMessageProto2]] = ...,\r
 562                  repeated_nested_enum: Optional[Iterable[TestAllTypesProto2.NestedEnum]] = ...,\r
 563                  repeated_foreign_enum: Optional[Iterable[ForeignEnumProto2]] = ...,\r
 564                  repeated_string_piece: Optional[Iterable[Text]] = ...,\r
 565                  repeated_cord: Optional[Iterable[Text]] = ...,\r
 566                  map_int32_int32: Optional[Mapping[int, int]]=...,\r
 567                  map_int64_int64: Optional[Mapping[int, int]]=...,\r
 568                  map_uint32_uint32: Optional[Mapping[int, int]]=...,\r
 569                  map_uint64_uint64: Optional[Mapping[int, int]]=...,\r
 570                  map_sint32_sint32: Optional[Mapping[int, int]]=...,\r
 571                  map_sint64_sint64: Optional[Mapping[int, int]]=...,\r
 572                  map_fixed32_fixed32: Optional[Mapping[int, int]]=...,\r
 573                  map_fixed64_fixed64: Optional[Mapping[int, int]]=...,\r
 574                  map_sfixed32_sfixed32: Optional[Mapping[int, int]]=...,\r
 575                  map_sfixed64_sfixed64: Optional[Mapping[int, int]]=...,\r
 576                  map_int32_float: Optional[Mapping[int, float]]=...,\r
 577                  map_int32_double: Optional[Mapping[int, float]]=...,\r
 578                  map_bool_bool: Optional[Mapping[bool, bool]]=...,\r
 579                  map_string_string: Optional[Mapping[Text, Text]]=...,\r
 580                  map_string_bytes: Optional[Mapping[Text, bytes]]=...,\r
 581                  map_string_nested_message: Optional[Mapping[Text, TestAllTypesProto2.NestedMessage]]=...,\r
 582                  map_string_foreign_message: Optional[Mapping[Text, ForeignMessageProto2]]=...,\r
 583                  map_string_nested_enum: Optional[Mapping[Text, TestAllTypesProto2.NestedEnum]]=...,\r
 584                  map_string_foreign_enum: Optional[Mapping[Text, ForeignEnumProto2]]=...,\r
 585                  oneof_uint32: Optional[int] = ...,\r
 586                  oneof_nested_message: Optional[TestAllTypesProto2.NestedMessage] = ...,\r
 587                  oneof_string: Optional[Text] = ...,\r
 588                  oneof_bytes: Optional[bytes] = ...,\r
 589                  oneof_bool: Optional[bool] = ...,\r
 590                  oneof_uint64: Optional[int] = ...,\r
 591                  oneof_float: Optional[float] = ...,\r
 592                  oneof_double: Optional[float] = ...,\r
 593                  oneof_enum: Optional[TestAllTypesProto2.NestedEnum] = ...,\r
 594                  data: Optional[TestAllTypesProto2.Data] = ...,\r
 595                  fieldname1: Optional[int] = ...,\r
 596                  field_name2: Optional[int] = ...,\r
 597                  _field_name3: Optional[int] = ...,\r
 598                  field__name4_: Optional[int] = ...,\r
 599                  field0name5: Optional[int] = ...,\r
 600                  field_0_name6: Optional[int] = ...,\r
 601                  fieldName7: Optional[int] = ...,\r
 602                  FieldName8: Optional[int] = ...,\r
 603                  field_Name9: Optional[int] = ...,\r
 604                  Field_Name10: Optional[int] = ...,\r
 605                  FIELD_NAME11: Optional[int] = ...,\r
 606                  FIELD_name12: Optional[int] = ...,\r
 607                  __field_name13: Optional[int] = ...,\r
 608                  __Field_name14: Optional[int] = ...,\r
 609                  field__name15: Optional[int] = ...,\r
 610                  field__Name16: Optional[int] = ...,\r
 611                  field_name17__: Optional[int] = ...,\r
 612                  Field_name18__: Optional[int] = ...,\r
 613                  ) -> None: ...\r
 614 \r
 615     @classmethod\r
 616     def FromString(cls, s: bytes) -> TestAllTypesProto2: ...\r
 617 \r
 618 \r
 619 class ForeignMessageProto2(Message):\r
 620     c = ...  # type: int\r
 621 \r
 622     def __init__(self,\r
 623                  c: Optional[int] = ...,\r
 624                  ) -> None: ...\r
 625 \r
 626     @classmethod\r
 627     def FromString(cls, s: bytes) -> ForeignMessageProto2: ...\r