.config/coc/extensions/coc-python-data/languageServer.0.5.59/Typeshed/third_party/2and3/google/protobuf/descriptor_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 typing import (\r
   9     Iterable,\r
  10     List,\r
  11     Optional,\r
  12     Text,\r
  13     Tuple,\r
  14     cast,\r
  15 )\r
  16 \r
  17 \r
  18 class FileDescriptorSet(Message):\r
  19 \r
  20     @property\r
  21     def file(self) -> RepeatedCompositeFieldContainer[FileDescriptorProto]: ...\r
  22 \r
  23     def __init__(self,\r
  24                  file: Optional[Iterable[FileDescriptorProto]] = ...,\r
  25                  ) -> None: ...\r
  26 \r
  27     @classmethod\r
  28     def FromString(cls, s: bytes) -> FileDescriptorSet: ...\r
  29 \r
  30 \r
  31 class FileDescriptorProto(Message):\r
  32     name = ...  # type: Text\r
  33     package = ...  # type: Text\r
  34     dependency = ...  # type: RepeatedScalarFieldContainer[Text]\r
  35     public_dependency = ...  # type: RepeatedScalarFieldContainer[int]\r
  36     weak_dependency = ...  # type: RepeatedScalarFieldContainer[int]\r
  37     syntax = ...  # type: Text\r
  38 \r
  39     @property\r
  40     def message_type(\r
  41         self) -> RepeatedCompositeFieldContainer[DescriptorProto]: ...\r
  42 \r
  43     @property\r
  44     def enum_type(\r
  45         self) -> RepeatedCompositeFieldContainer[EnumDescriptorProto]: ...\r
  46 \r
  47     @property\r
  48     def service(\r
  49         self) -> RepeatedCompositeFieldContainer[ServiceDescriptorProto]: ...\r
  50 \r
  51     @property\r
  52     def extension(\r
  53         self) -> RepeatedCompositeFieldContainer[FieldDescriptorProto]: ...\r
  54 \r
  55     @property\r
  56     def options(self) -> FileOptions: ...\r
  57 \r
  58     @property\r
  59     def source_code_info(self) -> SourceCodeInfo: ...\r
  60 \r
  61     def __init__(self,\r
  62                  name: Optional[Text] = ...,\r
  63                  package: Optional[Text] = ...,\r
  64                  dependency: Optional[Iterable[Text]] = ...,\r
  65                  public_dependency: Optional[Iterable[int]] = ...,\r
  66                  weak_dependency: Optional[Iterable[int]] = ...,\r
  67                  message_type: Optional[Iterable[DescriptorProto]] = ...,\r
  68                  enum_type: Optional[Iterable[EnumDescriptorProto]] = ...,\r
  69                  service: Optional[Iterable[ServiceDescriptorProto]] = ...,\r
  70                  extension: Optional[Iterable[FieldDescriptorProto]] = ...,\r
  71                  options: Optional[FileOptions] = ...,\r
  72                  source_code_info: Optional[SourceCodeInfo] = ...,\r
  73                  syntax: Optional[Text] = ...,\r
  74                  ) -> None: ...\r
  75 \r
  76     @classmethod\r
  77     def FromString(cls, s: bytes) -> FileDescriptorProto: ...\r
  78 \r
  79 \r
  80 class DescriptorProto(Message):\r
  81 \r
  82     class ExtensionRange(Message):\r
  83         start = ...  # type: int\r
  84         end = ...  # type: int\r
  85 \r
  86         @property\r
  87         def options(self) -> ExtensionRangeOptions: ...\r
  88 \r
  89         def __init__(self,\r
  90                      start: Optional[int] = ...,\r
  91                      end: Optional[int] = ...,\r
  92                      options: Optional[ExtensionRangeOptions] = ...,\r
  93                      ) -> None: ...\r
  94 \r
  95         @classmethod\r
  96         def FromString(cls, s: bytes) -> DescriptorProto.ExtensionRange: ...\r
  97 \r
  98     class ReservedRange(Message):\r
  99         start = ...  # type: int\r
 100         end = ...  # type: int\r
 101 \r
 102         def __init__(self,\r
 103                      start: Optional[int] = ...,\r
 104                      end: Optional[int] = ...,\r
 105                      ) -> None: ...\r
 106 \r
 107         @classmethod\r
 108         def FromString(cls, s: bytes) -> DescriptorProto.ReservedRange: ...\r
 109     name = ...  # type: Text\r
 110     reserved_name = ...  # type: RepeatedScalarFieldContainer[Text]\r
 111 \r
 112     @property\r
 113     def field(\r
 114         self) -> RepeatedCompositeFieldContainer[FieldDescriptorProto]: ...\r
 115 \r
 116     @property\r
 117     def extension(\r
 118         self) -> RepeatedCompositeFieldContainer[FieldDescriptorProto]: ...\r
 119 \r
 120     @property\r
 121     def nested_type(\r
 122         self) -> RepeatedCompositeFieldContainer[DescriptorProto]: ...\r
 123 \r
 124     @property\r
 125     def enum_type(\r
 126         self) -> RepeatedCompositeFieldContainer[EnumDescriptorProto]: ...\r
 127 \r
 128     @property\r
 129     def extension_range(\r
 130         self) -> RepeatedCompositeFieldContainer[DescriptorProto.ExtensionRange]: ...\r
 131 \r
 132     @property\r
 133     def oneof_decl(\r
 134         self) -> RepeatedCompositeFieldContainer[OneofDescriptorProto]: ...\r
 135 \r
 136     @property\r
 137     def options(self) -> MessageOptions: ...\r
 138 \r
 139     @property\r
 140     def reserved_range(\r
 141         self) -> RepeatedCompositeFieldContainer[DescriptorProto.ReservedRange]: ...\r
 142 \r
 143     def __init__(self,\r
 144                  name: Optional[Text] = ...,\r
 145                  field: Optional[Iterable[FieldDescriptorProto]] = ...,\r
 146                  extension: Optional[Iterable[FieldDescriptorProto]] = ...,\r
 147                  nested_type: Optional[Iterable[DescriptorProto]] = ...,\r
 148                  enum_type: Optional[Iterable[EnumDescriptorProto]] = ...,\r
 149                  extension_range: Optional[Iterable[DescriptorProto.ExtensionRange]] = ...,\r
 150                  oneof_decl: Optional[Iterable[OneofDescriptorProto]] = ...,\r
 151                  options: Optional[MessageOptions] = ...,\r
 152                  reserved_range: Optional[Iterable[DescriptorProto.ReservedRange]] = ...,\r
 153                  reserved_name: Optional[Iterable[Text]] = ...,\r
 154                  ) -> None: ...\r
 155 \r
 156     @classmethod\r
 157     def FromString(cls, s: bytes) -> DescriptorProto: ...\r
 158 \r
 159 \r
 160 class ExtensionRangeOptions(Message):\r
 161 \r
 162     @property\r
 163     def uninterpreted_option(\r
 164         self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...\r
 165 \r
 166     def __init__(self,\r
 167                  uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,\r
 168                  ) -> None: ...\r
 169 \r
 170     @classmethod\r
 171     def FromString(cls, s: bytes) -> ExtensionRangeOptions: ...\r
 172 \r
 173 \r
 174 class FieldDescriptorProto(Message):\r
 175 \r
 176     class Type(int):\r
 177 \r
 178         @classmethod\r
 179         def Name(cls, number: int) -> bytes: ...\r
 180 \r
 181         @classmethod\r
 182         def Value(cls, name: bytes) -> FieldDescriptorProto.Type: ...\r
 183 \r
 184         @classmethod\r
 185         def keys(cls) -> List[bytes]: ...\r
 186 \r
 187         @classmethod\r
 188         def values(cls) -> List[FieldDescriptorProto.Type]: ...\r
 189 \r
 190         @classmethod\r
 191         def items(cls) -> List[Tuple[bytes, FieldDescriptorProto.Type]]: ...\r
 192     TYPE_DOUBLE: Type\r
 193     TYPE_FLOAT: Type\r
 194     TYPE_INT64: Type\r
 195     TYPE_UINT64: Type\r
 196     TYPE_INT32: Type\r
 197     TYPE_FIXED64: Type\r
 198     TYPE_FIXED32: Type\r
 199     TYPE_BOOL: Type\r
 200     TYPE_STRING: Type\r
 201     TYPE_GROUP: Type\r
 202     TYPE_MESSAGE: Type\r
 203     TYPE_BYTES: Type\r
 204     TYPE_UINT32: Type\r
 205     TYPE_ENUM: Type\r
 206     TYPE_SFIXED32: Type\r
 207     TYPE_SFIXED64: Type\r
 208     TYPE_SINT32: Type\r
 209     TYPE_SINT64: Type\r
 210 \r
 211     class Label(int):\r
 212 \r
 213         @classmethod\r
 214         def Name(cls, number: int) -> bytes: ...\r
 215 \r
 216         @classmethod\r
 217         def Value(cls, name: bytes) -> FieldDescriptorProto.Label: ...\r
 218 \r
 219         @classmethod\r
 220         def keys(cls) -> List[bytes]: ...\r
 221 \r
 222         @classmethod\r
 223         def values(cls) -> List[FieldDescriptorProto.Label]: ...\r
 224 \r
 225         @classmethod\r
 226         def items(cls) -> List[Tuple[bytes, FieldDescriptorProto.Label]]: ...\r
 227     LABEL_OPTIONAL: Label\r
 228     LABEL_REQUIRED: Label\r
 229     LABEL_REPEATED: Label\r
 230     name = ...  # type: Text\r
 231     number = ...  # type: int\r
 232     label = ...  # type: FieldDescriptorProto.Label\r
 233     type = ...  # type: FieldDescriptorProto.Type\r
 234     type_name = ...  # type: Text\r
 235     extendee = ...  # type: Text\r
 236     default_value = ...  # type: Text\r
 237     oneof_index = ...  # type: int\r
 238     json_name = ...  # type: Text\r
 239 \r
 240     @property\r
 241     def options(self) -> FieldOptions: ...\r
 242 \r
 243     def __init__(self,\r
 244                  name: Optional[Text] = ...,\r
 245                  number: Optional[int] = ...,\r
 246                  label: Optional[FieldDescriptorProto.Label] = ...,\r
 247                  type: Optional[FieldDescriptorProto.Type] = ...,\r
 248                  type_name: Optional[Text] = ...,\r
 249                  extendee: Optional[Text] = ...,\r
 250                  default_value: Optional[Text] = ...,\r
 251                  oneof_index: Optional[int] = ...,\r
 252                  json_name: Optional[Text] = ...,\r
 253                  options: Optional[FieldOptions] = ...,\r
 254                  ) -> None: ...\r
 255 \r
 256     @classmethod\r
 257     def FromString(cls, s: bytes) -> FieldDescriptorProto: ...\r
 258 \r
 259 \r
 260 class OneofDescriptorProto(Message):\r
 261     name = ...  # type: Text\r
 262 \r
 263     @property\r
 264     def options(self) -> OneofOptions: ...\r
 265 \r
 266     def __init__(self,\r
 267                  name: Optional[Text] = ...,\r
 268                  options: Optional[OneofOptions] = ...,\r
 269                  ) -> None: ...\r
 270 \r
 271     @classmethod\r
 272     def FromString(cls, s: bytes) -> OneofDescriptorProto: ...\r
 273 \r
 274 \r
 275 class EnumDescriptorProto(Message):\r
 276 \r
 277     class EnumReservedRange(Message):\r
 278         start = ...  # type: int\r
 279         end = ...  # type: int\r
 280 \r
 281         def __init__(self,\r
 282                      start: Optional[int] = ...,\r
 283                      end: Optional[int] = ...,\r
 284                      ) -> None: ...\r
 285 \r
 286         @classmethod\r
 287         def FromString(\r
 288             cls, s: bytes) -> EnumDescriptorProto.EnumReservedRange: ...\r
 289     name = ...  # type: Text\r
 290     reserved_name = ...  # type: RepeatedScalarFieldContainer[Text]\r
 291 \r
 292     @property\r
 293     def value(\r
 294         self) -> RepeatedCompositeFieldContainer[EnumValueDescriptorProto]: ...\r
 295 \r
 296     @property\r
 297     def options(self) -> EnumOptions: ...\r
 298 \r
 299     @property\r
 300     def reserved_range(\r
 301         self) -> RepeatedCompositeFieldContainer[EnumDescriptorProto.EnumReservedRange]: ...\r
 302 \r
 303     def __init__(self,\r
 304                  name: Optional[Text] = ...,\r
 305                  value: Optional[Iterable[EnumValueDescriptorProto]] = ...,\r
 306                  options: Optional[EnumOptions] = ...,\r
 307                  reserved_range: Optional[Iterable[EnumDescriptorProto.EnumReservedRange]] = ...,\r
 308                  reserved_name: Optional[Iterable[Text]] = ...,\r
 309                  ) -> None: ...\r
 310 \r
 311     @classmethod\r
 312     def FromString(cls, s: bytes) -> EnumDescriptorProto: ...\r
 313 \r
 314 \r
 315 class EnumValueDescriptorProto(Message):\r
 316     name = ...  # type: Text\r
 317     number = ...  # type: int\r
 318 \r
 319     @property\r
 320     def options(self) -> EnumValueOptions: ...\r
 321 \r
 322     def __init__(self,\r
 323                  name: Optional[Text] = ...,\r
 324                  number: Optional[int] = ...,\r
 325                  options: Optional[EnumValueOptions] = ...,\r
 326                  ) -> None: ...\r
 327 \r
 328     @classmethod\r
 329     def FromString(cls, s: bytes) -> EnumValueDescriptorProto: ...\r
 330 \r
 331 \r
 332 class ServiceDescriptorProto(Message):\r
 333     name = ...  # type: Text\r
 334 \r
 335     @property\r
 336     def method(\r
 337         self) -> RepeatedCompositeFieldContainer[MethodDescriptorProto]: ...\r
 338 \r
 339     @property\r
 340     def options(self) -> ServiceOptions: ...\r
 341 \r
 342     def __init__(self,\r
 343                  name: Optional[Text] = ...,\r
 344                  method: Optional[Iterable[MethodDescriptorProto]] = ...,\r
 345                  options: Optional[ServiceOptions] = ...,\r
 346                  ) -> None: ...\r
 347 \r
 348     @classmethod\r
 349     def FromString(cls, s: bytes) -> ServiceDescriptorProto: ...\r
 350 \r
 351 \r
 352 class MethodDescriptorProto(Message):\r
 353     name = ...  # type: Text\r
 354     input_type = ...  # type: Text\r
 355     output_type = ...  # type: Text\r
 356     client_streaming = ...  # type: bool\r
 357     server_streaming = ...  # type: bool\r
 358 \r
 359     @property\r
 360     def options(self) -> MethodOptions: ...\r
 361 \r
 362     def __init__(self,\r
 363                  name: Optional[Text] = ...,\r
 364                  input_type: Optional[Text] = ...,\r
 365                  output_type: Optional[Text] = ...,\r
 366                  options: Optional[MethodOptions] = ...,\r
 367                  client_streaming: Optional[bool] = ...,\r
 368                  server_streaming: Optional[bool] = ...,\r
 369                  ) -> None: ...\r
 370 \r
 371     @classmethod\r
 372     def FromString(cls, s: bytes) -> MethodDescriptorProto: ...\r
 373 \r
 374 \r
 375 class FileOptions(Message):\r
 376 \r
 377     class OptimizeMode(int):\r
 378 \r
 379         @classmethod\r
 380         def Name(cls, number: int) -> bytes: ...\r
 381 \r
 382         @classmethod\r
 383         def Value(cls, name: bytes) -> FileOptions.OptimizeMode: ...\r
 384 \r
 385         @classmethod\r
 386         def keys(cls) -> List[bytes]: ...\r
 387 \r
 388         @classmethod\r
 389         def values(cls) -> List[FileOptions.OptimizeMode]: ...\r
 390 \r
 391         @classmethod\r
 392         def items(cls) -> List[Tuple[bytes, FileOptions.OptimizeMode]]: ...\r
 393     SPEED: OptimizeMode\r
 394     CODE_SIZE: OptimizeMode\r
 395     LITE_RUNTIME: OptimizeMode\r
 396     java_package = ...  # type: Text\r
 397     java_outer_classname = ...  # type: Text\r
 398     java_multiple_files = ...  # type: bool\r
 399     java_generate_equals_and_hash = ...  # type: bool\r
 400     java_string_check_utf8 = ...  # type: bool\r
 401     optimize_for = ...  # type: FileOptions.OptimizeMode\r
 402     go_package = ...  # type: Text\r
 403     cc_generic_services = ...  # type: bool\r
 404     java_generic_services = ...  # type: bool\r
 405     py_generic_services = ...  # type: bool\r
 406     php_generic_services = ...  # type: bool\r
 407     deprecated = ...  # type: bool\r
 408     cc_enable_arenas = ...  # type: bool\r
 409     objc_class_prefix = ...  # type: Text\r
 410     csharp_namespace = ...  # type: Text\r
 411     swift_prefix = ...  # type: Text\r
 412     php_class_prefix = ...  # type: Text\r
 413     php_namespace = ...  # type: Text\r
 414 \r
 415     @property\r
 416     def uninterpreted_option(\r
 417         self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...\r
 418 \r
 419     def __init__(self,\r
 420                  java_package: Optional[Text] = ...,\r
 421                  java_outer_classname: Optional[Text] = ...,\r
 422                  java_multiple_files: Optional[bool] = ...,\r
 423                  java_generate_equals_and_hash: Optional[bool] = ...,\r
 424                  java_string_check_utf8: Optional[bool] = ...,\r
 425                  optimize_for: Optional[FileOptions.OptimizeMode] = ...,\r
 426                  go_package: Optional[Text] = ...,\r
 427                  cc_generic_services: Optional[bool] = ...,\r
 428                  java_generic_services: Optional[bool] = ...,\r
 429                  py_generic_services: Optional[bool] = ...,\r
 430                  php_generic_services: Optional[bool] = ...,\r
 431                  deprecated: Optional[bool] = ...,\r
 432                  cc_enable_arenas: Optional[bool] = ...,\r
 433                  objc_class_prefix: Optional[Text] = ...,\r
 434                  csharp_namespace: Optional[Text] = ...,\r
 435                  swift_prefix: Optional[Text] = ...,\r
 436                  php_class_prefix: Optional[Text] = ...,\r
 437                  php_namespace: Optional[Text] = ...,\r
 438                  uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,\r
 439                  ) -> None: ...\r
 440 \r
 441     @classmethod\r
 442     def FromString(cls, s: bytes) -> FileOptions: ...\r
 443 \r
 444 \r
 445 class MessageOptions(Message):\r
 446     message_set_wire_format = ...  # type: bool\r
 447     no_standard_descriptor_accessor = ...  # type: bool\r
 448     deprecated = ...  # type: bool\r
 449     map_entry = ...  # type: bool\r
 450 \r
 451     @property\r
 452     def uninterpreted_option(\r
 453         self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...\r
 454 \r
 455     def __init__(self,\r
 456                  message_set_wire_format: Optional[bool] = ...,\r
 457                  no_standard_descriptor_accessor: Optional[bool] = ...,\r
 458                  deprecated: Optional[bool] = ...,\r
 459                  map_entry: Optional[bool] = ...,\r
 460                  uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,\r
 461                  ) -> None: ...\r
 462 \r
 463     @classmethod\r
 464     def FromString(cls, s: bytes) -> MessageOptions: ...\r
 465 \r
 466 \r
 467 class FieldOptions(Message):\r
 468 \r
 469     class CType(int):\r
 470 \r
 471         @classmethod\r
 472         def Name(cls, number: int) -> bytes: ...\r
 473 \r
 474         @classmethod\r
 475         def Value(cls, name: bytes) -> FieldOptions.CType: ...\r
 476 \r
 477         @classmethod\r
 478         def keys(cls) -> List[bytes]: ...\r
 479 \r
 480         @classmethod\r
 481         def values(cls) -> List[FieldOptions.CType]: ...\r
 482 \r
 483         @classmethod\r
 484         def items(cls) -> List[Tuple[bytes, FieldOptions.CType]]: ...\r
 485     STRING: CType\r
 486     CORD: CType\r
 487     STRING_PIECE: CType\r
 488 \r
 489     class JSType(int):\r
 490 \r
 491         @classmethod\r
 492         def Name(cls, number: int) -> bytes: ...\r
 493 \r
 494         @classmethod\r
 495         def Value(cls, name: bytes) -> FieldOptions.JSType: ...\r
 496 \r
 497         @classmethod\r
 498         def keys(cls) -> List[bytes]: ...\r
 499 \r
 500         @classmethod\r
 501         def values(cls) -> List[FieldOptions.JSType]: ...\r
 502 \r
 503         @classmethod\r
 504         def items(cls) -> List[Tuple[bytes, FieldOptions.JSType]]: ...\r
 505     JS_NORMAL: JSType\r
 506     JS_STRING: JSType\r
 507     JS_NUMBER: JSType\r
 508     ctype = ...  # type: FieldOptions.CType\r
 509     packed = ...  # type: bool\r
 510     jstype = ...  # type: FieldOptions.JSType\r
 511     lazy = ...  # type: bool\r
 512     deprecated = ...  # type: bool\r
 513     weak = ...  # type: bool\r
 514 \r
 515     @property\r
 516     def uninterpreted_option(\r
 517         self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...\r
 518 \r
 519     def __init__(self,\r
 520                  ctype: Optional[FieldOptions.CType] = ...,\r
 521                  packed: Optional[bool] = ...,\r
 522                  jstype: Optional[FieldOptions.JSType] = ...,\r
 523                  lazy: Optional[bool] = ...,\r
 524                  deprecated: Optional[bool] = ...,\r
 525                  weak: Optional[bool] = ...,\r
 526                  uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,\r
 527                  ) -> None: ...\r
 528 \r
 529     @classmethod\r
 530     def FromString(cls, s: bytes) -> FieldOptions: ...\r
 531 \r
 532 \r
 533 class OneofOptions(Message):\r
 534 \r
 535     @property\r
 536     def uninterpreted_option(\r
 537         self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...\r
 538 \r
 539     def __init__(self,\r
 540                  uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,\r
 541                  ) -> None: ...\r
 542 \r
 543     @classmethod\r
 544     def FromString(cls, s: bytes) -> OneofOptions: ...\r
 545 \r
 546 \r
 547 class EnumOptions(Message):\r
 548     allow_alias = ...  # type: bool\r
 549     deprecated = ...  # type: bool\r
 550 \r
 551     @property\r
 552     def uninterpreted_option(\r
 553         self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...\r
 554 \r
 555     def __init__(self,\r
 556                  allow_alias: Optional[bool] = ...,\r
 557                  deprecated: Optional[bool] = ...,\r
 558                  uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,\r
 559                  ) -> None: ...\r
 560 \r
 561     @classmethod\r
 562     def FromString(cls, s: bytes) -> EnumOptions: ...\r
 563 \r
 564 \r
 565 class EnumValueOptions(Message):\r
 566     deprecated = ...  # type: bool\r
 567 \r
 568     @property\r
 569     def uninterpreted_option(\r
 570         self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...\r
 571 \r
 572     def __init__(self,\r
 573                  deprecated: Optional[bool] = ...,\r
 574                  uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,\r
 575                  ) -> None: ...\r
 576 \r
 577     @classmethod\r
 578     def FromString(cls, s: bytes) -> EnumValueOptions: ...\r
 579 \r
 580 \r
 581 class ServiceOptions(Message):\r
 582     deprecated = ...  # type: bool\r
 583 \r
 584     @property\r
 585     def uninterpreted_option(\r
 586         self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...\r
 587 \r
 588     def __init__(self,\r
 589                  deprecated: Optional[bool] = ...,\r
 590                  uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,\r
 591                  ) -> None: ...\r
 592 \r
 593     @classmethod\r
 594     def FromString(cls, s: bytes) -> ServiceOptions: ...\r
 595 \r
 596 \r
 597 class MethodOptions(Message):\r
 598 \r
 599     class IdempotencyLevel(int):\r
 600 \r
 601         @classmethod\r
 602         def Name(cls, number: int) -> bytes: ...\r
 603 \r
 604         @classmethod\r
 605         def Value(cls, name: bytes) -> MethodOptions.IdempotencyLevel: ...\r
 606 \r
 607         @classmethod\r
 608         def keys(cls) -> List[bytes]: ...\r
 609 \r
 610         @classmethod\r
 611         def values(cls) -> List[MethodOptions.IdempotencyLevel]: ...\r
 612 \r
 613         @classmethod\r
 614         def items(cls) -> List[Tuple[bytes, MethodOptions.IdempotencyLevel]]: ...\r
 615     IDEMPOTENCY_UNKNOWN: IdempotencyLevel\r
 616     NO_SIDE_EFFECTS: IdempotencyLevel\r
 617     IDEMPOTENT: IdempotencyLevel\r
 618     deprecated = ...  # type: bool\r
 619     idempotency_level = ...  # type: MethodOptions.IdempotencyLevel\r
 620 \r
 621     @property\r
 622     def uninterpreted_option(\r
 623         self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ...\r
 624 \r
 625     def __init__(self,\r
 626                  deprecated: Optional[bool] = ...,\r
 627                  idempotency_level: Optional[MethodOptions.IdempotencyLevel] = ...,\r
 628                  uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ...,\r
 629                  ) -> None: ...\r
 630 \r
 631     @classmethod\r
 632     def FromString(cls, s: bytes) -> MethodOptions: ...\r
 633 \r
 634 \r
 635 class UninterpretedOption(Message):\r
 636 \r
 637     class NamePart(Message):\r
 638         name_part = ...  # type: Text\r
 639         is_extension = ...  # type: bool\r
 640 \r
 641         def __init__(self,\r
 642                      name_part: Text,\r
 643                      is_extension: bool,\r
 644                      ) -> None: ...\r
 645 \r
 646         @classmethod\r
 647         def FromString(cls, s: bytes) -> UninterpretedOption.NamePart: ...\r
 648     identifier_value = ...  # type: Text\r
 649     positive_int_value = ...  # type: int\r
 650     negative_int_value = ...  # type: int\r
 651     double_value = ...  # type: float\r
 652     string_value = ...  # type: bytes\r
 653     aggregate_value = ...  # type: Text\r
 654 \r
 655     @property\r
 656     def name(\r
 657         self) -> RepeatedCompositeFieldContainer[UninterpretedOption.NamePart]: ...\r
 658 \r
 659     def __init__(self,\r
 660                  name: Optional[Iterable[UninterpretedOption.NamePart]] = ...,\r
 661                  identifier_value: Optional[Text] = ...,\r
 662                  positive_int_value: Optional[int] = ...,\r
 663                  negative_int_value: Optional[int] = ...,\r
 664                  double_value: Optional[float] = ...,\r
 665                  string_value: Optional[bytes] = ...,\r
 666                  aggregate_value: Optional[Text] = ...,\r
 667                  ) -> None: ...\r
 668 \r
 669     @classmethod\r
 670     def FromString(cls, s: bytes) -> UninterpretedOption: ...\r
 671 \r
 672 \r
 673 class SourceCodeInfo(Message):\r
 674 \r
 675     class Location(Message):\r
 676         path = ...  # type: RepeatedScalarFieldContainer[int]\r
 677         span = ...  # type: RepeatedScalarFieldContainer[int]\r
 678         leading_comments = ...  # type: Text\r
 679         trailing_comments = ...  # type: Text\r
 680         leading_detached_comments = ...  # type: RepeatedScalarFieldContainer[Text]\r
 681 \r
 682         def __init__(self,\r
 683                      path: Optional[Iterable[int]] = ...,\r
 684                      span: Optional[Iterable[int]] = ...,\r
 685                      leading_comments: Optional[Text] = ...,\r
 686                      trailing_comments: Optional[Text] = ...,\r
 687                      leading_detached_comments: Optional[Iterable[Text]] = ...,\r
 688                      ) -> None: ...\r
 689 \r
 690         @classmethod\r
 691         def FromString(cls, s: bytes) -> SourceCodeInfo.Location: ...\r
 692 \r
 693     @property\r
 694     def location(\r
 695         self) -> RepeatedCompositeFieldContainer[SourceCodeInfo.Location]: ...\r
 696 \r
 697     def __init__(self,\r
 698                  location: Optional[Iterable[SourceCodeInfo.Location]] = ...,\r
 699                  ) -> None: ...\r
 700 \r
 701     @classmethod\r
 702     def FromString(cls, s: bytes) -> SourceCodeInfo: ...\r
 703 \r
 704 \r
 705 class GeneratedCodeInfo(Message):\r
 706 \r
 707     class Annotation(Message):\r
 708         path = ...  # type: RepeatedScalarFieldContainer[int]\r
 709         source_file = ...  # type: Text\r
 710         begin = ...  # type: int\r
 711         end = ...  # type: int\r
 712 \r
 713         def __init__(self,\r
 714                      path: Optional[Iterable[int]] = ...,\r
 715                      source_file: Optional[Text] = ...,\r
 716                      begin: Optional[int] = ...,\r
 717                      end: Optional[int] = ...,\r
 718                      ) -> None: ...\r
 719 \r
 720         @classmethod\r
 721         def FromString(cls, s: bytes) -> GeneratedCodeInfo.Annotation: ...\r
 722 \r
 723     @property\r
 724     def annotation(\r
 725         self) -> RepeatedCompositeFieldContainer[GeneratedCodeInfo.Annotation]: ...\r
 726 \r
 727     def __init__(self,\r
 728                  annotation: Optional[Iterable[GeneratedCodeInfo.Annotation]] = ...,\r
 729                  ) -> None: ...\r
 730 \r
 731     @classmethod\r
 732     def FromString(cls, s: bytes) -> GeneratedCodeInfo: ...\r