.config/coc/extensions/coc-python-data/languageServer.0.5.59/Typeshed/third_party/2and3/google/protobuf/unittest_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 from google.protobuf.unittest_import_pb2 import (\r
   9     ImportEnum,\r
  10     ImportMessage,\r
  11 )\r
  12 from google.protobuf.unittest_import_public_pb2 import (\r
  13     PublicImportMessage,\r
  14 )\r
  15 from typing import (\r
  16     Iterable,\r
  17     List,\r
  18     Mapping,\r
  19     MutableMapping,\r
  20     Optional,\r
  21     Text,\r
  22     Tuple,\r
  23     cast,\r
  24 )\r
  25 \r
  26 \r
  27 class ForeignEnum(int):\r
  28     @classmethod\r
  29     def Name(cls, number: int) -> bytes: ...\r
  30 \r
  31     @classmethod\r
  32     def Value(cls, name: bytes) -> ForeignEnum: ...\r
  33 \r
  34     @classmethod\r
  35     def keys(cls) -> List[bytes]: ...\r
  36 \r
  37     @classmethod\r
  38     def values(cls) -> List[ForeignEnum]: ...\r
  39 \r
  40     @classmethod\r
  41     def items(cls) -> List[Tuple[bytes, ForeignEnum]]: ...\r
  42 \r
  43 \r
  44 FOREIGN_FOO: ForeignEnum\r
  45 FOREIGN_BAR: ForeignEnum\r
  46 FOREIGN_BAZ: ForeignEnum\r
  47 \r
  48 \r
  49 class TestEnumWithDupValue(int):\r
  50     @classmethod\r
  51     def Name(cls, number: int) -> bytes: ...\r
  52 \r
  53     @classmethod\r
  54     def Value(cls, name: bytes) -> TestEnumWithDupValue: ...\r
  55 \r
  56     @classmethod\r
  57     def keys(cls) -> List[bytes]: ...\r
  58 \r
  59     @classmethod\r
  60     def values(cls) -> List[TestEnumWithDupValue]: ...\r
  61 \r
  62     @classmethod\r
  63     def items(cls) -> List[Tuple[bytes, TestEnumWithDupValue]]: ...\r
  64 \r
  65 \r
  66 FOO1: TestEnumWithDupValue\r
  67 BAR1: TestEnumWithDupValue\r
  68 BAZ: TestEnumWithDupValue\r
  69 FOO2: TestEnumWithDupValue\r
  70 BAR2: TestEnumWithDupValue\r
  71 \r
  72 \r
  73 class TestSparseEnum(int):\r
  74     @classmethod\r
  75     def Name(cls, number: int) -> bytes: ...\r
  76 \r
  77     @classmethod\r
  78     def Value(cls, name: bytes) -> TestSparseEnum: ...\r
  79 \r
  80     @classmethod\r
  81     def keys(cls) -> List[bytes]: ...\r
  82 \r
  83     @classmethod\r
  84     def values(cls) -> List[TestSparseEnum]: ...\r
  85 \r
  86     @classmethod\r
  87     def items(cls) -> List[Tuple[bytes, TestSparseEnum]]: ...\r
  88 \r
  89 \r
  90 SPARSE_A: TestSparseEnum\r
  91 SPARSE_B: TestSparseEnum\r
  92 SPARSE_C: TestSparseEnum\r
  93 SPARSE_D: TestSparseEnum\r
  94 SPARSE_E: TestSparseEnum\r
  95 SPARSE_F: TestSparseEnum\r
  96 SPARSE_G: TestSparseEnum\r
  97 \r
  98 \r
  99 class TestAllTypes(Message):\r
 100     class NestedEnum(int):\r
 101         @classmethod\r
 102         def Name(cls, number: int) -> bytes: ...\r
 103 \r
 104         @classmethod\r
 105         def Value(cls, name: bytes) -> TestAllTypes.NestedEnum: ...\r
 106 \r
 107         @classmethod\r
 108         def keys(cls) -> List[bytes]: ...\r
 109 \r
 110         @classmethod\r
 111         def values(cls) -> List[TestAllTypes.NestedEnum]: ...\r
 112 \r
 113         @classmethod\r
 114         def items(cls) -> List[Tuple[bytes, TestAllTypes.NestedEnum]]: ...\r
 115     FOO: NestedEnum\r
 116     BAR: NestedEnum\r
 117     BAZ: NestedEnum\r
 118     NEG: NestedEnum\r
 119 \r
 120     class NestedMessage(Message):\r
 121         bb = ...  # type: int\r
 122 \r
 123         def __init__(self,\r
 124                      bb: Optional[int] = ...,\r
 125                      ) -> None: ...\r
 126 \r
 127         @classmethod\r
 128         def FromString(cls, s: bytes) -> TestAllTypes.NestedMessage: ...\r
 129 \r
 130     class OptionalGroup(Message):\r
 131         a = ...  # type: int\r
 132 \r
 133         def __init__(self,\r
 134                      a: Optional[int] = ...,\r
 135                      ) -> None: ...\r
 136 \r
 137         @classmethod\r
 138         def FromString(cls, s: bytes) -> TestAllTypes.OptionalGroup: ...\r
 139 \r
 140     class RepeatedGroup(Message):\r
 141         a = ...  # type: int\r
 142 \r
 143         def __init__(self,\r
 144                      a: Optional[int] = ...,\r
 145                      ) -> None: ...\r
 146 \r
 147         @classmethod\r
 148         def FromString(cls, s: bytes) -> TestAllTypes.RepeatedGroup: ...\r
 149     optional_int32 = ...  # type: int\r
 150     optional_int64 = ...  # type: int\r
 151     optional_uint32 = ...  # type: int\r
 152     optional_uint64 = ...  # type: int\r
 153     optional_sint32 = ...  # type: int\r
 154     optional_sint64 = ...  # type: int\r
 155     optional_fixed32 = ...  # type: int\r
 156     optional_fixed64 = ...  # type: int\r
 157     optional_sfixed32 = ...  # type: int\r
 158     optional_sfixed64 = ...  # type: int\r
 159     optional_float = ...  # type: float\r
 160     optional_double = ...  # type: float\r
 161     optional_bool = ...  # type: bool\r
 162     optional_string = ...  # type: Text\r
 163     optional_bytes = ...  # type: bytes\r
 164     optional_nested_enum = ...  # type: TestAllTypes.NestedEnum\r
 165     optional_foreign_enum = ...  # type: ForeignEnum\r
 166     optional_import_enum = ...  # type: ImportEnum\r
 167     optional_string_piece = ...  # type: Text\r
 168     optional_cord = ...  # type: Text\r
 169     repeated_int32 = ...  # type: RepeatedScalarFieldContainer[int]\r
 170     repeated_int64 = ...  # type: RepeatedScalarFieldContainer[int]\r
 171     repeated_uint32 = ...  # type: RepeatedScalarFieldContainer[int]\r
 172     repeated_uint64 = ...  # type: RepeatedScalarFieldContainer[int]\r
 173     repeated_sint32 = ...  # type: RepeatedScalarFieldContainer[int]\r
 174     repeated_sint64 = ...  # type: RepeatedScalarFieldContainer[int]\r
 175     repeated_fixed32 = ...  # type: RepeatedScalarFieldContainer[int]\r
 176     repeated_fixed64 = ...  # type: RepeatedScalarFieldContainer[int]\r
 177     repeated_sfixed32 = ...  # type: RepeatedScalarFieldContainer[int]\r
 178     repeated_sfixed64 = ...  # type: RepeatedScalarFieldContainer[int]\r
 179     repeated_float = ...  # type: RepeatedScalarFieldContainer[float]\r
 180     repeated_double = ...  # type: RepeatedScalarFieldContainer[float]\r
 181     repeated_bool = ...  # type: RepeatedScalarFieldContainer[bool]\r
 182     repeated_string = ...  # type: RepeatedScalarFieldContainer[Text]\r
 183     repeated_bytes = ...  # type: RepeatedScalarFieldContainer[bytes]\r
 184     repeated_nested_enum = ...  # type: RepeatedScalarFieldContainer[TestAllTypes.NestedEnum]\r
 185     repeated_foreign_enum = ...  # type: RepeatedScalarFieldContainer[ForeignEnum]\r
 186     repeated_import_enum = ...  # type: RepeatedScalarFieldContainer[ImportEnum]\r
 187     repeated_string_piece = ...  # type: RepeatedScalarFieldContainer[Text]\r
 188     repeated_cord = ...  # type: RepeatedScalarFieldContainer[Text]\r
 189     default_int32 = ...  # type: int\r
 190     default_int64 = ...  # type: int\r
 191     default_uint32 = ...  # type: int\r
 192     default_uint64 = ...  # type: int\r
 193     default_sint32 = ...  # type: int\r
 194     default_sint64 = ...  # type: int\r
 195     default_fixed32 = ...  # type: int\r
 196     default_fixed64 = ...  # type: int\r
 197     default_sfixed32 = ...  # type: int\r
 198     default_sfixed64 = ...  # type: int\r
 199     default_float = ...  # type: float\r
 200     default_double = ...  # type: float\r
 201     default_bool = ...  # type: bool\r
 202     default_string = ...  # type: Text\r
 203     default_bytes = ...  # type: bytes\r
 204     default_nested_enum = ...  # type: TestAllTypes.NestedEnum\r
 205     default_foreign_enum = ...  # type: ForeignEnum\r
 206     default_import_enum = ...  # type: ImportEnum\r
 207     default_string_piece = ...  # type: Text\r
 208     default_cord = ...  # type: Text\r
 209     oneof_uint32 = ...  # type: int\r
 210     oneof_string = ...  # type: Text\r
 211     oneof_bytes = ...  # type: bytes\r
 212 \r
 213     @property\r
 214     def optionalgroup(self) -> TestAllTypes.OptionalGroup: ...\r
 215 \r
 216     @property\r
 217     def optional_nested_message(self) -> TestAllTypes.NestedMessage: ...\r
 218 \r
 219     @property\r
 220     def optional_foreign_message(self) -> ForeignMessage: ...\r
 221 \r
 222     @property\r
 223     def optional_import_message(self) -> ImportMessage: ...\r
 224 \r
 225     @property\r
 226     def optional_public_import_message(self) -> PublicImportMessage: ...\r
 227 \r
 228     @property\r
 229     def optional_lazy_message(self) -> TestAllTypes.NestedMessage: ...\r
 230 \r
 231     @property\r
 232     def repeatedgroup(\r
 233         self) -> RepeatedCompositeFieldContainer[TestAllTypes.RepeatedGroup]: ...\r
 234 \r
 235     @property\r
 236     def repeated_nested_message(\r
 237         self) -> RepeatedCompositeFieldContainer[TestAllTypes.NestedMessage]: ...\r
 238 \r
 239     @property\r
 240     def repeated_foreign_message(\r
 241         self) -> RepeatedCompositeFieldContainer[ForeignMessage]: ...\r
 242 \r
 243     @property\r
 244     def repeated_import_message(\r
 245         self) -> RepeatedCompositeFieldContainer[ImportMessage]: ...\r
 246 \r
 247     @property\r
 248     def repeated_lazy_message(\r
 249         self) -> RepeatedCompositeFieldContainer[TestAllTypes.NestedMessage]: ...\r
 250 \r
 251     @property\r
 252     def oneof_nested_message(self) -> TestAllTypes.NestedMessage: ...\r
 253 \r
 254     def __init__(self,\r
 255                  optional_int32: Optional[int] = ...,\r
 256                  optional_int64: Optional[int] = ...,\r
 257                  optional_uint32: Optional[int] = ...,\r
 258                  optional_uint64: Optional[int] = ...,\r
 259                  optional_sint32: Optional[int] = ...,\r
 260                  optional_sint64: Optional[int] = ...,\r
 261                  optional_fixed32: Optional[int] = ...,\r
 262                  optional_fixed64: Optional[int] = ...,\r
 263                  optional_sfixed32: Optional[int] = ...,\r
 264                  optional_sfixed64: Optional[int] = ...,\r
 265                  optional_float: Optional[float] = ...,\r
 266                  optional_double: Optional[float] = ...,\r
 267                  optional_bool: Optional[bool] = ...,\r
 268                  optional_string: Optional[Text] = ...,\r
 269                  optional_bytes: Optional[bytes] = ...,\r
 270                  optionalgroup: Optional[TestAllTypes.OptionalGroup] = ...,\r
 271                  optional_nested_message: Optional[TestAllTypes.NestedMessage] = ...,\r
 272                  optional_foreign_message: Optional[ForeignMessage] = ...,\r
 273                  optional_import_message: Optional[ImportMessage] = ...,\r
 274                  optional_nested_enum: Optional[TestAllTypes.NestedEnum] = ...,\r
 275                  optional_foreign_enum: Optional[ForeignEnum] = ...,\r
 276                  optional_import_enum: Optional[ImportEnum] = ...,\r
 277                  optional_string_piece: Optional[Text] = ...,\r
 278                  optional_cord: Optional[Text] = ...,\r
 279                  optional_public_import_message: Optional[PublicImportMessage] = ...,\r
 280                  optional_lazy_message: Optional[TestAllTypes.NestedMessage] = ...,\r
 281                  repeated_int32: Optional[Iterable[int]] = ...,\r
 282                  repeated_int64: Optional[Iterable[int]] = ...,\r
 283                  repeated_uint32: Optional[Iterable[int]] = ...,\r
 284                  repeated_uint64: Optional[Iterable[int]] = ...,\r
 285                  repeated_sint32: Optional[Iterable[int]] = ...,\r
 286                  repeated_sint64: Optional[Iterable[int]] = ...,\r
 287                  repeated_fixed32: Optional[Iterable[int]] = ...,\r
 288                  repeated_fixed64: Optional[Iterable[int]] = ...,\r
 289                  repeated_sfixed32: Optional[Iterable[int]] = ...,\r
 290                  repeated_sfixed64: Optional[Iterable[int]] = ...,\r
 291                  repeated_float: Optional[Iterable[float]] = ...,\r
 292                  repeated_double: Optional[Iterable[float]] = ...,\r
 293                  repeated_bool: Optional[Iterable[bool]] = ...,\r
 294                  repeated_string: Optional[Iterable[Text]] = ...,\r
 295                  repeated_bytes: Optional[Iterable[bytes]] = ...,\r
 296                  repeatedgroup: Optional[Iterable[TestAllTypes.RepeatedGroup]] = ...,\r
 297                  repeated_nested_message: Optional[Iterable[TestAllTypes.NestedMessage]] = ...,\r
 298                  repeated_foreign_message: Optional[Iterable[ForeignMessage]] = ...,\r
 299                  repeated_import_message: Optional[Iterable[ImportMessage]] = ...,\r
 300                  repeated_nested_enum: Optional[Iterable[TestAllTypes.NestedEnum]] = ...,\r
 301                  repeated_foreign_enum: Optional[Iterable[ForeignEnum]] = ...,\r
 302                  repeated_import_enum: Optional[Iterable[ImportEnum]] = ...,\r
 303                  repeated_string_piece: Optional[Iterable[Text]] = ...,\r
 304                  repeated_cord: Optional[Iterable[Text]] = ...,\r
 305                  repeated_lazy_message: Optional[Iterable[TestAllTypes.NestedMessage]] = ...,\r
 306                  default_int32: Optional[int] = ...,\r
 307                  default_int64: Optional[int] = ...,\r
 308                  default_uint32: Optional[int] = ...,\r
 309                  default_uint64: Optional[int] = ...,\r
 310                  default_sint32: Optional[int] = ...,\r
 311                  default_sint64: Optional[int] = ...,\r
 312                  default_fixed32: Optional[int] = ...,\r
 313                  default_fixed64: Optional[int] = ...,\r
 314                  default_sfixed32: Optional[int] = ...,\r
 315                  default_sfixed64: Optional[int] = ...,\r
 316                  default_float: Optional[float] = ...,\r
 317                  default_double: Optional[float] = ...,\r
 318                  default_bool: Optional[bool] = ...,\r
 319                  default_string: Optional[Text] = ...,\r
 320                  default_bytes: Optional[bytes] = ...,\r
 321                  default_nested_enum: Optional[TestAllTypes.NestedEnum] = ...,\r
 322                  default_foreign_enum: Optional[ForeignEnum] = ...,\r
 323                  default_import_enum: Optional[ImportEnum] = ...,\r
 324                  default_string_piece: Optional[Text] = ...,\r
 325                  default_cord: Optional[Text] = ...,\r
 326                  oneof_uint32: Optional[int] = ...,\r
 327                  oneof_nested_message: Optional[TestAllTypes.NestedMessage] = ...,\r
 328                  oneof_string: Optional[Text] = ...,\r
 329                  oneof_bytes: Optional[bytes] = ...,\r
 330                  ) -> None: ...\r
 331 \r
 332     @classmethod\r
 333     def FromString(cls, s: bytes) -> TestAllTypes: ...\r
 334 \r
 335 \r
 336 class NestedTestAllTypes(Message):\r
 337 \r
 338     @property\r
 339     def child(self) -> NestedTestAllTypes: ...\r
 340 \r
 341     @property\r
 342     def payload(self) -> TestAllTypes: ...\r
 343 \r
 344     @property\r
 345     def repeated_child(\r
 346         self) -> RepeatedCompositeFieldContainer[NestedTestAllTypes]: ...\r
 347 \r
 348     def __init__(self,\r
 349                  child: Optional[NestedTestAllTypes] = ...,\r
 350                  payload: Optional[TestAllTypes] = ...,\r
 351                  repeated_child: Optional[Iterable[NestedTestAllTypes]] = ...,\r
 352                  ) -> None: ...\r
 353 \r
 354     @classmethod\r
 355     def FromString(cls, s: bytes) -> NestedTestAllTypes: ...\r
 356 \r
 357 \r
 358 class TestDeprecatedFields(Message):\r
 359     deprecated_int32 = ...  # type: int\r
 360     deprecated_int32_in_oneof = ...  # type: int\r
 361 \r
 362     def __init__(self,\r
 363                  deprecated_int32: Optional[int] = ...,\r
 364                  deprecated_int32_in_oneof: Optional[int] = ...,\r
 365                  ) -> None: ...\r
 366 \r
 367     @classmethod\r
 368     def FromString(cls, s: bytes) -> TestDeprecatedFields: ...\r
 369 \r
 370 \r
 371 class TestDeprecatedMessage(Message):\r
 372 \r
 373     def __init__(self,\r
 374                  ) -> None: ...\r
 375 \r
 376     @classmethod\r
 377     def FromString(cls, s: bytes) -> TestDeprecatedMessage: ...\r
 378 \r
 379 \r
 380 class ForeignMessage(Message):\r
 381     c = ...  # type: int\r
 382     d = ...  # type: int\r
 383 \r
 384     def __init__(self,\r
 385                  c: Optional[int] = ...,\r
 386                  d: Optional[int] = ...,\r
 387                  ) -> None: ...\r
 388 \r
 389     @classmethod\r
 390     def FromString(cls, s: bytes) -> ForeignMessage: ...\r
 391 \r
 392 \r
 393 class TestReservedFields(Message):\r
 394 \r
 395     def __init__(self,\r
 396                  ) -> None: ...\r
 397 \r
 398     @classmethod\r
 399     def FromString(cls, s: bytes) -> TestReservedFields: ...\r
 400 \r
 401 \r
 402 class TestAllExtensions(Message):\r
 403 \r
 404     def __init__(self,\r
 405                  ) -> None: ...\r
 406 \r
 407     @classmethod\r
 408     def FromString(cls, s: bytes) -> TestAllExtensions: ...\r
 409 \r
 410 \r
 411 class OptionalGroup_extension(Message):\r
 412     a = ...  # type: int\r
 413 \r
 414     def __init__(self,\r
 415                  a: Optional[int] = ...,\r
 416                  ) -> None: ...\r
 417 \r
 418     @classmethod\r
 419     def FromString(cls, s: bytes) -> OptionalGroup_extension: ...\r
 420 \r
 421 \r
 422 class RepeatedGroup_extension(Message):\r
 423     a = ...  # type: int\r
 424 \r
 425     def __init__(self,\r
 426                  a: Optional[int] = ...,\r
 427                  ) -> None: ...\r
 428 \r
 429     @classmethod\r
 430     def FromString(cls, s: bytes) -> RepeatedGroup_extension: ...\r
 431 \r
 432 \r
 433 class TestGroup(Message):\r
 434     class OptionalGroup(Message):\r
 435         a = ...  # type: int\r
 436 \r
 437         def __init__(self,\r
 438                      a: Optional[int] = ...,\r
 439                      ) -> None: ...\r
 440 \r
 441         @classmethod\r
 442         def FromString(cls, s: bytes) -> TestGroup.OptionalGroup: ...\r
 443     optional_foreign_enum = ...  # type: ForeignEnum\r
 444 \r
 445     @property\r
 446     def optionalgroup(self) -> TestGroup.OptionalGroup: ...\r
 447 \r
 448     def __init__(self,\r
 449                  optionalgroup: Optional[TestGroup.OptionalGroup] = ...,\r
 450                  optional_foreign_enum: Optional[ForeignEnum] = ...,\r
 451                  ) -> None: ...\r
 452 \r
 453     @classmethod\r
 454     def FromString(cls, s: bytes) -> TestGroup: ...\r
 455 \r
 456 \r
 457 class TestGroupExtension(Message):\r
 458 \r
 459     def __init__(self,\r
 460                  ) -> None: ...\r
 461 \r
 462     @classmethod\r
 463     def FromString(cls, s: bytes) -> TestGroupExtension: ...\r
 464 \r
 465 \r
 466 class TestNestedExtension(Message):\r
 467     class OptionalGroup_extension(Message):\r
 468         a = ...  # type: int\r
 469 \r
 470         def __init__(self,\r
 471                      a: Optional[int] = ...,\r
 472                      ) -> None: ...\r
 473 \r
 474         @classmethod\r
 475         def FromString(\r
 476             cls, s: bytes) -> TestNestedExtension.OptionalGroup_extension: ...\r
 477 \r
 478     def __init__(self,\r
 479                  ) -> None: ...\r
 480 \r
 481     @classmethod\r
 482     def FromString(cls, s: bytes) -> TestNestedExtension: ...\r
 483 \r
 484 \r
 485 class TestRequired(Message):\r
 486     a = ...  # type: int\r
 487     dummy2 = ...  # type: int\r
 488     b = ...  # type: int\r
 489     dummy4 = ...  # type: int\r
 490     dummy5 = ...  # type: int\r
 491     dummy6 = ...  # type: int\r
 492     dummy7 = ...  # type: int\r
 493     dummy8 = ...  # type: int\r
 494     dummy9 = ...  # type: int\r
 495     dummy10 = ...  # type: int\r
 496     dummy11 = ...  # type: int\r
 497     dummy12 = ...  # type: int\r
 498     dummy13 = ...  # type: int\r
 499     dummy14 = ...  # type: int\r
 500     dummy15 = ...  # type: int\r
 501     dummy16 = ...  # type: int\r
 502     dummy17 = ...  # type: int\r
 503     dummy18 = ...  # type: int\r
 504     dummy19 = ...  # type: int\r
 505     dummy20 = ...  # type: int\r
 506     dummy21 = ...  # type: int\r
 507     dummy22 = ...  # type: int\r
 508     dummy23 = ...  # type: int\r
 509     dummy24 = ...  # type: int\r
 510     dummy25 = ...  # type: int\r
 511     dummy26 = ...  # type: int\r
 512     dummy27 = ...  # type: int\r
 513     dummy28 = ...  # type: int\r
 514     dummy29 = ...  # type: int\r
 515     dummy30 = ...  # type: int\r
 516     dummy31 = ...  # type: int\r
 517     dummy32 = ...  # type: int\r
 518     c = ...  # type: int\r
 519 \r
 520     def __init__(self,\r
 521                  a: int,\r
 522                  b: int,\r
 523                  c: int,\r
 524                  dummy2: Optional[int] = ...,\r
 525                  dummy4: Optional[int] = ...,\r
 526                  dummy5: Optional[int] = ...,\r
 527                  dummy6: Optional[int] = ...,\r
 528                  dummy7: Optional[int] = ...,\r
 529                  dummy8: Optional[int] = ...,\r
 530                  dummy9: Optional[int] = ...,\r
 531                  dummy10: Optional[int] = ...,\r
 532                  dummy11: Optional[int] = ...,\r
 533                  dummy12: Optional[int] = ...,\r
 534                  dummy13: Optional[int] = ...,\r
 535                  dummy14: Optional[int] = ...,\r
 536                  dummy15: Optional[int] = ...,\r
 537                  dummy16: Optional[int] = ...,\r
 538                  dummy17: Optional[int] = ...,\r
 539                  dummy18: Optional[int] = ...,\r
 540                  dummy19: Optional[int] = ...,\r
 541                  dummy20: Optional[int] = ...,\r
 542                  dummy21: Optional[int] = ...,\r
 543                  dummy22: Optional[int] = ...,\r
 544                  dummy23: Optional[int] = ...,\r
 545                  dummy24: Optional[int] = ...,\r
 546                  dummy25: Optional[int] = ...,\r
 547                  dummy26: Optional[int] = ...,\r
 548                  dummy27: Optional[int] = ...,\r
 549                  dummy28: Optional[int] = ...,\r
 550                  dummy29: Optional[int] = ...,\r
 551                  dummy30: Optional[int] = ...,\r
 552                  dummy31: Optional[int] = ...,\r
 553                  dummy32: Optional[int] = ...,\r
 554                  ) -> None: ...\r
 555 \r
 556     @classmethod\r
 557     def FromString(cls, s: bytes) -> TestRequired: ...\r
 558 \r
 559 \r
 560 class TestRequiredForeign(Message):\r
 561     dummy = ...  # type: int\r
 562 \r
 563     @property\r
 564     def optional_message(self) -> TestRequired: ...\r
 565 \r
 566     @property\r
 567     def repeated_message(\r
 568         self) -> RepeatedCompositeFieldContainer[TestRequired]: ...\r
 569 \r
 570     def __init__(self,\r
 571                  optional_message: Optional[TestRequired] = ...,\r
 572                  repeated_message: Optional[Iterable[TestRequired]] = ...,\r
 573                  dummy: Optional[int] = ...,\r
 574                  ) -> None: ...\r
 575 \r
 576     @classmethod\r
 577     def FromString(cls, s: bytes) -> TestRequiredForeign: ...\r
 578 \r
 579 \r
 580 class TestRequiredMessage(Message):\r
 581 \r
 582     @property\r
 583     def optional_message(self) -> TestRequired: ...\r
 584 \r
 585     @property\r
 586     def repeated_message(\r
 587         self) -> RepeatedCompositeFieldContainer[TestRequired]: ...\r
 588 \r
 589     @property\r
 590     def required_message(self) -> TestRequired: ...\r
 591 \r
 592     def __init__(self,\r
 593                  required_message: TestRequired,\r
 594                  optional_message: Optional[TestRequired] = ...,\r
 595                  repeated_message: Optional[Iterable[TestRequired]] = ...,\r
 596                  ) -> None: ...\r
 597 \r
 598     @classmethod\r
 599     def FromString(cls, s: bytes) -> TestRequiredMessage: ...\r
 600 \r
 601 \r
 602 class TestForeignNested(Message):\r
 603 \r
 604     @property\r
 605     def foreign_nested(self) -> TestAllTypes.NestedMessage: ...\r
 606 \r
 607     def __init__(self,\r
 608                  foreign_nested: Optional[TestAllTypes.NestedMessage] = ...,\r
 609                  ) -> None: ...\r
 610 \r
 611     @classmethod\r
 612     def FromString(cls, s: bytes) -> TestForeignNested: ...\r
 613 \r
 614 \r
 615 class TestEmptyMessage(Message):\r
 616 \r
 617     def __init__(self,\r
 618                  ) -> None: ...\r
 619 \r
 620     @classmethod\r
 621     def FromString(cls, s: bytes) -> TestEmptyMessage: ...\r
 622 \r
 623 \r
 624 class TestEmptyMessageWithExtensions(Message):\r
 625 \r
 626     def __init__(self,\r
 627                  ) -> None: ...\r
 628 \r
 629     @classmethod\r
 630     def FromString(cls, s: bytes) -> TestEmptyMessageWithExtensions: ...\r
 631 \r
 632 \r
 633 class TestMultipleExtensionRanges(Message):\r
 634 \r
 635     def __init__(self,\r
 636                  ) -> None: ...\r
 637 \r
 638     @classmethod\r
 639     def FromString(cls, s: bytes) -> TestMultipleExtensionRanges: ...\r
 640 \r
 641 \r
 642 class TestReallyLargeTagNumber(Message):\r
 643     a = ...  # type: int\r
 644     bb = ...  # type: int\r
 645 \r
 646     def __init__(self,\r
 647                  a: Optional[int] = ...,\r
 648                  bb: Optional[int] = ...,\r
 649                  ) -> None: ...\r
 650 \r
 651     @classmethod\r
 652     def FromString(cls, s: bytes) -> TestReallyLargeTagNumber: ...\r
 653 \r
 654 \r
 655 class TestRecursiveMessage(Message):\r
 656     i = ...  # type: int\r
 657 \r
 658     @property\r
 659     def a(self) -> TestRecursiveMessage: ...\r
 660 \r
 661     def __init__(self,\r
 662                  a: Optional[TestRecursiveMessage] = ...,\r
 663                  i: Optional[int] = ...,\r
 664                  ) -> None: ...\r
 665 \r
 666     @classmethod\r
 667     def FromString(cls, s: bytes) -> TestRecursiveMessage: ...\r
 668 \r
 669 \r
 670 class TestMutualRecursionA(Message):\r
 671     class SubMessage(Message):\r
 672 \r
 673         @property\r
 674         def b(self) -> TestMutualRecursionB: ...\r
 675 \r
 676         def __init__(self,\r
 677                      b: Optional[TestMutualRecursionB] = ...,\r
 678                      ) -> None: ...\r
 679 \r
 680         @classmethod\r
 681         def FromString(cls, s: bytes) -> TestMutualRecursionA.SubMessage: ...\r
 682 \r
 683     class SubGroup(Message):\r
 684 \r
 685         @property\r
 686         def sub_message(self) -> TestMutualRecursionA.SubMessage: ...\r
 687 \r
 688         @property\r
 689         def not_in_this_scc(self) -> TestAllTypes: ...\r
 690 \r
 691         def __init__(self,\r
 692                      sub_message: Optional[TestMutualRecursionA.SubMessage] = ...,\r
 693                      not_in_this_scc: Optional[TestAllTypes] = ...,\r
 694                      ) -> None: ...\r
 695 \r
 696         @classmethod\r
 697         def FromString(cls, s: bytes) -> TestMutualRecursionA.SubGroup: ...\r
 698 \r
 699     @property\r
 700     def bb(self) -> TestMutualRecursionB: ...\r
 701 \r
 702     @property\r
 703     def subgroup(self) -> TestMutualRecursionA.SubGroup: ...\r
 704 \r
 705     def __init__(self,\r
 706                  bb: Optional[TestMutualRecursionB] = ...,\r
 707                  subgroup: Optional[TestMutualRecursionA.SubGroup] = ...,\r
 708                  ) -> None: ...\r
 709 \r
 710     @classmethod\r
 711     def FromString(cls, s: bytes) -> TestMutualRecursionA: ...\r
 712 \r
 713 \r
 714 class TestMutualRecursionB(Message):\r
 715     optional_int32 = ...  # type: int\r
 716 \r
 717     @property\r
 718     def a(self) -> TestMutualRecursionA: ...\r
 719 \r
 720     def __init__(self,\r
 721                  a: Optional[TestMutualRecursionA] = ...,\r
 722                  optional_int32: Optional[int] = ...,\r
 723                  ) -> None: ...\r
 724 \r
 725     @classmethod\r
 726     def FromString(cls, s: bytes) -> TestMutualRecursionB: ...\r
 727 \r
 728 \r
 729 class TestIsInitialized(Message):\r
 730     class SubMessage(Message):\r
 731         class SubGroup(Message):\r
 732             i = ...  # type: int\r
 733 \r
 734             def __init__(self,\r
 735                          i: int,\r
 736                          ) -> None: ...\r
 737 \r
 738             @classmethod\r
 739             def FromString(\r
 740                 cls, s: bytes) -> TestIsInitialized.SubMessage.SubGroup: ...\r
 741 \r
 742         @property\r
 743         def subgroup(self) -> TestIsInitialized.SubMessage.SubGroup: ...\r
 744 \r
 745         def __init__(self,\r
 746                      subgroup: Optional[TestIsInitialized.SubMessage.SubGroup] = ...,\r
 747                      ) -> None: ...\r
 748 \r
 749         @classmethod\r
 750         def FromString(cls, s: bytes) -> TestIsInitialized.SubMessage: ...\r
 751 \r
 752     @property\r
 753     def sub_message(self) -> TestIsInitialized.SubMessage: ...\r
 754 \r
 755     def __init__(self,\r
 756                  sub_message: Optional[TestIsInitialized.SubMessage] = ...,\r
 757                  ) -> None: ...\r
 758 \r
 759     @classmethod\r
 760     def FromString(cls, s: bytes) -> TestIsInitialized: ...\r
 761 \r
 762 \r
 763 class TestDupFieldNumber(Message):\r
 764     class Foo(Message):\r
 765         a = ...  # type: int\r
 766 \r
 767         def __init__(self,\r
 768                      a: Optional[int] = ...,\r
 769                      ) -> None: ...\r
 770 \r
 771         @classmethod\r
 772         def FromString(cls, s: bytes) -> TestDupFieldNumber.Foo: ...\r
 773 \r
 774     class Bar(Message):\r
 775         a = ...  # type: int\r
 776 \r
 777         def __init__(self,\r
 778                      a: Optional[int] = ...,\r
 779                      ) -> None: ...\r
 780 \r
 781         @classmethod\r
 782         def FromString(cls, s: bytes) -> TestDupFieldNumber.Bar: ...\r
 783     a = ...  # type: int\r
 784 \r
 785     @property\r
 786     def foo(self) -> TestDupFieldNumber.Foo: ...\r
 787 \r
 788     @property\r
 789     def bar(self) -> TestDupFieldNumber.Bar: ...\r
 790 \r
 791     def __init__(self,\r
 792                  a: Optional[int] = ...,\r
 793                  foo: Optional[TestDupFieldNumber.Foo] = ...,\r
 794                  bar: Optional[TestDupFieldNumber.Bar] = ...,\r
 795                  ) -> None: ...\r
 796 \r
 797     @classmethod\r
 798     def FromString(cls, s: bytes) -> TestDupFieldNumber: ...\r
 799 \r
 800 \r
 801 class TestEagerMessage(Message):\r
 802 \r
 803     @property\r
 804     def sub_message(self) -> TestAllTypes: ...\r
 805 \r
 806     def __init__(self,\r
 807                  sub_message: Optional[TestAllTypes] = ...,\r
 808                  ) -> None: ...\r
 809 \r
 810     @classmethod\r
 811     def FromString(cls, s: bytes) -> TestEagerMessage: ...\r
 812 \r
 813 \r
 814 class TestLazyMessage(Message):\r
 815 \r
 816     @property\r
 817     def sub_message(self) -> TestAllTypes: ...\r
 818 \r
 819     def __init__(self,\r
 820                  sub_message: Optional[TestAllTypes] = ...,\r
 821                  ) -> None: ...\r
 822 \r
 823     @classmethod\r
 824     def FromString(cls, s: bytes) -> TestLazyMessage: ...\r
 825 \r
 826 \r
 827 class TestNestedMessageHasBits(Message):\r
 828     class NestedMessage(Message):\r
 829         nestedmessage_repeated_int32 = ...  # type: RepeatedScalarFieldContainer[int]\r
 830 \r
 831         @property\r
 832         def nestedmessage_repeated_foreignmessage(\r
 833             self) -> RepeatedCompositeFieldContainer[ForeignMessage]: ...\r
 834 \r
 835         def __init__(self,\r
 836                      nestedmessage_repeated_int32: Optional[Iterable[int]] = ...,\r
 837                      nestedmessage_repeated_foreignmessage: Optional[Iterable[ForeignMessage]] = ...,\r
 838                      ) -> None: ...\r
 839 \r
 840         @classmethod\r
 841         def FromString(\r
 842             cls, s: bytes) -> TestNestedMessageHasBits.NestedMessage: ...\r
 843 \r
 844     @property\r
 845     def optional_nested_message(\r
 846         self) -> TestNestedMessageHasBits.NestedMessage: ...\r
 847 \r
 848     def __init__(self,\r
 849                  optional_nested_message: Optional[TestNestedMessageHasBits.NestedMessage] = ...,\r
 850                  ) -> None: ...\r
 851 \r
 852     @classmethod\r
 853     def FromString(cls, s: bytes) -> TestNestedMessageHasBits: ...\r
 854 \r
 855 \r
 856 class TestCamelCaseFieldNames(Message):\r
 857     PrimitiveField = ...  # type: int\r
 858     StringField = ...  # type: Text\r
 859     EnumField = ...  # type: ForeignEnum\r
 860     StringPieceField = ...  # type: Text\r
 861     CordField = ...  # type: Text\r
 862     RepeatedPrimitiveField = ...  # type: RepeatedScalarFieldContainer[int]\r
 863     RepeatedStringField = ...  # type: RepeatedScalarFieldContainer[Text]\r
 864     RepeatedEnumField = ...  # type: RepeatedScalarFieldContainer[ForeignEnum]\r
 865     RepeatedStringPieceField = ...  # type: RepeatedScalarFieldContainer[Text]\r
 866     RepeatedCordField = ...  # type: RepeatedScalarFieldContainer[Text]\r
 867 \r
 868     @property\r
 869     def MessageField(self) -> ForeignMessage: ...\r
 870 \r
 871     @property\r
 872     def RepeatedMessageField(\r
 873         self) -> RepeatedCompositeFieldContainer[ForeignMessage]: ...\r
 874 \r
 875     def __init__(self,\r
 876                  PrimitiveField: Optional[int] = ...,\r
 877                  StringField: Optional[Text] = ...,\r
 878                  EnumField: Optional[ForeignEnum] = ...,\r
 879                  MessageField: Optional[ForeignMessage] = ...,\r
 880                  StringPieceField: Optional[Text] = ...,\r
 881                  CordField: Optional[Text] = ...,\r
 882                  RepeatedPrimitiveField: Optional[Iterable[int]] = ...,\r
 883                  RepeatedStringField: Optional[Iterable[Text]] = ...,\r
 884                  RepeatedEnumField: Optional[Iterable[ForeignEnum]] = ...,\r
 885                  RepeatedMessageField: Optional[Iterable[ForeignMessage]] = ...,\r
 886                  RepeatedStringPieceField: Optional[Iterable[Text]] = ...,\r
 887                  RepeatedCordField: Optional[Iterable[Text]] = ...,\r
 888                  ) -> None: ...\r
 889 \r
 890     @classmethod\r
 891     def FromString(cls, s: bytes) -> TestCamelCaseFieldNames: ...\r
 892 \r
 893 \r
 894 class TestFieldOrderings(Message):\r
 895     class NestedMessage(Message):\r
 896         oo = ...  # type: int\r
 897         bb = ...  # type: int\r
 898 \r
 899         def __init__(self,\r
 900                      oo: Optional[int] = ...,\r
 901                      bb: Optional[int] = ...,\r
 902                      ) -> None: ...\r
 903 \r
 904         @classmethod\r
 905         def FromString(cls, s: bytes) -> TestFieldOrderings.NestedMessage: ...\r
 906     my_string = ...  # type: Text\r
 907     my_int = ...  # type: int\r
 908     my_float = ...  # type: float\r
 909 \r
 910     @property\r
 911     def optional_nested_message(self) -> TestFieldOrderings.NestedMessage: ...\r
 912 \r
 913     def __init__(self,\r
 914                  my_string: Optional[Text] = ...,\r
 915                  my_int: Optional[int] = ...,\r
 916                  my_float: Optional[float] = ...,\r
 917                  optional_nested_message: Optional[TestFieldOrderings.NestedMessage] = ...,\r
 918                  ) -> None: ...\r
 919 \r
 920     @classmethod\r
 921     def FromString(cls, s: bytes) -> TestFieldOrderings: ...\r
 922 \r
 923 \r
 924 class TestExtensionOrderings1(Message):\r
 925     my_string = ...  # type: Text\r
 926 \r
 927     def __init__(self,\r
 928                  my_string: Optional[Text] = ...,\r
 929                  ) -> None: ...\r
 930 \r
 931     @classmethod\r
 932     def FromString(cls, s: bytes) -> TestExtensionOrderings1: ...\r
 933 \r
 934 \r
 935 class TestExtensionOrderings2(Message):\r
 936     class TestExtensionOrderings3(Message):\r
 937         my_string = ...  # type: Text\r
 938 \r
 939         def __init__(self,\r
 940                      my_string: Optional[Text] = ...,\r
 941                      ) -> None: ...\r
 942 \r
 943         @classmethod\r
 944         def FromString(\r
 945             cls, s: bytes) -> TestExtensionOrderings2.TestExtensionOrderings3: ...\r
 946     my_string = ...  # type: Text\r
 947 \r
 948     def __init__(self,\r
 949                  my_string: Optional[Text] = ...,\r
 950                  ) -> None: ...\r
 951 \r
 952     @classmethod\r
 953     def FromString(cls, s: bytes) -> TestExtensionOrderings2: ...\r
 954 \r
 955 \r
 956 class TestExtremeDefaultValues(Message):\r
 957     escaped_bytes = ...  # type: bytes\r
 958     large_uint32 = ...  # type: int\r
 959     large_uint64 = ...  # type: int\r
 960     small_int32 = ...  # type: int\r
 961     small_int64 = ...  # type: int\r
 962     really_small_int32 = ...  # type: int\r
 963     really_small_int64 = ...  # type: int\r
 964     utf8_string = ...  # type: Text\r
 965     zero_float = ...  # type: float\r
 966     one_float = ...  # type: float\r
 967     small_float = ...  # type: float\r
 968     negative_one_float = ...  # type: float\r
 969     negative_float = ...  # type: float\r
 970     large_float = ...  # type: float\r
 971     small_negative_float = ...  # type: float\r
 972     inf_double = ...  # type: float\r
 973     neg_inf_double = ...  # type: float\r
 974     nan_double = ...  # type: float\r
 975     inf_float = ...  # type: float\r
 976     neg_inf_float = ...  # type: float\r
 977     nan_float = ...  # type: float\r
 978     cpp_trigraph = ...  # type: Text\r
 979     string_with_zero = ...  # type: Text\r
 980     bytes_with_zero = ...  # type: bytes\r
 981     string_piece_with_zero = ...  # type: Text\r
 982     cord_with_zero = ...  # type: Text\r
 983     replacement_string = ...  # type: Text\r
 984 \r
 985     def __init__(self,\r
 986                  escaped_bytes: Optional[bytes] = ...,\r
 987                  large_uint32: Optional[int] = ...,\r
 988                  large_uint64: Optional[int] = ...,\r
 989                  small_int32: Optional[int] = ...,\r
 990                  small_int64: Optional[int] = ...,\r
 991                  really_small_int32: Optional[int] = ...,\r
 992                  really_small_int64: Optional[int] = ...,\r
 993                  utf8_string: Optional[Text] = ...,\r
 994                  zero_float: Optional[float] = ...,\r
 995                  one_float: Optional[float] = ...,\r
 996                  small_float: Optional[float] = ...,\r
 997                  negative_one_float: Optional[float] = ...,\r
 998                  negative_float: Optional[float] = ...,\r
 999                  large_float: Optional[float] = ...,\r
1000                  small_negative_float: Optional[float] = ...,\r
1001                  inf_double: Optional[float] = ...,\r
1002                  neg_inf_double: Optional[float] = ...,\r
1003                  nan_double: Optional[float] = ...,\r
1004                  inf_float: Optional[float] = ...,\r
1005                  neg_inf_float: Optional[float] = ...,\r
1006                  nan_float: Optional[float] = ...,\r
1007                  cpp_trigraph: Optional[Text] = ...,\r
1008                  string_with_zero: Optional[Text] = ...,\r
1009                  bytes_with_zero: Optional[bytes] = ...,\r
1010                  string_piece_with_zero: Optional[Text] = ...,\r
1011                  cord_with_zero: Optional[Text] = ...,\r
1012                  replacement_string: Optional[Text] = ...,\r
1013                  ) -> None: ...\r
1014 \r
1015     @classmethod\r
1016     def FromString(cls, s: bytes) -> TestExtremeDefaultValues: ...\r
1017 \r
1018 \r
1019 class SparseEnumMessage(Message):\r
1020     sparse_enum = ...  # type: TestSparseEnum\r
1021 \r
1022     def __init__(self,\r
1023                  sparse_enum: Optional[TestSparseEnum] = ...,\r
1024                  ) -> None: ...\r
1025 \r
1026     @classmethod\r
1027     def FromString(cls, s: bytes) -> SparseEnumMessage: ...\r
1028 \r
1029 \r
1030 class OneString(Message):\r
1031     data = ...  # type: Text\r
1032 \r
1033     def __init__(self,\r
1034                  data: Optional[Text] = ...,\r
1035                  ) -> None: ...\r
1036 \r
1037     @classmethod\r
1038     def FromString(cls, s: bytes) -> OneString: ...\r
1039 \r
1040 \r
1041 class MoreString(Message):\r
1042     data = ...  # type: RepeatedScalarFieldContainer[Text]\r
1043 \r
1044     def __init__(self,\r
1045                  data: Optional[Iterable[Text]] = ...,\r
1046                  ) -> None: ...\r
1047 \r
1048     @classmethod\r
1049     def FromString(cls, s: bytes) -> MoreString: ...\r
1050 \r
1051 \r
1052 class OneBytes(Message):\r
1053     data = ...  # type: bytes\r
1054 \r
1055     def __init__(self,\r
1056                  data: Optional[bytes] = ...,\r
1057                  ) -> None: ...\r
1058 \r
1059     @classmethod\r
1060     def FromString(cls, s: bytes) -> OneBytes: ...\r
1061 \r
1062 \r
1063 class MoreBytes(Message):\r
1064     data = ...  # type: RepeatedScalarFieldContainer[bytes]\r
1065 \r
1066     def __init__(self,\r
1067                  data: Optional[Iterable[bytes]] = ...,\r
1068                  ) -> None: ...\r
1069 \r
1070     @classmethod\r
1071     def FromString(cls, s: bytes) -> MoreBytes: ...\r
1072 \r
1073 \r
1074 class Int32Message(Message):\r
1075     data = ...  # type: int\r
1076 \r
1077     def __init__(self,\r
1078                  data: Optional[int] = ...,\r
1079                  ) -> None: ...\r
1080 \r
1081     @classmethod\r
1082     def FromString(cls, s: bytes) -> Int32Message: ...\r
1083 \r
1084 \r
1085 class Uint32Message(Message):\r
1086     data = ...  # type: int\r
1087 \r
1088     def __init__(self,\r
1089                  data: Optional[int] = ...,\r
1090                  ) -> None: ...\r
1091 \r
1092     @classmethod\r
1093     def FromString(cls, s: bytes) -> Uint32Message: ...\r
1094 \r
1095 \r
1096 class Int64Message(Message):\r
1097     data = ...  # type: int\r
1098 \r
1099     def __init__(self,\r
1100                  data: Optional[int] = ...,\r
1101                  ) -> None: ...\r
1102 \r
1103     @classmethod\r
1104     def FromString(cls, s: bytes) -> Int64Message: ...\r
1105 \r
1106 \r
1107 class Uint64Message(Message):\r
1108     data = ...  # type: int\r
1109 \r
1110     def __init__(self,\r
1111                  data: Optional[int] = ...,\r
1112                  ) -> None: ...\r
1113 \r
1114     @classmethod\r
1115     def FromString(cls, s: bytes) -> Uint64Message: ...\r
1116 \r
1117 \r
1118 class BoolMessage(Message):\r
1119     data = ...  # type: bool\r
1120 \r
1121     def __init__(self,\r
1122                  data: Optional[bool] = ...,\r
1123                  ) -> None: ...\r
1124 \r
1125     @classmethod\r
1126     def FromString(cls, s: bytes) -> BoolMessage: ...\r
1127 \r
1128 \r
1129 class TestOneof(Message):\r
1130     class FooGroup(Message):\r
1131         a = ...  # type: int\r
1132         b = ...  # type: Text\r
1133 \r
1134         def __init__(self,\r
1135                      a: Optional[int] = ...,\r
1136                      b: Optional[Text] = ...,\r
1137                      ) -> None: ...\r
1138 \r
1139         @classmethod\r
1140         def FromString(cls, s: bytes) -> TestOneof.FooGroup: ...\r
1141     foo_int = ...  # type: int\r
1142     foo_string = ...  # type: Text\r
1143 \r
1144     @property\r
1145     def foo_message(self) -> TestAllTypes: ...\r
1146 \r
1147     @property\r
1148     def foogroup(self) -> TestOneof.FooGroup: ...\r
1149 \r
1150     def __init__(self,\r
1151                  foo_int: Optional[int] = ...,\r
1152                  foo_string: Optional[Text] = ...,\r
1153                  foo_message: Optional[TestAllTypes] = ...,\r
1154                  foogroup: Optional[TestOneof.FooGroup] = ...,\r
1155                  ) -> None: ...\r
1156 \r
1157     @classmethod\r
1158     def FromString(cls, s: bytes) -> TestOneof: ...\r
1159 \r
1160 \r
1161 class TestOneofBackwardsCompatible(Message):\r
1162     class FooGroup(Message):\r
1163         a = ...  # type: int\r
1164         b = ...  # type: Text\r
1165 \r
1166         def __init__(self,\r
1167                      a: Optional[int] = ...,\r
1168                      b: Optional[Text] = ...,\r
1169                      ) -> None: ...\r
1170 \r
1171         @classmethod\r
1172         def FromString(\r
1173             cls, s: bytes) -> TestOneofBackwardsCompatible.FooGroup: ...\r
1174     foo_int = ...  # type: int\r
1175     foo_string = ...  # type: Text\r
1176 \r
1177     @property\r
1178     def foo_message(self) -> TestAllTypes: ...\r
1179 \r
1180     @property\r
1181     def foogroup(self) -> TestOneofBackwardsCompatible.FooGroup: ...\r
1182 \r
1183     def __init__(self,\r
1184                  foo_int: Optional[int] = ...,\r
1185                  foo_string: Optional[Text] = ...,\r
1186                  foo_message: Optional[TestAllTypes] = ...,\r
1187                  foogroup: Optional[TestOneofBackwardsCompatible.FooGroup] = ...,\r
1188                  ) -> None: ...\r
1189 \r
1190     @classmethod\r
1191     def FromString(cls, s: bytes) -> TestOneofBackwardsCompatible: ...\r
1192 \r
1193 \r
1194 class TestOneof2(Message):\r
1195     class NestedEnum(int):\r
1196         @classmethod\r
1197         def Name(cls, number: int) -> bytes: ...\r
1198 \r
1199         @classmethod\r
1200         def Value(cls, name: bytes) -> TestOneof2.NestedEnum: ...\r
1201 \r
1202         @classmethod\r
1203         def keys(cls) -> List[bytes]: ...\r
1204 \r
1205         @classmethod\r
1206         def values(cls) -> List[TestOneof2.NestedEnum]: ...\r
1207 \r
1208         @classmethod\r
1209         def items(cls) -> List[Tuple[bytes, TestOneof2.NestedEnum]]: ...\r
1210     FOO: NestedEnum\r
1211     BAR: NestedEnum\r
1212     BAZ: NestedEnum\r
1213 \r
1214     class FooGroup(Message):\r
1215         a = ...  # type: int\r
1216         b = ...  # type: Text\r
1217 \r
1218         def __init__(self,\r
1219                      a: Optional[int] = ...,\r
1220                      b: Optional[Text] = ...,\r
1221                      ) -> None: ...\r
1222 \r
1223         @classmethod\r
1224         def FromString(cls, s: bytes) -> TestOneof2.FooGroup: ...\r
1225 \r
1226     class NestedMessage(Message):\r
1227         qux_int = ...  # type: int\r
1228         corge_int = ...  # type: RepeatedScalarFieldContainer[int]\r
1229 \r
1230         def __init__(self,\r
1231                      qux_int: Optional[int] = ...,\r
1232                      corge_int: Optional[Iterable[int]] = ...,\r
1233                      ) -> None: ...\r
1234 \r
1235         @classmethod\r
1236         def FromString(cls, s: bytes) -> TestOneof2.NestedMessage: ...\r
1237     foo_int = ...  # type: int\r
1238     foo_string = ...  # type: Text\r
1239     foo_cord = ...  # type: Text\r
1240     foo_string_piece = ...  # type: Text\r
1241     foo_bytes = ...  # type: bytes\r
1242     foo_enum = ...  # type: TestOneof2.NestedEnum\r
1243     bar_int = ...  # type: int\r
1244     bar_string = ...  # type: Text\r
1245     bar_cord = ...  # type: Text\r
1246     bar_string_piece = ...  # type: Text\r
1247     bar_bytes = ...  # type: bytes\r
1248     bar_enum = ...  # type: TestOneof2.NestedEnum\r
1249     baz_int = ...  # type: int\r
1250     baz_string = ...  # type: Text\r
1251 \r
1252     @property\r
1253     def foo_message(self) -> TestOneof2.NestedMessage: ...\r
1254 \r
1255     @property\r
1256     def foogroup(self) -> TestOneof2.FooGroup: ...\r
1257 \r
1258     @property\r
1259     def foo_lazy_message(self) -> TestOneof2.NestedMessage: ...\r
1260 \r
1261     def __init__(self,\r
1262                  foo_int: Optional[int] = ...,\r
1263                  foo_string: Optional[Text] = ...,\r
1264                  foo_cord: Optional[Text] = ...,\r
1265                  foo_string_piece: Optional[Text] = ...,\r
1266                  foo_bytes: Optional[bytes] = ...,\r
1267                  foo_enum: Optional[TestOneof2.NestedEnum] = ...,\r
1268                  foo_message: Optional[TestOneof2.NestedMessage] = ...,\r
1269                  foogroup: Optional[TestOneof2.FooGroup] = ...,\r
1270                  foo_lazy_message: Optional[TestOneof2.NestedMessage] = ...,\r
1271                  bar_int: Optional[int] = ...,\r
1272                  bar_string: Optional[Text] = ...,\r
1273                  bar_cord: Optional[Text] = ...,\r
1274                  bar_string_piece: Optional[Text] = ...,\r
1275                  bar_bytes: Optional[bytes] = ...,\r
1276                  bar_enum: Optional[TestOneof2.NestedEnum] = ...,\r
1277                  baz_int: Optional[int] = ...,\r
1278                  baz_string: Optional[Text] = ...,\r
1279                  ) -> None: ...\r
1280 \r
1281     @classmethod\r
1282     def FromString(cls, s: bytes) -> TestOneof2: ...\r
1283 \r
1284 \r
1285 class TestRequiredOneof(Message):\r
1286     class NestedMessage(Message):\r
1287         required_double = ...  # type: float\r
1288 \r
1289         def __init__(self,\r
1290                      required_double: float,\r
1291                      ) -> None: ...\r
1292 \r
1293         @classmethod\r
1294         def FromString(cls, s: bytes) -> TestRequiredOneof.NestedMessage: ...\r
1295     foo_int = ...  # type: int\r
1296     foo_string = ...  # type: Text\r
1297 \r
1298     @property\r
1299     def foo_message(self) -> TestRequiredOneof.NestedMessage: ...\r
1300 \r
1301     def __init__(self,\r
1302                  foo_int: Optional[int] = ...,\r
1303                  foo_string: Optional[Text] = ...,\r
1304                  foo_message: Optional[TestRequiredOneof.NestedMessage] = ...,\r
1305                  ) -> None: ...\r
1306 \r
1307     @classmethod\r
1308     def FromString(cls, s: bytes) -> TestRequiredOneof: ...\r
1309 \r
1310 \r
1311 class TestPackedTypes(Message):\r
1312     packed_int32 = ...  # type: RepeatedScalarFieldContainer[int]\r
1313     packed_int64 = ...  # type: RepeatedScalarFieldContainer[int]\r
1314     packed_uint32 = ...  # type: RepeatedScalarFieldContainer[int]\r
1315     packed_uint64 = ...  # type: RepeatedScalarFieldContainer[int]\r
1316     packed_sint32 = ...  # type: RepeatedScalarFieldContainer[int]\r
1317     packed_sint64 = ...  # type: RepeatedScalarFieldContainer[int]\r
1318     packed_fixed32 = ...  # type: RepeatedScalarFieldContainer[int]\r
1319     packed_fixed64 = ...  # type: RepeatedScalarFieldContainer[int]\r
1320     packed_sfixed32 = ...  # type: RepeatedScalarFieldContainer[int]\r
1321     packed_sfixed64 = ...  # type: RepeatedScalarFieldContainer[int]\r
1322     packed_float = ...  # type: RepeatedScalarFieldContainer[float]\r
1323     packed_double = ...  # type: RepeatedScalarFieldContainer[float]\r
1324     packed_bool = ...  # type: RepeatedScalarFieldContainer[bool]\r
1325     packed_enum = ...  # type: RepeatedScalarFieldContainer[ForeignEnum]\r
1326 \r
1327     def __init__(self,\r
1328                  packed_int32: Optional[Iterable[int]] = ...,\r
1329                  packed_int64: Optional[Iterable[int]] = ...,\r
1330                  packed_uint32: Optional[Iterable[int]] = ...,\r
1331                  packed_uint64: Optional[Iterable[int]] = ...,\r
1332                  packed_sint32: Optional[Iterable[int]] = ...,\r
1333                  packed_sint64: Optional[Iterable[int]] = ...,\r
1334                  packed_fixed32: Optional[Iterable[int]] = ...,\r
1335                  packed_fixed64: Optional[Iterable[int]] = ...,\r
1336                  packed_sfixed32: Optional[Iterable[int]] = ...,\r
1337                  packed_sfixed64: Optional[Iterable[int]] = ...,\r
1338                  packed_float: Optional[Iterable[float]] = ...,\r
1339                  packed_double: Optional[Iterable[float]] = ...,\r
1340                  packed_bool: Optional[Iterable[bool]] = ...,\r
1341                  packed_enum: Optional[Iterable[ForeignEnum]] = ...,\r
1342                  ) -> None: ...\r
1343 \r
1344     @classmethod\r
1345     def FromString(cls, s: bytes) -> TestPackedTypes: ...\r
1346 \r
1347 \r
1348 class TestUnpackedTypes(Message):\r
1349     unpacked_int32 = ...  # type: RepeatedScalarFieldContainer[int]\r
1350     unpacked_int64 = ...  # type: RepeatedScalarFieldContainer[int]\r
1351     unpacked_uint32 = ...  # type: RepeatedScalarFieldContainer[int]\r
1352     unpacked_uint64 = ...  # type: RepeatedScalarFieldContainer[int]\r
1353     unpacked_sint32 = ...  # type: RepeatedScalarFieldContainer[int]\r
1354     unpacked_sint64 = ...  # type: RepeatedScalarFieldContainer[int]\r
1355     unpacked_fixed32 = ...  # type: RepeatedScalarFieldContainer[int]\r
1356     unpacked_fixed64 = ...  # type: RepeatedScalarFieldContainer[int]\r
1357     unpacked_sfixed32 = ...  # type: RepeatedScalarFieldContainer[int]\r
1358     unpacked_sfixed64 = ...  # type: RepeatedScalarFieldContainer[int]\r
1359     unpacked_float = ...  # type: RepeatedScalarFieldContainer[float]\r
1360     unpacked_double = ...  # type: RepeatedScalarFieldContainer[float]\r
1361     unpacked_bool = ...  # type: RepeatedScalarFieldContainer[bool]\r
1362     unpacked_enum = ...  # type: RepeatedScalarFieldContainer[ForeignEnum]\r
1363 \r
1364     def __init__(self,\r
1365                  unpacked_int32: Optional[Iterable[int]] = ...,\r
1366                  unpacked_int64: Optional[Iterable[int]] = ...,\r
1367                  unpacked_uint32: Optional[Iterable[int]] = ...,\r
1368                  unpacked_uint64: Optional[Iterable[int]] = ...,\r
1369                  unpacked_sint32: Optional[Iterable[int]] = ...,\r
1370                  unpacked_sint64: Optional[Iterable[int]] = ...,\r
1371                  unpacked_fixed32: Optional[Iterable[int]] = ...,\r
1372                  unpacked_fixed64: Optional[Iterable[int]] = ...,\r
1373                  unpacked_sfixed32: Optional[Iterable[int]] = ...,\r
1374                  unpacked_sfixed64: Optional[Iterable[int]] = ...,\r
1375                  unpacked_float: Optional[Iterable[float]] = ...,\r
1376                  unpacked_double: Optional[Iterable[float]] = ...,\r
1377                  unpacked_bool: Optional[Iterable[bool]] = ...,\r
1378                  unpacked_enum: Optional[Iterable[ForeignEnum]] = ...,\r
1379                  ) -> None: ...\r
1380 \r
1381     @classmethod\r
1382     def FromString(cls, s: bytes) -> TestUnpackedTypes: ...\r
1383 \r
1384 \r
1385 class TestPackedExtensions(Message):\r
1386 \r
1387     def __init__(self,\r
1388                  ) -> None: ...\r
1389 \r
1390     @classmethod\r
1391     def FromString(cls, s: bytes) -> TestPackedExtensions: ...\r
1392 \r
1393 \r
1394 class TestUnpackedExtensions(Message):\r
1395 \r
1396     def __init__(self,\r
1397                  ) -> None: ...\r
1398 \r
1399     @classmethod\r
1400     def FromString(cls, s: bytes) -> TestUnpackedExtensions: ...\r
1401 \r
1402 \r
1403 class TestDynamicExtensions(Message):\r
1404     class DynamicEnumType(int):\r
1405         @classmethod\r
1406         def Name(cls, number: int) -> bytes: ...\r
1407 \r
1408         @classmethod\r
1409         def Value(cls, name: bytes) -> TestDynamicExtensions.DynamicEnumType: ...\r
1410 \r
1411         @classmethod\r
1412         def keys(cls) -> List[bytes]: ...\r
1413 \r
1414         @classmethod\r
1415         def values(cls) -> List[TestDynamicExtensions.DynamicEnumType]: ...\r
1416 \r
1417         @classmethod\r
1418         def items(cls) -> List[Tuple[bytes,\r
1419                                      TestDynamicExtensions.DynamicEnumType]]: ...\r
1420     DYNAMIC_FOO: DynamicEnumType\r
1421     DYNAMIC_BAR: DynamicEnumType\r
1422     DYNAMIC_BAZ: DynamicEnumType\r
1423 \r
1424     class DynamicMessageType(Message):\r
1425         dynamic_field = ...  # type: int\r
1426 \r
1427         def __init__(self,\r
1428                      dynamic_field: Optional[int] = ...,\r
1429                      ) -> None: ...\r
1430 \r
1431         @classmethod\r
1432         def FromString(\r
1433             cls, s: bytes) -> TestDynamicExtensions.DynamicMessageType: ...\r
1434     scalar_extension = ...  # type: int\r
1435     enum_extension = ...  # type: ForeignEnum\r
1436     dynamic_enum_extension = ...  # type: TestDynamicExtensions.DynamicEnumType\r
1437     repeated_extension = ...  # type: RepeatedScalarFieldContainer[Text]\r
1438     packed_extension = ...  # type: RepeatedScalarFieldContainer[int]\r
1439 \r
1440     @property\r
1441     def message_extension(self) -> ForeignMessage: ...\r
1442 \r
1443     @property\r
1444     def dynamic_message_extension(\r
1445         self) -> TestDynamicExtensions.DynamicMessageType: ...\r
1446 \r
1447     def __init__(self,\r
1448                  scalar_extension: Optional[int] = ...,\r
1449                  enum_extension: Optional[ForeignEnum] = ...,\r
1450                  dynamic_enum_extension: Optional[TestDynamicExtensions.DynamicEnumType] = ...,\r
1451                  message_extension: Optional[ForeignMessage] = ...,\r
1452                  dynamic_message_extension: Optional[TestDynamicExtensions.DynamicMessageType] = ...,\r
1453                  repeated_extension: Optional[Iterable[Text]] = ...,\r
1454                  packed_extension: Optional[Iterable[int]] = ...,\r
1455                  ) -> None: ...\r
1456 \r
1457     @classmethod\r
1458     def FromString(cls, s: bytes) -> TestDynamicExtensions: ...\r
1459 \r
1460 \r
1461 class TestRepeatedScalarDifferentTagSizes(Message):\r
1462     repeated_fixed32 = ...  # type: RepeatedScalarFieldContainer[int]\r
1463     repeated_int32 = ...  # type: RepeatedScalarFieldContainer[int]\r
1464     repeated_fixed64 = ...  # type: RepeatedScalarFieldContainer[int]\r
1465     repeated_int64 = ...  # type: RepeatedScalarFieldContainer[int]\r
1466     repeated_float = ...  # type: RepeatedScalarFieldContainer[float]\r
1467     repeated_uint64 = ...  # type: RepeatedScalarFieldContainer[int]\r
1468 \r
1469     def __init__(self,\r
1470                  repeated_fixed32: Optional[Iterable[int]] = ...,\r
1471                  repeated_int32: Optional[Iterable[int]] = ...,\r
1472                  repeated_fixed64: Optional[Iterable[int]] = ...,\r
1473                  repeated_int64: Optional[Iterable[int]] = ...,\r
1474                  repeated_float: Optional[Iterable[float]] = ...,\r
1475                  repeated_uint64: Optional[Iterable[int]] = ...,\r
1476                  ) -> None: ...\r
1477 \r
1478     @classmethod\r
1479     def FromString(cls, s: bytes) -> TestRepeatedScalarDifferentTagSizes: ...\r
1480 \r
1481 \r
1482 class TestParsingMerge(Message):\r
1483     class RepeatedFieldsGenerator(Message):\r
1484         class Group1(Message):\r
1485 \r
1486             @property\r
1487             def field1(self) -> TestAllTypes: ...\r
1488 \r
1489             def __init__(self,\r
1490                          field1: Optional[TestAllTypes] = ...,\r
1491                          ) -> None: ...\r
1492 \r
1493             @classmethod\r
1494             def FromString(\r
1495                 cls, s: bytes) -> TestParsingMerge.RepeatedFieldsGenerator.Group1: ...\r
1496 \r
1497         class Group2(Message):\r
1498 \r
1499             @property\r
1500             def field1(self) -> TestAllTypes: ...\r
1501 \r
1502             def __init__(self,\r
1503                          field1: Optional[TestAllTypes] = ...,\r
1504                          ) -> None: ...\r
1505 \r
1506             @classmethod\r
1507             def FromString(\r
1508                 cls, s: bytes) -> TestParsingMerge.RepeatedFieldsGenerator.Group2: ...\r
1509 \r
1510         @property\r
1511         def field1(self) -> RepeatedCompositeFieldContainer[TestAllTypes]: ...\r
1512 \r
1513         @property\r
1514         def field2(self) -> RepeatedCompositeFieldContainer[TestAllTypes]: ...\r
1515 \r
1516         @property\r
1517         def field3(self) -> RepeatedCompositeFieldContainer[TestAllTypes]: ...\r
1518 \r
1519         @property\r
1520         def group1(\r
1521             self) -> RepeatedCompositeFieldContainer[TestParsingMerge.RepeatedFieldsGenerator.Group1]: ...\r
1522 \r
1523         @property\r
1524         def group2(\r
1525             self) -> RepeatedCompositeFieldContainer[TestParsingMerge.RepeatedFieldsGenerator.Group2]: ...\r
1526 \r
1527         @property\r
1528         def ext1(self) -> RepeatedCompositeFieldContainer[TestAllTypes]: ...\r
1529 \r
1530         @property\r
1531         def ext2(self) -> RepeatedCompositeFieldContainer[TestAllTypes]: ...\r
1532 \r
1533         def __init__(self,\r
1534                      field1: Optional[Iterable[TestAllTypes]] = ...,\r
1535                      field2: Optional[Iterable[TestAllTypes]] = ...,\r
1536                      field3: Optional[Iterable[TestAllTypes]] = ...,\r
1537                      group1: Optional[Iterable[TestParsingMerge.RepeatedFieldsGenerator.Group1]] = ...,\r
1538                      group2: Optional[Iterable[TestParsingMerge.RepeatedFieldsGenerator.Group2]] = ...,\r
1539                      ext1: Optional[Iterable[TestAllTypes]] = ...,\r
1540                      ext2: Optional[Iterable[TestAllTypes]] = ...,\r
1541                      ) -> None: ...\r
1542 \r
1543         @classmethod\r
1544         def FromString(\r
1545             cls, s: bytes) -> TestParsingMerge.RepeatedFieldsGenerator: ...\r
1546 \r
1547     class OptionalGroup(Message):\r
1548 \r
1549         @property\r
1550         def optional_group_all_types(self) -> TestAllTypes: ...\r
1551 \r
1552         def __init__(self,\r
1553                      optional_group_all_types: Optional[TestAllTypes] = ...,\r
1554                      ) -> None: ...\r
1555 \r
1556         @classmethod\r
1557         def FromString(cls, s: bytes) -> TestParsingMerge.OptionalGroup: ...\r
1558 \r
1559     class RepeatedGroup(Message):\r
1560 \r
1561         @property\r
1562         def repeated_group_all_types(self) -> TestAllTypes: ...\r
1563 \r
1564         def __init__(self,\r
1565                      repeated_group_all_types: Optional[TestAllTypes] = ...,\r
1566                      ) -> None: ...\r
1567 \r
1568         @classmethod\r
1569         def FromString(cls, s: bytes) -> TestParsingMerge.RepeatedGroup: ...\r
1570 \r
1571     @property\r
1572     def required_all_types(self) -> TestAllTypes: ...\r
1573 \r
1574     @property\r
1575     def optional_all_types(self) -> TestAllTypes: ...\r
1576 \r
1577     @property\r
1578     def repeated_all_types(\r
1579         self) -> RepeatedCompositeFieldContainer[TestAllTypes]: ...\r
1580 \r
1581     @property\r
1582     def optionalgroup(self) -> TestParsingMerge.OptionalGroup: ...\r
1583 \r
1584     @property\r
1585     def repeatedgroup(\r
1586         self) -> RepeatedCompositeFieldContainer[TestParsingMerge.RepeatedGroup]: ...\r
1587 \r
1588     def __init__(self,\r
1589                  required_all_types: TestAllTypes,\r
1590                  optional_all_types: Optional[TestAllTypes] = ...,\r
1591                  repeated_all_types: Optional[Iterable[TestAllTypes]] = ...,\r
1592                  optionalgroup: Optional[TestParsingMerge.OptionalGroup] = ...,\r
1593                  repeatedgroup: Optional[Iterable[TestParsingMerge.RepeatedGroup]] = ...,\r
1594                  ) -> None: ...\r
1595 \r
1596     @classmethod\r
1597     def FromString(cls, s: bytes) -> TestParsingMerge: ...\r
1598 \r
1599 \r
1600 class TestCommentInjectionMessage(Message):\r
1601     a = ...  # type: Text\r
1602 \r
1603     def __init__(self,\r
1604                  a: Optional[Text] = ...,\r
1605                  ) -> None: ...\r
1606 \r
1607     @classmethod\r
1608     def FromString(cls, s: bytes) -> TestCommentInjectionMessage: ...\r
1609 \r
1610 \r
1611 class FooRequest(Message):\r
1612 \r
1613     def __init__(self,\r
1614                  ) -> None: ...\r
1615 \r
1616     @classmethod\r
1617     def FromString(cls, s: bytes) -> FooRequest: ...\r
1618 \r
1619 \r
1620 class FooResponse(Message):\r
1621 \r
1622     def __init__(self,\r
1623                  ) -> None: ...\r
1624 \r
1625     @classmethod\r
1626     def FromString(cls, s: bytes) -> FooResponse: ...\r
1627 \r
1628 \r
1629 class FooClientMessage(Message):\r
1630 \r
1631     def __init__(self,\r
1632                  ) -> None: ...\r
1633 \r
1634     @classmethod\r
1635     def FromString(cls, s: bytes) -> FooClientMessage: ...\r
1636 \r
1637 \r
1638 class FooServerMessage(Message):\r
1639 \r
1640     def __init__(self,\r
1641                  ) -> None: ...\r
1642 \r
1643     @classmethod\r
1644     def FromString(cls, s: bytes) -> FooServerMessage: ...\r
1645 \r
1646 \r
1647 class BarRequest(Message):\r
1648 \r
1649     def __init__(self,\r
1650                  ) -> None: ...\r
1651 \r
1652     @classmethod\r
1653     def FromString(cls, s: bytes) -> BarRequest: ...\r
1654 \r
1655 \r
1656 class BarResponse(Message):\r
1657 \r
1658     def __init__(self,\r
1659                  ) -> None: ...\r
1660 \r
1661     @classmethod\r
1662     def FromString(cls, s: bytes) -> BarResponse: ...\r
1663 \r
1664 \r
1665 class TestJsonName(Message):\r
1666     field_name1 = ...  # type: int\r
1667     fieldName2 = ...  # type: int\r
1668     FieldName3 = ...  # type: int\r
1669     _field_name4 = ...  # type: int\r
1670     FIELD_NAME5 = ...  # type: int\r
1671     field_name6 = ...  # type: int\r
1672 \r
1673     def __init__(self,\r
1674                  field_name1: Optional[int] = ...,\r
1675                  fieldName2: Optional[int] = ...,\r
1676                  FieldName3: Optional[int] = ...,\r
1677                  _field_name4: Optional[int] = ...,\r
1678                  FIELD_NAME5: Optional[int] = ...,\r
1679                  field_name6: Optional[int] = ...,\r
1680                  ) -> None: ...\r
1681 \r
1682     @classmethod\r
1683     def FromString(cls, s: bytes) -> TestJsonName: ...\r
1684 \r
1685 \r
1686 class TestHugeFieldNumbers(Message):\r
1687     class OptionalGroup(Message):\r
1688         group_a = ...  # type: int\r
1689 \r
1690         def __init__(self,\r
1691                      group_a: Optional[int] = ...,\r
1692                      ) -> None: ...\r
1693 \r
1694         @classmethod\r
1695         def FromString(cls, s: bytes) -> TestHugeFieldNumbers.OptionalGroup: ...\r
1696 \r
1697     class StringStringMapEntry(Message):\r
1698         key = ...  # type: Text\r
1699         value = ...  # type: Text\r
1700 \r
1701         def __init__(self,\r
1702                      key: Optional[Text] = ...,\r
1703                      value: Optional[Text] = ...,\r
1704                      ) -> None: ...\r
1705 \r
1706         @classmethod\r
1707         def FromString(\r
1708             cls, s: bytes) -> TestHugeFieldNumbers.StringStringMapEntry: ...\r
1709     optional_int32 = ...  # type: int\r
1710     fixed_32 = ...  # type: int\r
1711     repeated_int32 = ...  # type: RepeatedScalarFieldContainer[int]\r
1712     packed_int32 = ...  # type: RepeatedScalarFieldContainer[int]\r
1713     optional_enum = ...  # type: ForeignEnum\r
1714     optional_string = ...  # type: Text\r
1715     optional_bytes = ...  # type: bytes\r
1716     oneof_uint32 = ...  # type: int\r
1717     oneof_string = ...  # type: Text\r
1718     oneof_bytes = ...  # type: bytes\r
1719 \r
1720     @property\r
1721     def optional_message(self) -> ForeignMessage: ...\r
1722 \r
1723     @property\r
1724     def optionalgroup(self) -> TestHugeFieldNumbers.OptionalGroup: ...\r
1725 \r
1726     @property\r
1727     def string_string_map(self) -> MutableMapping[Text, Text]: ...\r
1728 \r
1729     @property\r
1730     def oneof_test_all_types(self) -> TestAllTypes: ...\r
1731 \r
1732     def __init__(self,\r
1733                  optional_int32: Optional[int] = ...,\r
1734                  fixed_32: Optional[int] = ...,\r
1735                  repeated_int32: Optional[Iterable[int]] = ...,\r
1736                  packed_int32: Optional[Iterable[int]] = ...,\r
1737                  optional_enum: Optional[ForeignEnum] = ...,\r
1738                  optional_string: Optional[Text] = ...,\r
1739                  optional_bytes: Optional[bytes] = ...,\r
1740                  optional_message: Optional[ForeignMessage] = ...,\r
1741                  optionalgroup: Optional[TestHugeFieldNumbers.OptionalGroup] = ...,\r
1742                  string_string_map: Optional[Mapping[Text, Text]] = ...,\r
1743                  oneof_uint32: Optional[int] = ...,\r
1744                  oneof_test_all_types: Optional[TestAllTypes] = ...,\r
1745                  oneof_string: Optional[Text] = ...,\r
1746                  oneof_bytes: Optional[bytes] = ...,\r
1747                  ) -> None: ...\r
1748 \r
1749     @classmethod\r
1750     def FromString(cls, s: bytes) -> TestHugeFieldNumbers: ...\r
1751 \r
1752 \r
1753 class TestExtensionInsideTable(Message):\r
1754     field1 = ...  # type: int\r
1755     field2 = ...  # type: int\r
1756     field3 = ...  # type: int\r
1757     field4 = ...  # type: int\r
1758     field6 = ...  # type: int\r
1759     field7 = ...  # type: int\r
1760     field8 = ...  # type: int\r
1761     field9 = ...  # type: int\r
1762     field10 = ...  # type: int\r
1763 \r
1764     def __init__(self,\r
1765                  field1: Optional[int] = ...,\r
1766                  field2: Optional[int] = ...,\r
1767                  field3: Optional[int] = ...,\r
1768                  field4: Optional[int] = ...,\r
1769                  field6: Optional[int] = ...,\r
1770                  field7: Optional[int] = ...,\r
1771                  field8: Optional[int] = ...,\r
1772                  field9: Optional[int] = ...,\r
1773                  field10: Optional[int] = ...,\r
1774                  ) -> None: ...\r
1775 \r
1776     @classmethod\r
1777     def FromString(cls, s: bytes) -> TestExtensionInsideTable: ...\r