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

   1 from google.protobuf.any_pb2 import (\r
   2     Any,\r
   3 )\r
   4 from google.protobuf.duration_pb2 import (\r
   5     Duration,\r
   6 )\r
   7 from google.protobuf.field_mask_pb2 import (\r
   8     FieldMask,\r
   9 )\r
  10 from google.protobuf.internal.containers import (\r
  11     RepeatedCompositeFieldContainer,\r
  12     RepeatedScalarFieldContainer,\r
  13 )\r
  14 from google.protobuf.message import (\r
  15     Message,\r
  16 )\r
  17 from google.protobuf.struct_pb2 import (\r
  18     ListValue,\r
  19     Struct,\r
  20     Value,\r
  21 )\r
  22 from google.protobuf.timestamp_pb2 import (\r
  23     Timestamp,\r
  24 )\r
  25 from google.protobuf.unittest_pb2 import (\r
  26     TestAllExtensions,\r
  27 )\r
  28 from google.protobuf.wrappers_pb2 import (\r
  29     BoolValue,\r
  30     BytesValue,\r
  31     DoubleValue,\r
  32     FloatValue,\r
  33     Int32Value,\r
  34     Int64Value,\r
  35     StringValue,\r
  36     UInt32Value,\r
  37     UInt64Value,\r
  38 )\r
  39 from typing import (\r
  40     Iterable,\r
  41     List,\r
  42     Mapping,\r
  43     MutableMapping,\r
  44     Optional,\r
  45     Text,\r
  46     Tuple,\r
  47     cast,\r
  48 )\r
  49 \r
  50 \r
  51 class EnumType(int):\r
  52 \r
  53     @classmethod\r
  54     def Name(cls, number: int) -> bytes: ...\r
  55 \r
  56     @classmethod\r
  57     def Value(cls, name: bytes) -> EnumType: ...\r
  58 \r
  59     @classmethod\r
  60     def keys(cls) -> List[bytes]: ...\r
  61 \r
  62     @classmethod\r
  63     def values(cls) -> List[EnumType]: ...\r
  64 \r
  65     @classmethod\r
  66     def items(cls) -> List[Tuple[bytes, EnumType]]: ...\r
  67 \r
  68 \r
  69 FOO: EnumType\r
  70 BAR: EnumType\r
  71 \r
  72 \r
  73 class MessageType(Message):\r
  74     value = ...  # type: int\r
  75 \r
  76     def __init__(self,\r
  77                  value: Optional[int] = ...,\r
  78                  ) -> None: ...\r
  79 \r
  80     @classmethod\r
  81     def FromString(cls, s: bytes) -> MessageType: ...\r
  82 \r
  83 \r
  84 class TestMessage(Message):\r
  85     bool_value = ...  # type: bool\r
  86     int32_value = ...  # type: int\r
  87     int64_value = ...  # type: int\r
  88     uint32_value = ...  # type: int\r
  89     uint64_value = ...  # type: int\r
  90     float_value = ...  # type: float\r
  91     double_value = ...  # type: float\r
  92     string_value = ...  # type: Text\r
  93     bytes_value = ...  # type: bytes\r
  94     enum_value = ...  # type: EnumType\r
  95     repeated_bool_value = ...  # type: RepeatedScalarFieldContainer[bool]\r
  96     repeated_int32_value = ...  # type: RepeatedScalarFieldContainer[int]\r
  97     repeated_int64_value = ...  # type: RepeatedScalarFieldContainer[int]\r
  98     repeated_uint32_value = ...  # type: RepeatedScalarFieldContainer[int]\r
  99     repeated_uint64_value = ...  # type: RepeatedScalarFieldContainer[int]\r
 100     repeated_float_value = ...  # type: RepeatedScalarFieldContainer[float]\r
 101     repeated_double_value = ...  # type: RepeatedScalarFieldContainer[float]\r
 102     repeated_string_value = ...  # type: RepeatedScalarFieldContainer[Text]\r
 103     repeated_bytes_value = ...  # type: RepeatedScalarFieldContainer[bytes]\r
 104     repeated_enum_value = ...  # type: RepeatedScalarFieldContainer[EnumType]\r
 105 \r
 106     @property\r
 107     def message_value(self) -> MessageType: ...\r
 108 \r
 109     @property\r
 110     def repeated_message_value(\r
 111         self) -> RepeatedCompositeFieldContainer[MessageType]: ...\r
 112 \r
 113     def __init__(self,\r
 114                  bool_value: Optional[bool] = ...,\r
 115                  int32_value: Optional[int] = ...,\r
 116                  int64_value: Optional[int] = ...,\r
 117                  uint32_value: Optional[int] = ...,\r
 118                  uint64_value: Optional[int] = ...,\r
 119                  float_value: Optional[float] = ...,\r
 120                  double_value: Optional[float] = ...,\r
 121                  string_value: Optional[Text] = ...,\r
 122                  bytes_value: Optional[bytes] = ...,\r
 123                  enum_value: Optional[EnumType] = ...,\r
 124                  message_value: Optional[MessageType] = ...,\r
 125                  repeated_bool_value: Optional[Iterable[bool]] = ...,\r
 126                  repeated_int32_value: Optional[Iterable[int]] = ...,\r
 127                  repeated_int64_value: Optional[Iterable[int]] = ...,\r
 128                  repeated_uint32_value: Optional[Iterable[int]] = ...,\r
 129                  repeated_uint64_value: Optional[Iterable[int]] = ...,\r
 130                  repeated_float_value: Optional[Iterable[float]] = ...,\r
 131                  repeated_double_value: Optional[Iterable[float]] = ...,\r
 132                  repeated_string_value: Optional[Iterable[Text]] = ...,\r
 133                  repeated_bytes_value: Optional[Iterable[bytes]] = ...,\r
 134                  repeated_enum_value: Optional[Iterable[EnumType]] = ...,\r
 135                  repeated_message_value: Optional[Iterable[MessageType]] = ...,\r
 136                  ) -> None: ...\r
 137 \r
 138     @classmethod\r
 139     def FromString(cls, s: bytes) -> TestMessage: ...\r
 140 \r
 141 \r
 142 class TestOneof(Message):\r
 143     oneof_int32_value = ...  # type: int\r
 144     oneof_string_value = ...  # type: Text\r
 145     oneof_bytes_value = ...  # type: bytes\r
 146     oneof_enum_value = ...  # type: EnumType\r
 147 \r
 148     @property\r
 149     def oneof_message_value(self) -> MessageType: ...\r
 150 \r
 151     def __init__(self,\r
 152                  oneof_int32_value: Optional[int] = ...,\r
 153                  oneof_string_value: Optional[Text] = ...,\r
 154                  oneof_bytes_value: Optional[bytes] = ...,\r
 155                  oneof_enum_value: Optional[EnumType] = ...,\r
 156                  oneof_message_value: Optional[MessageType] = ...,\r
 157                  ) -> None: ...\r
 158 \r
 159     @classmethod\r
 160     def FromString(cls, s: bytes) -> TestOneof: ...\r
 161 \r
 162 \r
 163 class TestMap(Message):\r
 164 \r
 165     class BoolMapEntry(Message):\r
 166         key = ...  # type: bool\r
 167         value = ...  # type: int\r
 168 \r
 169         def __init__(self,\r
 170                      key: Optional[bool] = ...,\r
 171                      value: Optional[int] = ...,\r
 172                      ) -> None: ...\r
 173 \r
 174         @classmethod\r
 175         def FromString(cls, s: bytes) -> TestMap.BoolMapEntry: ...\r
 176 \r
 177     class Int32MapEntry(Message):\r
 178         key = ...  # type: int\r
 179         value = ...  # type: int\r
 180 \r
 181         def __init__(self,\r
 182                      key: Optional[int] = ...,\r
 183                      value: Optional[int] = ...,\r
 184                      ) -> None: ...\r
 185 \r
 186         @classmethod\r
 187         def FromString(cls, s: bytes) -> TestMap.Int32MapEntry: ...\r
 188 \r
 189     class Int64MapEntry(Message):\r
 190         key = ...  # type: int\r
 191         value = ...  # type: int\r
 192 \r
 193         def __init__(self,\r
 194                      key: Optional[int] = ...,\r
 195                      value: Optional[int] = ...,\r
 196                      ) -> None: ...\r
 197 \r
 198         @classmethod\r
 199         def FromString(cls, s: bytes) -> TestMap.Int64MapEntry: ...\r
 200 \r
 201     class Uint32MapEntry(Message):\r
 202         key = ...  # type: int\r
 203         value = ...  # type: int\r
 204 \r
 205         def __init__(self,\r
 206                      key: Optional[int] = ...,\r
 207                      value: Optional[int] = ...,\r
 208                      ) -> None: ...\r
 209 \r
 210         @classmethod\r
 211         def FromString(cls, s: bytes) -> TestMap.Uint32MapEntry: ...\r
 212 \r
 213     class Uint64MapEntry(Message):\r
 214         key = ...  # type: int\r
 215         value = ...  # type: int\r
 216 \r
 217         def __init__(self,\r
 218                      key: Optional[int] = ...,\r
 219                      value: Optional[int] = ...,\r
 220                      ) -> None: ...\r
 221 \r
 222         @classmethod\r
 223         def FromString(cls, s: bytes) -> TestMap.Uint64MapEntry: ...\r
 224 \r
 225     class StringMapEntry(Message):\r
 226         key = ...  # type: Text\r
 227         value = ...  # type: int\r
 228 \r
 229         def __init__(self,\r
 230                      key: Optional[Text] = ...,\r
 231                      value: Optional[int] = ...,\r
 232                      ) -> None: ...\r
 233 \r
 234         @classmethod\r
 235         def FromString(cls, s: bytes) -> TestMap.StringMapEntry: ...\r
 236 \r
 237     @property\r
 238     def bool_map(self) -> MutableMapping[bool, int]: ...\r
 239 \r
 240     @property\r
 241     def int32_map(self) -> MutableMapping[int, int]: ...\r
 242 \r
 243     @property\r
 244     def int64_map(self) -> MutableMapping[int, int]: ...\r
 245 \r
 246     @property\r
 247     def uint32_map(self) -> MutableMapping[int, int]: ...\r
 248 \r
 249     @property\r
 250     def uint64_map(self) -> MutableMapping[int, int]: ...\r
 251 \r
 252     @property\r
 253     def string_map(self) -> MutableMapping[Text, int]: ...\r
 254 \r
 255     def __init__(self,\r
 256                  bool_map: Optional[Mapping[bool, int]]=...,\r
 257                  int32_map: Optional[Mapping[int, int]]=...,\r
 258                  int64_map: Optional[Mapping[int, int]]=...,\r
 259                  uint32_map: Optional[Mapping[int, int]]=...,\r
 260                  uint64_map: Optional[Mapping[int, int]]=...,\r
 261                  string_map: Optional[Mapping[Text, int]]=...,\r
 262                  ) -> None: ...\r
 263 \r
 264     @classmethod\r
 265     def FromString(cls, s: bytes) -> TestMap: ...\r
 266 \r
 267 \r
 268 class TestNestedMap(Message):\r
 269 \r
 270     class BoolMapEntry(Message):\r
 271         key = ...  # type: bool\r
 272         value = ...  # type: int\r
 273 \r
 274         def __init__(self,\r
 275                      key: Optional[bool] = ...,\r
 276                      value: Optional[int] = ...,\r
 277                      ) -> None: ...\r
 278 \r
 279         @classmethod\r
 280         def FromString(cls, s: bytes) -> TestNestedMap.BoolMapEntry: ...\r
 281 \r
 282     class Int32MapEntry(Message):\r
 283         key = ...  # type: int\r
 284         value = ...  # type: int\r
 285 \r
 286         def __init__(self,\r
 287                      key: Optional[int] = ...,\r
 288                      value: Optional[int] = ...,\r
 289                      ) -> None: ...\r
 290 \r
 291         @classmethod\r
 292         def FromString(cls, s: bytes) -> TestNestedMap.Int32MapEntry: ...\r
 293 \r
 294     class Int64MapEntry(Message):\r
 295         key = ...  # type: int\r
 296         value = ...  # type: int\r
 297 \r
 298         def __init__(self,\r
 299                      key: Optional[int] = ...,\r
 300                      value: Optional[int] = ...,\r
 301                      ) -> None: ...\r
 302 \r
 303         @classmethod\r
 304         def FromString(cls, s: bytes) -> TestNestedMap.Int64MapEntry: ...\r
 305 \r
 306     class Uint32MapEntry(Message):\r
 307         key = ...  # type: int\r
 308         value = ...  # type: int\r
 309 \r
 310         def __init__(self,\r
 311                      key: Optional[int] = ...,\r
 312                      value: Optional[int] = ...,\r
 313                      ) -> None: ...\r
 314 \r
 315         @classmethod\r
 316         def FromString(cls, s: bytes) -> TestNestedMap.Uint32MapEntry: ...\r
 317 \r
 318     class Uint64MapEntry(Message):\r
 319         key = ...  # type: int\r
 320         value = ...  # type: int\r
 321 \r
 322         def __init__(self,\r
 323                      key: Optional[int] = ...,\r
 324                      value: Optional[int] = ...,\r
 325                      ) -> None: ...\r
 326 \r
 327         @classmethod\r
 328         def FromString(cls, s: bytes) -> TestNestedMap.Uint64MapEntry: ...\r
 329 \r
 330     class StringMapEntry(Message):\r
 331         key = ...  # type: Text\r
 332         value = ...  # type: int\r
 333 \r
 334         def __init__(self,\r
 335                      key: Optional[Text] = ...,\r
 336                      value: Optional[int] = ...,\r
 337                      ) -> None: ...\r
 338 \r
 339         @classmethod\r
 340         def FromString(cls, s: bytes) -> TestNestedMap.StringMapEntry: ...\r
 341 \r
 342     class MapMapEntry(Message):\r
 343         key = ...  # type: Text\r
 344 \r
 345         @property\r
 346         def value(self) -> TestNestedMap: ...\r
 347 \r
 348         def __init__(self,\r
 349                      key: Optional[Text] = ...,\r
 350                      value: Optional[TestNestedMap] = ...,\r
 351                      ) -> None: ...\r
 352 \r
 353         @classmethod\r
 354         def FromString(cls, s: bytes) -> TestNestedMap.MapMapEntry: ...\r
 355 \r
 356     @property\r
 357     def bool_map(self) -> MutableMapping[bool, int]: ...\r
 358 \r
 359     @property\r
 360     def int32_map(self) -> MutableMapping[int, int]: ...\r
 361 \r
 362     @property\r
 363     def int64_map(self) -> MutableMapping[int, int]: ...\r
 364 \r
 365     @property\r
 366     def uint32_map(self) -> MutableMapping[int, int]: ...\r
 367 \r
 368     @property\r
 369     def uint64_map(self) -> MutableMapping[int, int]: ...\r
 370 \r
 371     @property\r
 372     def string_map(self) -> MutableMapping[Text, int]: ...\r
 373 \r
 374     @property\r
 375     def map_map(self) -> MutableMapping[Text, TestNestedMap]: ...\r
 376 \r
 377     def __init__(self,\r
 378                  bool_map: Optional[Mapping[bool, int]]=...,\r
 379                  int32_map: Optional[Mapping[int, int]]=...,\r
 380                  int64_map: Optional[Mapping[int, int]]=...,\r
 381                  uint32_map: Optional[Mapping[int, int]]=...,\r
 382                  uint64_map: Optional[Mapping[int, int]]=...,\r
 383                  string_map: Optional[Mapping[Text, int]]=...,\r
 384                  map_map: Optional[Mapping[Text, TestNestedMap]]=...,\r
 385                  ) -> None: ...\r
 386 \r
 387     @classmethod\r
 388     def FromString(cls, s: bytes) -> TestNestedMap: ...\r
 389 \r
 390 \r
 391 class TestWrapper(Message):\r
 392 \r
 393     @property\r
 394     def bool_value(self) -> BoolValue: ...\r
 395 \r
 396     @property\r
 397     def int32_value(self) -> Int32Value: ...\r
 398 \r
 399     @property\r
 400     def int64_value(self) -> Int64Value: ...\r
 401 \r
 402     @property\r
 403     def uint32_value(self) -> UInt32Value: ...\r
 404 \r
 405     @property\r
 406     def uint64_value(self) -> UInt64Value: ...\r
 407 \r
 408     @property\r
 409     def float_value(self) -> FloatValue: ...\r
 410 \r
 411     @property\r
 412     def double_value(self) -> DoubleValue: ...\r
 413 \r
 414     @property\r
 415     def string_value(self) -> StringValue: ...\r
 416 \r
 417     @property\r
 418     def bytes_value(self) -> BytesValue: ...\r
 419 \r
 420     @property\r
 421     def repeated_bool_value(\r
 422         self) -> RepeatedCompositeFieldContainer[BoolValue]: ...\r
 423 \r
 424     @property\r
 425     def repeated_int32_value(\r
 426         self) -> RepeatedCompositeFieldContainer[Int32Value]: ...\r
 427 \r
 428     @property\r
 429     def repeated_int64_value(\r
 430         self) -> RepeatedCompositeFieldContainer[Int64Value]: ...\r
 431 \r
 432     @property\r
 433     def repeated_uint32_value(\r
 434         self) -> RepeatedCompositeFieldContainer[UInt32Value]: ...\r
 435 \r
 436     @property\r
 437     def repeated_uint64_value(\r
 438         self) -> RepeatedCompositeFieldContainer[UInt64Value]: ...\r
 439 \r
 440     @property\r
 441     def repeated_float_value(\r
 442         self) -> RepeatedCompositeFieldContainer[FloatValue]: ...\r
 443 \r
 444     @property\r
 445     def repeated_double_value(\r
 446         self) -> RepeatedCompositeFieldContainer[DoubleValue]: ...\r
 447 \r
 448     @property\r
 449     def repeated_string_value(\r
 450         self) -> RepeatedCompositeFieldContainer[StringValue]: ...\r
 451 \r
 452     @property\r
 453     def repeated_bytes_value(\r
 454         self) -> RepeatedCompositeFieldContainer[BytesValue]: ...\r
 455 \r
 456     def __init__(self,\r
 457                  bool_value: Optional[BoolValue] = ...,\r
 458                  int32_value: Optional[Int32Value] = ...,\r
 459                  int64_value: Optional[Int64Value] = ...,\r
 460                  uint32_value: Optional[UInt32Value] = ...,\r
 461                  uint64_value: Optional[UInt64Value] = ...,\r
 462                  float_value: Optional[FloatValue] = ...,\r
 463                  double_value: Optional[DoubleValue] = ...,\r
 464                  string_value: Optional[StringValue] = ...,\r
 465                  bytes_value: Optional[BytesValue] = ...,\r
 466                  repeated_bool_value: Optional[Iterable[BoolValue]] = ...,\r
 467                  repeated_int32_value: Optional[Iterable[Int32Value]] = ...,\r
 468                  repeated_int64_value: Optional[Iterable[Int64Value]] = ...,\r
 469                  repeated_uint32_value: Optional[Iterable[UInt32Value]] = ...,\r
 470                  repeated_uint64_value: Optional[Iterable[UInt64Value]] = ...,\r
 471                  repeated_float_value: Optional[Iterable[FloatValue]] = ...,\r
 472                  repeated_double_value: Optional[Iterable[DoubleValue]] = ...,\r
 473                  repeated_string_value: Optional[Iterable[StringValue]] = ...,\r
 474                  repeated_bytes_value: Optional[Iterable[BytesValue]] = ...,\r
 475                  ) -> None: ...\r
 476 \r
 477     @classmethod\r
 478     def FromString(cls, s: bytes) -> TestWrapper: ...\r
 479 \r
 480 \r
 481 class TestTimestamp(Message):\r
 482 \r
 483     @property\r
 484     def value(self) -> Timestamp: ...\r
 485 \r
 486     @property\r
 487     def repeated_value(self) -> RepeatedCompositeFieldContainer[Timestamp]: ...\r
 488 \r
 489     def __init__(self,\r
 490                  value: Optional[Timestamp] = ...,\r
 491                  repeated_value: Optional[Iterable[Timestamp]] = ...,\r
 492                  ) -> None: ...\r
 493 \r
 494     @classmethod\r
 495     def FromString(cls, s: bytes) -> TestTimestamp: ...\r
 496 \r
 497 \r
 498 class TestDuration(Message):\r
 499 \r
 500     @property\r
 501     def value(self) -> Duration: ...\r
 502 \r
 503     @property\r
 504     def repeated_value(self) -> RepeatedCompositeFieldContainer[Duration]: ...\r
 505 \r
 506     def __init__(self,\r
 507                  value: Optional[Duration] = ...,\r
 508                  repeated_value: Optional[Iterable[Duration]] = ...,\r
 509                  ) -> None: ...\r
 510 \r
 511     @classmethod\r
 512     def FromString(cls, s: bytes) -> TestDuration: ...\r
 513 \r
 514 \r
 515 class TestFieldMask(Message):\r
 516 \r
 517     @property\r
 518     def value(self) -> FieldMask: ...\r
 519 \r
 520     def __init__(self,\r
 521                  value: Optional[FieldMask] = ...,\r
 522                  ) -> None: ...\r
 523 \r
 524     @classmethod\r
 525     def FromString(cls, s: bytes) -> TestFieldMask: ...\r
 526 \r
 527 \r
 528 class TestStruct(Message):\r
 529 \r
 530     @property\r
 531     def value(self) -> Struct: ...\r
 532 \r
 533     @property\r
 534     def repeated_value(self) -> RepeatedCompositeFieldContainer[Struct]: ...\r
 535 \r
 536     def __init__(self,\r
 537                  value: Optional[Struct] = ...,\r
 538                  repeated_value: Optional[Iterable[Struct]] = ...,\r
 539                  ) -> None: ...\r
 540 \r
 541     @classmethod\r
 542     def FromString(cls, s: bytes) -> TestStruct: ...\r
 543 \r
 544 \r
 545 class TestAny(Message):\r
 546 \r
 547     @property\r
 548     def value(self) -> Any: ...\r
 549 \r
 550     @property\r
 551     def repeated_value(self) -> RepeatedCompositeFieldContainer[Any]: ...\r
 552 \r
 553     def __init__(self,\r
 554                  value: Optional[Any] = ...,\r
 555                  repeated_value: Optional[Iterable[Any]] = ...,\r
 556                  ) -> None: ...\r
 557 \r
 558     @classmethod\r
 559     def FromString(cls, s: bytes) -> TestAny: ...\r
 560 \r
 561 \r
 562 class TestValue(Message):\r
 563 \r
 564     @property\r
 565     def value(self) -> Value: ...\r
 566 \r
 567     @property\r
 568     def repeated_value(self) -> RepeatedCompositeFieldContainer[Value]: ...\r
 569 \r
 570     def __init__(self,\r
 571                  value: Optional[Value] = ...,\r
 572                  repeated_value: Optional[Iterable[Value]] = ...,\r
 573                  ) -> None: ...\r
 574 \r
 575     @classmethod\r
 576     def FromString(cls, s: bytes) -> TestValue: ...\r
 577 \r
 578 \r
 579 class TestListValue(Message):\r
 580 \r
 581     @property\r
 582     def value(self) -> ListValue: ...\r
 583 \r
 584     @property\r
 585     def repeated_value(self) -> RepeatedCompositeFieldContainer[ListValue]: ...\r
 586 \r
 587     def __init__(self,\r
 588                  value: Optional[ListValue] = ...,\r
 589                  repeated_value: Optional[Iterable[ListValue]] = ...,\r
 590                  ) -> None: ...\r
 591 \r
 592     @classmethod\r
 593     def FromString(cls, s: bytes) -> TestListValue: ...\r
 594 \r
 595 \r
 596 class TestBoolValue(Message):\r
 597 \r
 598     class BoolMapEntry(Message):\r
 599         key = ...  # type: bool\r
 600         value = ...  # type: int\r
 601 \r
 602         def __init__(self,\r
 603                      key: Optional[bool] = ...,\r
 604                      value: Optional[int] = ...,\r
 605                      ) -> None: ...\r
 606 \r
 607         @classmethod\r
 608         def FromString(cls, s: bytes) -> TestBoolValue.BoolMapEntry: ...\r
 609     bool_value = ...  # type: bool\r
 610 \r
 611     @property\r
 612     def bool_map(self) -> MutableMapping[bool, int]: ...\r
 613 \r
 614     def __init__(self,\r
 615                  bool_value: Optional[bool] = ...,\r
 616                  bool_map: Optional[Mapping[bool, int]]=...,\r
 617                  ) -> None: ...\r
 618 \r
 619     @classmethod\r
 620     def FromString(cls, s: bytes) -> TestBoolValue: ...\r
 621 \r
 622 \r
 623 class TestCustomJsonName(Message):\r
 624     value = ...  # type: int\r
 625 \r
 626     def __init__(self,\r
 627                  value: Optional[int] = ...,\r
 628                  ) -> None: ...\r
 629 \r
 630     @classmethod\r
 631     def FromString(cls, s: bytes) -> TestCustomJsonName: ...\r
 632 \r
 633 \r
 634 class TestExtensions(Message):\r
 635 \r
 636     @property\r
 637     def extensions(self) -> TestAllExtensions: ...\r
 638 \r
 639     def __init__(self,\r
 640                  extensions: Optional[TestAllExtensions] = ...,\r
 641                  ) -> None: ...\r
 642 \r
 643     @classmethod\r
 644     def FromString(cls, s: bytes) -> TestExtensions: ...\r
 645 \r
 646 \r
 647 class TestEnumValue(Message):\r
 648     enum_value1 = ...  # type: EnumType\r
 649     enum_value2 = ...  # type: EnumType\r
 650     enum_value3 = ...  # type: EnumType\r
 651 \r
 652     def __init__(self,\r
 653                  enum_value1: Optional[EnumType] = ...,\r
 654                  enum_value2: Optional[EnumType] = ...,\r
 655                  enum_value3: Optional[EnumType] = ...,\r
 656                  ) -> None: ...\r
 657 \r
 658     @classmethod\r
 659     def FromString(cls, s: bytes) -> TestEnumValue: ...\r