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

   1 from google.protobuf.message import (\r
   2     Message,\r
   3 )\r
   4 from google.protobuf.unittest_no_arena_pb2 import (\r
   5     ForeignMessage,\r
   6 )\r
   7 from google.protobuf.unittest_pb2 import (\r
   8     ForeignMessage as ForeignMessage1,\r
   9     TestAllTypes,\r
  10     TestRequired,\r
  11 )\r
  12 from typing import (\r
  13     List,\r
  14     Mapping,\r
  15     MutableMapping,\r
  16     Optional,\r
  17     Text,\r
  18     Tuple,\r
  19     cast,\r
  20 )\r
  21 \r
  22 \r
  23 class MapEnum(int):\r
  24 \r
  25     @classmethod\r
  26     def Name(cls, number: int) -> bytes: ...\r
  27 \r
  28     @classmethod\r
  29     def Value(cls, name: bytes) -> MapEnum: ...\r
  30 \r
  31     @classmethod\r
  32     def keys(cls) -> List[bytes]: ...\r
  33 \r
  34     @classmethod\r
  35     def values(cls) -> List[MapEnum]: ...\r
  36 \r
  37     @classmethod\r
  38     def items(cls) -> List[Tuple[bytes, MapEnum]]: ...\r
  39 \r
  40 \r
  41 MAP_ENUM_FOO: MapEnum\r
  42 MAP_ENUM_BAR: MapEnum\r
  43 MAP_ENUM_BAZ: MapEnum\r
  44 \r
  45 \r
  46 class TestMap(Message):\r
  47 \r
  48     class MapInt32Int32Entry(Message):\r
  49         key = ...  # type: int\r
  50         value = ...  # type: int\r
  51 \r
  52         def __init__(self,\r
  53                      key: Optional[int] = ...,\r
  54                      value: Optional[int] = ...,\r
  55                      ) -> None: ...\r
  56 \r
  57         @classmethod\r
  58         def FromString(cls, s: bytes) -> TestMap.MapInt32Int32Entry: ...\r
  59 \r
  60     class MapInt64Int64Entry(Message):\r
  61         key = ...  # type: int\r
  62         value = ...  # type: int\r
  63 \r
  64         def __init__(self,\r
  65                      key: Optional[int] = ...,\r
  66                      value: Optional[int] = ...,\r
  67                      ) -> None: ...\r
  68 \r
  69         @classmethod\r
  70         def FromString(cls, s: bytes) -> TestMap.MapInt64Int64Entry: ...\r
  71 \r
  72     class MapUint32Uint32Entry(Message):\r
  73         key = ...  # type: int\r
  74         value = ...  # type: int\r
  75 \r
  76         def __init__(self,\r
  77                      key: Optional[int] = ...,\r
  78                      value: Optional[int] = ...,\r
  79                      ) -> None: ...\r
  80 \r
  81         @classmethod\r
  82         def FromString(cls, s: bytes) -> TestMap.MapUint32Uint32Entry: ...\r
  83 \r
  84     class MapUint64Uint64Entry(Message):\r
  85         key = ...  # type: int\r
  86         value = ...  # type: int\r
  87 \r
  88         def __init__(self,\r
  89                      key: Optional[int] = ...,\r
  90                      value: Optional[int] = ...,\r
  91                      ) -> None: ...\r
  92 \r
  93         @classmethod\r
  94         def FromString(cls, s: bytes) -> TestMap.MapUint64Uint64Entry: ...\r
  95 \r
  96     class MapSint32Sint32Entry(Message):\r
  97         key = ...  # type: int\r
  98         value = ...  # type: int\r
  99 \r
 100         def __init__(self,\r
 101                      key: Optional[int] = ...,\r
 102                      value: Optional[int] = ...,\r
 103                      ) -> None: ...\r
 104 \r
 105         @classmethod\r
 106         def FromString(cls, s: bytes) -> TestMap.MapSint32Sint32Entry: ...\r
 107 \r
 108     class MapSint64Sint64Entry(Message):\r
 109         key = ...  # type: int\r
 110         value = ...  # type: int\r
 111 \r
 112         def __init__(self,\r
 113                      key: Optional[int] = ...,\r
 114                      value: Optional[int] = ...,\r
 115                      ) -> None: ...\r
 116 \r
 117         @classmethod\r
 118         def FromString(cls, s: bytes) -> TestMap.MapSint64Sint64Entry: ...\r
 119 \r
 120     class MapFixed32Fixed32Entry(Message):\r
 121         key = ...  # type: int\r
 122         value = ...  # type: int\r
 123 \r
 124         def __init__(self,\r
 125                      key: Optional[int] = ...,\r
 126                      value: Optional[int] = ...,\r
 127                      ) -> None: ...\r
 128 \r
 129         @classmethod\r
 130         def FromString(cls, s: bytes) -> TestMap.MapFixed32Fixed32Entry: ...\r
 131 \r
 132     class MapFixed64Fixed64Entry(Message):\r
 133         key = ...  # type: int\r
 134         value = ...  # type: int\r
 135 \r
 136         def __init__(self,\r
 137                      key: Optional[int] = ...,\r
 138                      value: Optional[int] = ...,\r
 139                      ) -> None: ...\r
 140 \r
 141         @classmethod\r
 142         def FromString(cls, s: bytes) -> TestMap.MapFixed64Fixed64Entry: ...\r
 143 \r
 144     class MapSfixed32Sfixed32Entry(Message):\r
 145         key = ...  # type: int\r
 146         value = ...  # type: int\r
 147 \r
 148         def __init__(self,\r
 149                      key: Optional[int] = ...,\r
 150                      value: Optional[int] = ...,\r
 151                      ) -> None: ...\r
 152 \r
 153         @classmethod\r
 154         def FromString(cls, s: bytes) -> TestMap.MapSfixed32Sfixed32Entry: ...\r
 155 \r
 156     class MapSfixed64Sfixed64Entry(Message):\r
 157         key = ...  # type: int\r
 158         value = ...  # type: int\r
 159 \r
 160         def __init__(self,\r
 161                      key: Optional[int] = ...,\r
 162                      value: Optional[int] = ...,\r
 163                      ) -> None: ...\r
 164 \r
 165         @classmethod\r
 166         def FromString(cls, s: bytes) -> TestMap.MapSfixed64Sfixed64Entry: ...\r
 167 \r
 168     class MapInt32FloatEntry(Message):\r
 169         key = ...  # type: int\r
 170         value = ...  # type: float\r
 171 \r
 172         def __init__(self,\r
 173                      key: Optional[int] = ...,\r
 174                      value: Optional[float] = ...,\r
 175                      ) -> None: ...\r
 176 \r
 177         @classmethod\r
 178         def FromString(cls, s: bytes) -> TestMap.MapInt32FloatEntry: ...\r
 179 \r
 180     class MapInt32DoubleEntry(Message):\r
 181         key = ...  # type: int\r
 182         value = ...  # type: float\r
 183 \r
 184         def __init__(self,\r
 185                      key: Optional[int] = ...,\r
 186                      value: Optional[float] = ...,\r
 187                      ) -> None: ...\r
 188 \r
 189         @classmethod\r
 190         def FromString(cls, s: bytes) -> TestMap.MapInt32DoubleEntry: ...\r
 191 \r
 192     class MapBoolBoolEntry(Message):\r
 193         key = ...  # type: bool\r
 194         value = ...  # type: bool\r
 195 \r
 196         def __init__(self,\r
 197                      key: Optional[bool] = ...,\r
 198                      value: Optional[bool] = ...,\r
 199                      ) -> None: ...\r
 200 \r
 201         @classmethod\r
 202         def FromString(cls, s: bytes) -> TestMap.MapBoolBoolEntry: ...\r
 203 \r
 204     class MapStringStringEntry(Message):\r
 205         key = ...  # type: Text\r
 206         value = ...  # type: Text\r
 207 \r
 208         def __init__(self,\r
 209                      key: Optional[Text] = ...,\r
 210                      value: Optional[Text] = ...,\r
 211                      ) -> None: ...\r
 212 \r
 213         @classmethod\r
 214         def FromString(cls, s: bytes) -> TestMap.MapStringStringEntry: ...\r
 215 \r
 216     class MapInt32BytesEntry(Message):\r
 217         key = ...  # type: int\r
 218         value = ...  # type: bytes\r
 219 \r
 220         def __init__(self,\r
 221                      key: Optional[int] = ...,\r
 222                      value: Optional[bytes] = ...,\r
 223                      ) -> None: ...\r
 224 \r
 225         @classmethod\r
 226         def FromString(cls, s: bytes) -> TestMap.MapInt32BytesEntry: ...\r
 227 \r
 228     class MapInt32EnumEntry(Message):\r
 229         key = ...  # type: int\r
 230         value = ...  # type: MapEnum\r
 231 \r
 232         def __init__(self,\r
 233                      key: Optional[int] = ...,\r
 234                      value: Optional[MapEnum] = ...,\r
 235                      ) -> None: ...\r
 236 \r
 237         @classmethod\r
 238         def FromString(cls, s: bytes) -> TestMap.MapInt32EnumEntry: ...\r
 239 \r
 240     class MapInt32ForeignMessageEntry(Message):\r
 241         key = ...  # type: int\r
 242 \r
 243         @property\r
 244         def value(self) -> ForeignMessage1: ...\r
 245 \r
 246         def __init__(self,\r
 247                      key: Optional[int] = ...,\r
 248                      value: Optional[ForeignMessage1] = ...,\r
 249                      ) -> None: ...\r
 250 \r
 251         @classmethod\r
 252         def FromString(cls, s: bytes) -> TestMap.MapInt32ForeignMessageEntry: ...\r
 253 \r
 254     class MapStringForeignMessageEntry(Message):\r
 255         key = ...  # type: Text\r
 256 \r
 257         @property\r
 258         def value(self) -> ForeignMessage1: ...\r
 259 \r
 260         def __init__(self,\r
 261                      key: Optional[Text] = ...,\r
 262                      value: Optional[ForeignMessage1] = ...,\r
 263                      ) -> None: ...\r
 264 \r
 265         @classmethod\r
 266         def FromString(\r
 267             cls, s: bytes) -> TestMap.MapStringForeignMessageEntry: ...\r
 268 \r
 269     class MapInt32AllTypesEntry(Message):\r
 270         key = ...  # type: int\r
 271 \r
 272         @property\r
 273         def value(self) -> TestAllTypes: ...\r
 274 \r
 275         def __init__(self,\r
 276                      key: Optional[int] = ...,\r
 277                      value: Optional[TestAllTypes] = ...,\r
 278                      ) -> None: ...\r
 279 \r
 280         @classmethod\r
 281         def FromString(cls, s: bytes) -> TestMap.MapInt32AllTypesEntry: ...\r
 282 \r
 283     @property\r
 284     def map_int32_int32(self) -> MutableMapping[int, int]: ...\r
 285 \r
 286     @property\r
 287     def map_int64_int64(self) -> MutableMapping[int, int]: ...\r
 288 \r
 289     @property\r
 290     def map_uint32_uint32(self) -> MutableMapping[int, int]: ...\r
 291 \r
 292     @property\r
 293     def map_uint64_uint64(self) -> MutableMapping[int, int]: ...\r
 294 \r
 295     @property\r
 296     def map_sint32_sint32(self) -> MutableMapping[int, int]: ...\r
 297 \r
 298     @property\r
 299     def map_sint64_sint64(self) -> MutableMapping[int, int]: ...\r
 300 \r
 301     @property\r
 302     def map_fixed32_fixed32(self) -> MutableMapping[int, int]: ...\r
 303 \r
 304     @property\r
 305     def map_fixed64_fixed64(self) -> MutableMapping[int, int]: ...\r
 306 \r
 307     @property\r
 308     def map_sfixed32_sfixed32(self) -> MutableMapping[int, int]: ...\r
 309 \r
 310     @property\r
 311     def map_sfixed64_sfixed64(self) -> MutableMapping[int, int]: ...\r
 312 \r
 313     @property\r
 314     def map_int32_float(self) -> MutableMapping[int, float]: ...\r
 315 \r
 316     @property\r
 317     def map_int32_double(self) -> MutableMapping[int, float]: ...\r
 318 \r
 319     @property\r
 320     def map_bool_bool(self) -> MutableMapping[bool, bool]: ...\r
 321 \r
 322     @property\r
 323     def map_string_string(self) -> MutableMapping[Text, Text]: ...\r
 324 \r
 325     @property\r
 326     def map_int32_bytes(self) -> MutableMapping[int, bytes]: ...\r
 327 \r
 328     @property\r
 329     def map_int32_enum(self) -> MutableMapping[int, MapEnum]: ...\r
 330 \r
 331     @property\r
 332     def map_int32_foreign_message(\r
 333         self) -> MutableMapping[int, ForeignMessage1]: ...\r
 334 \r
 335     @property\r
 336     def map_string_foreign_message(\r
 337         self) -> MutableMapping[Text, ForeignMessage1]: ...\r
 338 \r
 339     @property\r
 340     def map_int32_all_types(self) -> MutableMapping[int, TestAllTypes]: ...\r
 341 \r
 342     def __init__(self,\r
 343                  map_int32_int32: Optional[Mapping[int, int]]=...,\r
 344                  map_int64_int64: Optional[Mapping[int, int]]=...,\r
 345                  map_uint32_uint32: Optional[Mapping[int, int]]=...,\r
 346                  map_uint64_uint64: Optional[Mapping[int, int]]=...,\r
 347                  map_sint32_sint32: Optional[Mapping[int, int]]=...,\r
 348                  map_sint64_sint64: Optional[Mapping[int, int]]=...,\r
 349                  map_fixed32_fixed32: Optional[Mapping[int, int]]=...,\r
 350                  map_fixed64_fixed64: Optional[Mapping[int, int]]=...,\r
 351                  map_sfixed32_sfixed32: Optional[Mapping[int, int]]=...,\r
 352                  map_sfixed64_sfixed64: Optional[Mapping[int, int]]=...,\r
 353                  map_int32_float: Optional[Mapping[int, float]]=...,\r
 354                  map_int32_double: Optional[Mapping[int, float]]=...,\r
 355                  map_bool_bool: Optional[Mapping[bool, bool]]=...,\r
 356                  map_string_string: Optional[Mapping[Text, Text]]=...,\r
 357                  map_int32_bytes: Optional[Mapping[int, bytes]]=...,\r
 358                  map_int32_enum: Optional[Mapping[int, MapEnum]]=...,\r
 359                  map_int32_foreign_message: Optional[Mapping[int, ForeignMessage1]]=...,\r
 360                  map_string_foreign_message: Optional[Mapping[Text, ForeignMessage1]]=...,\r
 361                  map_int32_all_types: Optional[Mapping[int, TestAllTypes]]=...,\r
 362                  ) -> None: ...\r
 363 \r
 364     @classmethod\r
 365     def FromString(cls, s: bytes) -> TestMap: ...\r
 366 \r
 367 \r
 368 class TestMapSubmessage(Message):\r
 369 \r
 370     @property\r
 371     def test_map(self) -> TestMap: ...\r
 372 \r
 373     def __init__(self,\r
 374                  test_map: Optional[TestMap] = ...,\r
 375                  ) -> None: ...\r
 376 \r
 377     @classmethod\r
 378     def FromString(cls, s: bytes) -> TestMapSubmessage: ...\r
 379 \r
 380 \r
 381 class TestMessageMap(Message):\r
 382 \r
 383     class MapInt32MessageEntry(Message):\r
 384         key = ...  # type: int\r
 385 \r
 386         @property\r
 387         def value(self) -> TestAllTypes: ...\r
 388 \r
 389         def __init__(self,\r
 390                      key: Optional[int] = ...,\r
 391                      value: Optional[TestAllTypes] = ...,\r
 392                      ) -> None: ...\r
 393 \r
 394         @classmethod\r
 395         def FromString(cls, s: bytes) -> TestMessageMap.MapInt32MessageEntry: ...\r
 396 \r
 397     @property\r
 398     def map_int32_message(self) -> MutableMapping[int, TestAllTypes]: ...\r
 399 \r
 400     def __init__(self,\r
 401                  map_int32_message: Optional[Mapping[int, TestAllTypes]]=...,\r
 402                  ) -> None: ...\r
 403 \r
 404     @classmethod\r
 405     def FromString(cls, s: bytes) -> TestMessageMap: ...\r
 406 \r
 407 \r
 408 class TestSameTypeMap(Message):\r
 409 \r
 410     class Map1Entry(Message):\r
 411         key = ...  # type: int\r
 412         value = ...  # type: int\r
 413 \r
 414         def __init__(self,\r
 415                      key: Optional[int] = ...,\r
 416                      value: Optional[int] = ...,\r
 417                      ) -> None: ...\r
 418 \r
 419         @classmethod\r
 420         def FromString(cls, s: bytes) -> TestSameTypeMap.Map1Entry: ...\r
 421 \r
 422     class Map2Entry(Message):\r
 423         key = ...  # type: int\r
 424         value = ...  # type: int\r
 425 \r
 426         def __init__(self,\r
 427                      key: Optional[int] = ...,\r
 428                      value: Optional[int] = ...,\r
 429                      ) -> None: ...\r
 430 \r
 431         @classmethod\r
 432         def FromString(cls, s: bytes) -> TestSameTypeMap.Map2Entry: ...\r
 433 \r
 434     @property\r
 435     def map1(self) -> MutableMapping[int, int]: ...\r
 436 \r
 437     @property\r
 438     def map2(self) -> MutableMapping[int, int]: ...\r
 439 \r
 440     def __init__(self,\r
 441                  map1: Optional[Mapping[int, int]]=...,\r
 442                  map2: Optional[Mapping[int, int]]=...,\r
 443                  ) -> None: ...\r
 444 \r
 445     @classmethod\r
 446     def FromString(cls, s: bytes) -> TestSameTypeMap: ...\r
 447 \r
 448 \r
 449 class TestRequiredMessageMap(Message):\r
 450 \r
 451     class MapFieldEntry(Message):\r
 452         key = ...  # type: int\r
 453 \r
 454         @property\r
 455         def value(self) -> TestRequired: ...\r
 456 \r
 457         def __init__(self,\r
 458                      key: Optional[int] = ...,\r
 459                      value: Optional[TestRequired] = ...,\r
 460                      ) -> None: ...\r
 461 \r
 462         @classmethod\r
 463         def FromString(\r
 464             cls, s: bytes) -> TestRequiredMessageMap.MapFieldEntry: ...\r
 465 \r
 466     @property\r
 467     def map_field(self) -> MutableMapping[int, TestRequired]: ...\r
 468 \r
 469     def __init__(self,\r
 470                  map_field: Optional[Mapping[int, TestRequired]]=...,\r
 471                  ) -> None: ...\r
 472 \r
 473     @classmethod\r
 474     def FromString(cls, s: bytes) -> TestRequiredMessageMap: ...\r
 475 \r
 476 \r
 477 class TestArenaMap(Message):\r
 478 \r
 479     class MapInt32Int32Entry(Message):\r
 480         key = ...  # type: int\r
 481         value = ...  # type: int\r
 482 \r
 483         def __init__(self,\r
 484                      key: Optional[int] = ...,\r
 485                      value: Optional[int] = ...,\r
 486                      ) -> None: ...\r
 487 \r
 488         @classmethod\r
 489         def FromString(cls, s: bytes) -> TestArenaMap.MapInt32Int32Entry: ...\r
 490 \r
 491     class MapInt64Int64Entry(Message):\r
 492         key = ...  # type: int\r
 493         value = ...  # type: int\r
 494 \r
 495         def __init__(self,\r
 496                      key: Optional[int] = ...,\r
 497                      value: Optional[int] = ...,\r
 498                      ) -> None: ...\r
 499 \r
 500         @classmethod\r
 501         def FromString(cls, s: bytes) -> TestArenaMap.MapInt64Int64Entry: ...\r
 502 \r
 503     class MapUint32Uint32Entry(Message):\r
 504         key = ...  # type: int\r
 505         value = ...  # type: int\r
 506 \r
 507         def __init__(self,\r
 508                      key: Optional[int] = ...,\r
 509                      value: Optional[int] = ...,\r
 510                      ) -> None: ...\r
 511 \r
 512         @classmethod\r
 513         def FromString(cls, s: bytes) -> TestArenaMap.MapUint32Uint32Entry: ...\r
 514 \r
 515     class MapUint64Uint64Entry(Message):\r
 516         key = ...  # type: int\r
 517         value = ...  # type: int\r
 518 \r
 519         def __init__(self,\r
 520                      key: Optional[int] = ...,\r
 521                      value: Optional[int] = ...,\r
 522                      ) -> None: ...\r
 523 \r
 524         @classmethod\r
 525         def FromString(cls, s: bytes) -> TestArenaMap.MapUint64Uint64Entry: ...\r
 526 \r
 527     class MapSint32Sint32Entry(Message):\r
 528         key = ...  # type: int\r
 529         value = ...  # type: int\r
 530 \r
 531         def __init__(self,\r
 532                      key: Optional[int] = ...,\r
 533                      value: Optional[int] = ...,\r
 534                      ) -> None: ...\r
 535 \r
 536         @classmethod\r
 537         def FromString(cls, s: bytes) -> TestArenaMap.MapSint32Sint32Entry: ...\r
 538 \r
 539     class MapSint64Sint64Entry(Message):\r
 540         key = ...  # type: int\r
 541         value = ...  # type: int\r
 542 \r
 543         def __init__(self,\r
 544                      key: Optional[int] = ...,\r
 545                      value: Optional[int] = ...,\r
 546                      ) -> None: ...\r
 547 \r
 548         @classmethod\r
 549         def FromString(cls, s: bytes) -> TestArenaMap.MapSint64Sint64Entry: ...\r
 550 \r
 551     class MapFixed32Fixed32Entry(Message):\r
 552         key = ...  # type: int\r
 553         value = ...  # type: int\r
 554 \r
 555         def __init__(self,\r
 556                      key: Optional[int] = ...,\r
 557                      value: Optional[int] = ...,\r
 558                      ) -> None: ...\r
 559 \r
 560         @classmethod\r
 561         def FromString(cls, s: bytes) -> TestArenaMap.MapFixed32Fixed32Entry: ...\r
 562 \r
 563     class MapFixed64Fixed64Entry(Message):\r
 564         key = ...  # type: int\r
 565         value = ...  # type: int\r
 566 \r
 567         def __init__(self,\r
 568                      key: Optional[int] = ...,\r
 569                      value: Optional[int] = ...,\r
 570                      ) -> None: ...\r
 571 \r
 572         @classmethod\r
 573         def FromString(cls, s: bytes) -> TestArenaMap.MapFixed64Fixed64Entry: ...\r
 574 \r
 575     class MapSfixed32Sfixed32Entry(Message):\r
 576         key = ...  # type: int\r
 577         value = ...  # type: int\r
 578 \r
 579         def __init__(self,\r
 580                      key: Optional[int] = ...,\r
 581                      value: Optional[int] = ...,\r
 582                      ) -> None: ...\r
 583 \r
 584         @classmethod\r
 585         def FromString(\r
 586             cls, s: bytes) -> TestArenaMap.MapSfixed32Sfixed32Entry: ...\r
 587 \r
 588     class MapSfixed64Sfixed64Entry(Message):\r
 589         key = ...  # type: int\r
 590         value = ...  # type: int\r
 591 \r
 592         def __init__(self,\r
 593                      key: Optional[int] = ...,\r
 594                      value: Optional[int] = ...,\r
 595                      ) -> None: ...\r
 596 \r
 597         @classmethod\r
 598         def FromString(\r
 599             cls, s: bytes) -> TestArenaMap.MapSfixed64Sfixed64Entry: ...\r
 600 \r
 601     class MapInt32FloatEntry(Message):\r
 602         key = ...  # type: int\r
 603         value = ...  # type: float\r
 604 \r
 605         def __init__(self,\r
 606                      key: Optional[int] = ...,\r
 607                      value: Optional[float] = ...,\r
 608                      ) -> None: ...\r
 609 \r
 610         @classmethod\r
 611         def FromString(cls, s: bytes) -> TestArenaMap.MapInt32FloatEntry: ...\r
 612 \r
 613     class MapInt32DoubleEntry(Message):\r
 614         key = ...  # type: int\r
 615         value = ...  # type: float\r
 616 \r
 617         def __init__(self,\r
 618                      key: Optional[int] = ...,\r
 619                      value: Optional[float] = ...,\r
 620                      ) -> None: ...\r
 621 \r
 622         @classmethod\r
 623         def FromString(cls, s: bytes) -> TestArenaMap.MapInt32DoubleEntry: ...\r
 624 \r
 625     class MapBoolBoolEntry(Message):\r
 626         key = ...  # type: bool\r
 627         value = ...  # type: bool\r
 628 \r
 629         def __init__(self,\r
 630                      key: Optional[bool] = ...,\r
 631                      value: Optional[bool] = ...,\r
 632                      ) -> None: ...\r
 633 \r
 634         @classmethod\r
 635         def FromString(cls, s: bytes) -> TestArenaMap.MapBoolBoolEntry: ...\r
 636 \r
 637     class MapStringStringEntry(Message):\r
 638         key = ...  # type: Text\r
 639         value = ...  # type: Text\r
 640 \r
 641         def __init__(self,\r
 642                      key: Optional[Text] = ...,\r
 643                      value: Optional[Text] = ...,\r
 644                      ) -> None: ...\r
 645 \r
 646         @classmethod\r
 647         def FromString(cls, s: bytes) -> TestArenaMap.MapStringStringEntry: ...\r
 648 \r
 649     class MapInt32BytesEntry(Message):\r
 650         key = ...  # type: int\r
 651         value = ...  # type: bytes\r
 652 \r
 653         def __init__(self,\r
 654                      key: Optional[int] = ...,\r
 655                      value: Optional[bytes] = ...,\r
 656                      ) -> None: ...\r
 657 \r
 658         @classmethod\r
 659         def FromString(cls, s: bytes) -> TestArenaMap.MapInt32BytesEntry: ...\r
 660 \r
 661     class MapInt32EnumEntry(Message):\r
 662         key = ...  # type: int\r
 663         value = ...  # type: MapEnum\r
 664 \r
 665         def __init__(self,\r
 666                      key: Optional[int] = ...,\r
 667                      value: Optional[MapEnum] = ...,\r
 668                      ) -> None: ...\r
 669 \r
 670         @classmethod\r
 671         def FromString(cls, s: bytes) -> TestArenaMap.MapInt32EnumEntry: ...\r
 672 \r
 673     class MapInt32ForeignMessageEntry(Message):\r
 674         key = ...  # type: int\r
 675 \r
 676         @property\r
 677         def value(self) -> ForeignMessage1: ...\r
 678 \r
 679         def __init__(self,\r
 680                      key: Optional[int] = ...,\r
 681                      value: Optional[ForeignMessage1] = ...,\r
 682                      ) -> None: ...\r
 683 \r
 684         @classmethod\r
 685         def FromString(\r
 686             cls, s: bytes) -> TestArenaMap.MapInt32ForeignMessageEntry: ...\r
 687 \r
 688     class MapInt32ForeignMessageNoArenaEntry(Message):\r
 689         key = ...  # type: int\r
 690 \r
 691         @property\r
 692         def value(self) -> ForeignMessage: ...\r
 693 \r
 694         def __init__(self,\r
 695                      key: Optional[int] = ...,\r
 696                      value: Optional[ForeignMessage] = ...,\r
 697                      ) -> None: ...\r
 698 \r
 699         @classmethod\r
 700         def FromString(\r
 701             cls, s: bytes) -> TestArenaMap.MapInt32ForeignMessageNoArenaEntry: ...\r
 702 \r
 703     @property\r
 704     def map_int32_int32(self) -> MutableMapping[int, int]: ...\r
 705 \r
 706     @property\r
 707     def map_int64_int64(self) -> MutableMapping[int, int]: ...\r
 708 \r
 709     @property\r
 710     def map_uint32_uint32(self) -> MutableMapping[int, int]: ...\r
 711 \r
 712     @property\r
 713     def map_uint64_uint64(self) -> MutableMapping[int, int]: ...\r
 714 \r
 715     @property\r
 716     def map_sint32_sint32(self) -> MutableMapping[int, int]: ...\r
 717 \r
 718     @property\r
 719     def map_sint64_sint64(self) -> MutableMapping[int, int]: ...\r
 720 \r
 721     @property\r
 722     def map_fixed32_fixed32(self) -> MutableMapping[int, int]: ...\r
 723 \r
 724     @property\r
 725     def map_fixed64_fixed64(self) -> MutableMapping[int, int]: ...\r
 726 \r
 727     @property\r
 728     def map_sfixed32_sfixed32(self) -> MutableMapping[int, int]: ...\r
 729 \r
 730     @property\r
 731     def map_sfixed64_sfixed64(self) -> MutableMapping[int, int]: ...\r
 732 \r
 733     @property\r
 734     def map_int32_float(self) -> MutableMapping[int, float]: ...\r
 735 \r
 736     @property\r
 737     def map_int32_double(self) -> MutableMapping[int, float]: ...\r
 738 \r
 739     @property\r
 740     def map_bool_bool(self) -> MutableMapping[bool, bool]: ...\r
 741 \r
 742     @property\r
 743     def map_string_string(self) -> MutableMapping[Text, Text]: ...\r
 744 \r
 745     @property\r
 746     def map_int32_bytes(self) -> MutableMapping[int, bytes]: ...\r
 747 \r
 748     @property\r
 749     def map_int32_enum(self) -> MutableMapping[int, MapEnum]: ...\r
 750 \r
 751     @property\r
 752     def map_int32_foreign_message(\r
 753         self) -> MutableMapping[int, ForeignMessage1]: ...\r
 754 \r
 755     @property\r
 756     def map_int32_foreign_message_no_arena(\r
 757         self) -> MutableMapping[int, ForeignMessage]: ...\r
 758 \r
 759     def __init__(self,\r
 760                  map_int32_int32: Optional[Mapping[int, int]]=...,\r
 761                  map_int64_int64: Optional[Mapping[int, int]]=...,\r
 762                  map_uint32_uint32: Optional[Mapping[int, int]]=...,\r
 763                  map_uint64_uint64: Optional[Mapping[int, int]]=...,\r
 764                  map_sint32_sint32: Optional[Mapping[int, int]]=...,\r
 765                  map_sint64_sint64: Optional[Mapping[int, int]]=...,\r
 766                  map_fixed32_fixed32: Optional[Mapping[int, int]]=...,\r
 767                  map_fixed64_fixed64: Optional[Mapping[int, int]]=...,\r
 768                  map_sfixed32_sfixed32: Optional[Mapping[int, int]]=...,\r
 769                  map_sfixed64_sfixed64: Optional[Mapping[int, int]]=...,\r
 770                  map_int32_float: Optional[Mapping[int, float]]=...,\r
 771                  map_int32_double: Optional[Mapping[int, float]]=...,\r
 772                  map_bool_bool: Optional[Mapping[bool, bool]]=...,\r
 773                  map_string_string: Optional[Mapping[Text, Text]]=...,\r
 774                  map_int32_bytes: Optional[Mapping[int, bytes]]=...,\r
 775                  map_int32_enum: Optional[Mapping[int, MapEnum]]=...,\r
 776                  map_int32_foreign_message: Optional[Mapping[int, ForeignMessage1]]=...,\r
 777                  map_int32_foreign_message_no_arena: Optional[Mapping[int, ForeignMessage]]=...,\r
 778                  ) -> None: ...\r
 779 \r
 780     @classmethod\r
 781     def FromString(cls, s: bytes) -> TestArenaMap: ...\r
 782 \r
 783 \r
 784 class MessageContainingEnumCalledType(Message):\r
 785 \r
 786     class Type(int):\r
 787 \r
 788         @classmethod\r
 789         def Name(cls, number: int) -> bytes: ...\r
 790 \r
 791         @classmethod\r
 792         def Value(cls, name: bytes) -> MessageContainingEnumCalledType.Type: ...\r
 793 \r
 794         @classmethod\r
 795         def keys(cls) -> List[bytes]: ...\r
 796 \r
 797         @classmethod\r
 798         def values(cls) -> List[MessageContainingEnumCalledType.Type]: ...\r
 799 \r
 800         @classmethod\r
 801         def items(cls) -> List[Tuple[bytes,\r
 802                                      MessageContainingEnumCalledType.Type]]: ...\r
 803     TYPE_FOO: Type\r
 804 \r
 805     class TypeEntry(Message):\r
 806         key = ...  # type: Text\r
 807 \r
 808         @property\r
 809         def value(self) -> MessageContainingEnumCalledType: ...\r
 810 \r
 811         def __init__(self,\r
 812                      key: Optional[Text] = ...,\r
 813                      value: Optional[MessageContainingEnumCalledType] = ...,\r
 814                      ) -> None: ...\r
 815 \r
 816         @classmethod\r
 817         def FromString(\r
 818             cls, s: bytes) -> MessageContainingEnumCalledType.TypeEntry: ...\r
 819 \r
 820     @property\r
 821     def type(self) -> MutableMapping[Text,\r
 822                                      MessageContainingEnumCalledType]: ...\r
 823 \r
 824     def __init__(self,\r
 825                  type: Optional[Mapping[Text, MessageContainingEnumCalledType]]=...,\r
 826                  ) -> None: ...\r
 827 \r
 828     @classmethod\r
 829     def FromString(cls, s: bytes) -> MessageContainingEnumCalledType: ...\r
 830 \r
 831 \r
 832 class MessageContainingMapCalledEntry(Message):\r
 833 \r
 834     class EntryEntry(Message):\r
 835         key = ...  # type: int\r
 836         value = ...  # type: int\r
 837 \r
 838         def __init__(self,\r
 839                      key: Optional[int] = ...,\r
 840                      value: Optional[int] = ...,\r
 841                      ) -> None: ...\r
 842 \r
 843         @classmethod\r
 844         def FromString(\r
 845             cls, s: bytes) -> MessageContainingMapCalledEntry.EntryEntry: ...\r
 846 \r
 847     @property\r
 848     def entry(self) -> MutableMapping[int, int]: ...\r
 849 \r
 850     def __init__(self,\r
 851                  entry: Optional[Mapping[int, int]]=...,\r
 852                  ) -> None: ...\r
 853 \r
 854     @classmethod\r
 855     def FromString(cls, s: bytes) -> MessageContainingMapCalledEntry: ...\r
 856 \r
 857 \r
 858 class TestRecursiveMapMessage(Message):\r
 859 \r
 860     class AEntry(Message):\r
 861         key = ...  # type: Text\r
 862 \r
 863         @property\r
 864         def value(self) -> TestRecursiveMapMessage: ...\r
 865 \r
 866         def __init__(self,\r
 867                      key: Optional[Text] = ...,\r
 868                      value: Optional[TestRecursiveMapMessage] = ...,\r
 869                      ) -> None: ...\r
 870 \r
 871         @classmethod\r
 872         def FromString(cls, s: bytes) -> TestRecursiveMapMessage.AEntry: ...\r
 873 \r
 874     @property\r
 875     def a(self) -> MutableMapping[Text, TestRecursiveMapMessage]: ...\r
 876 \r
 877     def __init__(self,\r
 878                  a: Optional[Mapping[Text, TestRecursiveMapMessage]]=...,\r
 879                  ) -> None: ...\r
 880 \r
 881     @classmethod\r
 882     def FromString(cls, s: bytes) -> TestRecursiveMapMessage: ...\r