pyderasn.pyi

   1 from datetime import datetime
   2 from typing import Any as TAny
   3 from typing import Dict
   4 from typing import NamedTuple
   5 from typing import Optional
   6 from typing import Sequence as TSequence
   7 from typing import Tuple
   8 from typing import Type
   9 from typing import Union
  10
  11
  12 TagClassUniversal = ...  # type: int
  13 TagClassApplication = ...  # type: int
  14 TagClassContext = ...  # type: int
  15 TagClassPrivate = ...  # type: int
  16 TagFormPrimitive = ...  # type: int
  17 TagFormConstructed = ...  # type: int
  18 TagClassReprs = ...  # type: Dict[int, str]
  19
  20
  21 class DecodeError(Exception):
  22     msg = ...  # type: str
  23     klass = ...  # type: Type
  24     decode_path = ...  # type: Tuple[str, ...]
  25     offset = ...  # type: int
  26
  27     def __init__(
  28             self,
  29             msg: str=...,
  30             klass: Optional[TAny]=...,
  31             decode_path: TAny=...,
  32             offset: int=...,
  33     ) -> None: ...
  34
  35 class NotEnoughData(DecodeError): ...
  36
  37 class TagMismatch(DecodeError): ...
  38
  39 class InvalidLength(DecodeError): ...
  40
  41 class InvalidOID(DecodeError): ...
  42
  43 class ObjUnknown(ValueError):
  44     name = ...  # type: str
  45
  46     def __init__(self, name: str) -> None: ...
  47
  48 class ObjNotReady(ValueError):
  49     name = ...  # type: str
  50
  51     def __init__(self, str) -> None: ...
  52
  53 class InvalidValueType(ValueError):
  54     expected_types = ...  # type: Tuple[Type, ...]
  55
  56     def __init__(self, expected_types: Tuple[Type, ...]) -> None: ...
  57
  58 class BoundsError(ValueError):
  59     bound_min = ...  # type: int
  60     value = ...  # type: int
  61     bound_max = ...  # type: int
  62
  63     def __init__(self, bound_min: int, value: int, bound_max: int) -> None: ...
  64
  65 def hexdec(data: str) -> bytes: ...
  66
  67 def hexenc(data: bytes) -> str: ...
  68
  69 def int_bytes_len(num: int, byte_len: int=...) -> int: ...
  70
  71 def zero_ended_encode(num: int) -> bytes: ...
  72
  73 def tag_encode(num: int, klass: int=..., form: int=...) -> bytes: ...
  74
  75 def tag_decode(tag: bytes) -> Tuple[int, int, int]: ...
  76
  77 def tag_ctxp(num: int) -> bytes: ...
  78
  79 def tag_ctxc(num: int) -> bytes: ...
  80
  81 def tag_strip(data: memoryview) -> Tuple[memoryview, int, memoryview]: ...
  82
  83 def len_encode(l: int) -> bytes: ...
  84
  85 def len_decode(data: memoryview) -> Tuple[int, int, memoryview]: ...
  86
  87 class Obj:
  88     tag = ...  # type: bytes
  89     optional = ...  # type: bool
  90
  91     def __init__(
  92             self,
  93             impl: Optional[bytes]=...,
  94             expl: Optional[bytes]=...,
  95             default: Optional[TAny]=...,
  96             optional: bool=...,
  97     ) -> None: ...
  98
  99     @property
 100     def ready(self) -> bool: ...
 101
 102     @property
 103     def decoded(self) -> bool: ...
 104
 105     def copy(self) -> "Obj": ...
 106
 107     @property
 108     def tlen(self) -> int: ...
 109
 110     @property
 111     def tlvlen(self) -> int: ...
 112
 113     def encode(self) -> bytes: ...
 114
 115     def decode(
 116             self,
 117             data: bytes,
 118             offset: int=...,
 119             leavemm: bool=...,
 120             decode_path: Tuple[str, ...]=...,
 121             ctx: Optional[Dict[str, TAny]]=...,
 122     ) -> Tuple[Obj, bytes]: ...
 123
 124     @property
 125     def expled(self) -> bool: ...
 126
 127     @property
 128     def expl_tag(self) -> bytes: ...
 129
 130     @property
 131     def expl_tlen(self) -> int: ...
 132
 133     @property
 134     def expl_llen(self) -> int: ...
 135
 136     @property
 137     def expl_offset(self) -> int: ...
 138
 139     @property
 140     def expl_vlen(self) -> int: ...
 141
 142     @property
 143     def expl_tlvlen(self) -> int: ...
 144
 145
 146 PP = NamedTuple("PP", (
 147     ("asn1_type_name", str),
 148     ("obj_name", str),
 149     ("decode_path", Tuple[str, ...]),
 150     ("value", Optional[str]),
 151     ("blob", Optional[Union[bytes, Tuple[str, ...]]]),
 152     ("optional", bool),
 153     ("default", bool),
 154     ("impl", Optional[Tuple[int, int, int]]),
 155     ("expl", Optional[Tuple[int, int, int]]),
 156     ("offset", int),
 157     ("tlen", int),
 158     ("llen", int),
 159     ("vlen", int),
 160     ("expl_offset", int),
 161     ("expl_tlen", int),
 162     ("expl_llen", int),
 163     ("expl_vlen", int),
 164 ))
 165
 166
 167 def pp_console_row(
 168         pp: PP,
 169         oids: Optional[Dict[str, str]]=...,
 170         with_offsets: bool=...,
 171         with_blob: bool=...,
 172 ): ...
 173
 174 def pp_console_blob(pp: PP) -> TSequence[str]: ...
 175
 176 def pprint(
 177         obj: Obj,
 178         oids: Optional[Dict[str, str]]=...,
 179         big_blobs: bool=...,
 180 ): ...
 181
 182
 183 class Boolean(Obj):
 184     tag_default = ...  # type: bytes
 185     asn1_type_name = ...  # type: str
 186     default = ...  # type: "Boolean"
 187     optional = ...  # type: bool
 188
 189     def __init__(
 190             self,
 191             value: Optional[Union["Boolean", bool]]=...,
 192             impl: Optional[bytes]=...,
 193             expl: Optional[bytes]=...,
 194             default: Optional[Union["Boolean", bool]]=...,
 195             optional: bool=...,
 196     ) -> None: ...
 197
 198     @property
 199     def ready(self) -> bool: ...
 200
 201     def copy(self) -> "Boolean": ...
 202
 203     def __call__(
 204             self,
 205             value: Optional[Union["Boolean", bool]]=...,
 206             impl: Optional[bytes]=...,
 207             expl: Optional[bytes]=...,
 208             default: Optional[Union["Boolean", bool]]=...,
 209             optional: Optional[bool]=...,
 210     ) -> "Boolean": ...
 211
 212     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
 213
 214
 215 class Integer(Obj):
 216     tag_default = ...  # type: bytes
 217     asn1_type_name = ...  # type: str
 218     specs = ...  # type: Dict[str, int]
 219     default = ...  # type: "Integer"
 220     optional = ...  # type: bool
 221
 222     def __init__(
 223             self,
 224             value: Optional[Union["Integer", int, str]]=...,
 225             bounds: Optional[Tuple[int, int]]=...,
 226             impl: Optional[bytes]=...,
 227             expl: Optional[bytes]=...,
 228             default: Optional[Union["Integer", int, str]]=...,
 229             optional: bool=...,
 230     ) -> None: ...
 231
 232     @property
 233     def ready(self) -> bool: ...
 234
 235     def copy(self) -> "Integer": ...
 236
 237     @property
 238     def named(self) -> Optional[str]: ...
 239
 240     def __call__(
 241             self,
 242             value: Optional[Union["Integer", int, str]]=...,
 243             bounds: Optional[Tuple[int, int]]=...,
 244             impl: Optional[bytes]=...,
 245             expl: Optional[bytes]=...,
 246             default: Optional[Union["Integer", int, str]]=...,
 247             optional: Optional[bool]=...,
 248     ) -> "Integer": ...
 249
 250     def __int__(self) -> int: ...
 251
 252     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
 253
 254
 255 class BitString(Obj):
 256     tag_default = ...  # type: bytes
 257     asn1_type_name = ...  # type: str
 258     specs = ...  # type: Dict[str, int]
 259     default = ...  # type: "BitString"
 260     optional = ...  # type: bool
 261
 262     def __init__(
 263             self,
 264             value: Optional[Union["BitString", bytes, Tuple[str, ...]]]=...,
 265             impl: Optional[bytes]=...,
 266             expl: Optional[bytes]=...,
 267             default: Optional[Union["BitString", bytes, Tuple[str, ...]]]=...,
 268             optional: bool=...,
 269     ) -> None: ...
 270
 271     @property
 272     def ready(self) -> bool: ...
 273
 274     def copy(self) -> "BitString": ...
 275
 276     @property
 277     def bit_len(self) -> int: ...
 278
 279     @property
 280     def named(self) -> TSequence[str]: ...
 281
 282     def __call__(
 283             self,
 284             value: Optional[Union["BitString", bytes, Tuple[str, ...]]]=...,
 285             impl: Optional[bytes]=...,
 286             expl: Optional[bytes]=...,
 287             default: Optional[Union["BitString", bytes, Tuple[str, ...]]]=...,
 288             optional: Optional[bool]=...,
 289     ) -> "BitString": ...
 290
 291     def __bytes__(self) -> bytes: ...
 292
 293     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
 294
 295
 296 class OctetString(Obj):
 297     tag_default = ...  # type: bytes
 298     asn1_type_name = ...  # type: str
 299     default = ...  # type: "OctetString"
 300     optional = ...  # type: bool
 301     defined = ...  # type: Tuple[ObjectIdentifier, Obj]
 302
 303     def __init__(
 304             self,
 305             value: Optional[Union["OctetString", bytes]]=...,
 306             bounds: Optional[Tuple[int, int]]=...,
 307             impl: Optional[bytes]=...,
 308             expl: Optional[bytes]=...,
 309             default: Optional[Union["OctetString", bytes]]=...,
 310             optional: bool=...,
 311     ) -> None: ...
 312
 313     @property
 314     def ready(self) -> bool: ...
 315
 316     def copy(self) -> "OctetString": ...
 317
 318     def __call__(
 319             self,
 320             value: Optional[Union["OctetString", bytes]]=...,
 321             bounds: Optional[Tuple[int, int]]=...,
 322             impl: Optional[bytes]=...,
 323             expl: Optional[bytes]=...,
 324             default: Optional[Union["OctetString", bytes]]=...,
 325             optional: Optional[bool]=...,
 326     ) -> "OctetString": ...
 327
 328     def __bytes__(self) -> bytes: ...
 329
 330     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
 331
 332
 333 class Null(Obj):
 334     tag_default = ...  # type: bytes
 335     asn1_type_name = ...  # type: str
 336     default = ...  # type: "Null"
 337     optional = ...  # type: bool
 338
 339     def __init__(
 340             self,
 341             impl: Optional[bytes]=...,
 342             expl: Optional[bytes]=...,
 343             optional: bool=...,
 344     ) -> None: ...
 345
 346     @property
 347     def ready(self) -> bool: ...
 348
 349     def copy(self) -> "Null": ...
 350
 351     def __call__(
 352             self,
 353             impl: Optional[bytes]=...,
 354             expl: Optional[bytes]=...,
 355             optional: Optional[bool]=...,
 356     ) -> "Null": ...
 357
 358     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
 359
 360
 361 class ObjectIdentifier(Obj):
 362     tag_default = ...  # type: bytes
 363     asn1_type_name = ...  # type: str
 364     default = ...  # type: "ObjectIdentifier"
 365     optional = ...  # type: bool
 366
 367     def __init__(
 368             self,
 369             value: Optional[Union["ObjectIdentifier", str, Tuple[int, ...]]]=...,
 370             defines: Optional[Sequence[Tuple[str, Dict["ObjectIdentifier", Obj]]]],
 371             impl: Optional[bytes]=...,
 372             expl: Optional[bytes]=...,
 373             default: Optional[Union["ObjectIdentifier", str, Tuple[int, ...]]]=...,
 374             optional: bool=...,
 375     ) -> None: ...
 376
 377     @property
 378     def ready(self) -> bool: ...
 379
 380     def copy(self) -> "ObjectIdentifier": ...
 381
 382     def __call__(
 383             self,
 384             value: Optional[Union["ObjectIdentifier", str, Tuple[int, ...]]]=...,
 385             impl: Optional[bytes]=...,
 386             expl: Optional[bytes]=...,
 387             default: Optional[Union["ObjectIdentifier", str, Tuple[int, ...]]]=...,
 388             optional: Optional[bool]=...,
 389     ) -> "ObjectIdentifier": ...
 390
 391     def __add__(
 392             self,
 393             their: Union["ObjectIdentifier", Tuple[int, ...]],
 394     ) -> "ObjectIdentifier": ...
 395
 396     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
 397
 398
 399 class Enumerated(Integer):
 400     tag_default = ...  # type: bytes
 401     asn1_type_name = ...  # type: str
 402     default = ...  # type: "Enumerated"
 403     optional = ...  # type: bool
 404
 405     def __init__(
 406             self,
 407             value: Optional[Union["Enumerated", str, int]]=...,
 408             impl: Optional[bytes]=...,
 409             expl: Optional[bytes]=...,
 410             default: Optional[Union["Enumerated", str, int]]=...,
 411             optional: bool=...,
 412     ) -> None: ...
 413
 414     def copy(self) -> "Enumerated": ...
 415
 416     def __call__(  # type: ignore
 417             self,
 418             value: Optional[Union["Enumerated", str, int]]=...,
 419             impl: Optional[bytes]=...,
 420             expl: Optional[bytes]=...,
 421             default: Optional[Union["Enumerated", str, int]]=...,
 422             optional: Optional[bool]=...,
 423     ) -> "Enumerated": ...
 424
 425
 426 class CommonString(OctetString):
 427     def pps(
 428             self,
 429             decode_path: Tuple[str, ...]=...,
 430             no_unicode: bool=...,
 431     ) -> TSequence[PP]: ...
 432
 433
 434 class UTF8String(CommonString):
 435     tag_default = ...  # type: bytes
 436     encoding = ...  # type: str
 437     asn1_type_name = ...  # type: str
 438     default = ...  # type: "UTF8String"
 439     optional = ...  # type: bool
 440
 441     def __init__(
 442             self,
 443             value: Optional[Union["UTF8String", str, bytes]]=...,
 444             bounds: Optional[Tuple[int, int]]=...,
 445             impl: Optional[bytes]=...,
 446             expl: Optional[bytes]=...,
 447             default: Optional[Union["UTF8String", str, bytes]]=...,
 448             optional: bool=...,
 449     ) -> None: ...
 450
 451     def __str__(self) -> str: ...
 452
 453
 454 class NumericString(CommonString):
 455     tag_default = ...  # type: bytes
 456     encoding = ...  # type: str
 457     asn1_type_name = ...  # type: str
 458     default = ...  # type: "NumericString"
 459     optional = ...  # type: bool
 460
 461     def __init__(
 462             self,
 463             value: Optional[Union["NumericString", str, bytes]]=...,
 464             bounds: Optional[Tuple[int, int]]=...,
 465             impl: Optional[bytes]=...,
 466             expl: Optional[bytes]=...,
 467             default: Optional[Union["NumericString", str, bytes]]=...,
 468             optional: bool=...,
 469     ) -> None: ...
 470
 471
 472 class PrintableString(CommonString):
 473     tag_default = ...  # type: bytes
 474     encoding = ...  # type: str
 475     asn1_type_name = ...  # type: str
 476     default = ...  # type: "PrintableString"
 477     optional = ...  # type: bool
 478
 479     def __init__(
 480             self,
 481             value: Optional[Union["PrintableString", str, bytes]]=...,
 482             bounds: Optional[Tuple[int, int]]=...,
 483             impl: Optional[bytes]=...,
 484             expl: Optional[bytes]=...,
 485             default: Optional[Union["PrintableString", str, bytes]]=...,
 486             optional: bool=...,
 487     ) -> None: ...
 488
 489
 490 class TeletexString(CommonString):
 491     tag_default = ...  # type: bytes
 492     encoding = ...  # type: str
 493     asn1_type_name = ...  # type: str
 494     default = ...  # type: "TeletexString"
 495     optional = ...  # type: bool
 496
 497     def __init__(
 498             self,
 499             value: Optional[Union["TeletexString", str, bytes]]=...,
 500             bounds: Optional[Tuple[int, int]]=...,
 501             impl: Optional[bytes]=...,
 502             expl: Optional[bytes]=...,
 503             default: Optional[Union["TeletexString", str, bytes]]=...,
 504             optional: bool=...,
 505     ) -> None: ...
 506
 507
 508 class T61String(TeletexString):
 509     asn1_type_name = ...  # type: str
 510     default = ...  # type: "T61String"
 511     optional = ...  # type: bool
 512
 513
 514 class VideotexString(CommonString):
 515     tag_default = ...  # type: bytes
 516     encoding = ...  # type: str
 517     asn1_type_name = ...  # type: str
 518     default = ...  # type: "VideotexString"
 519     optional = ...  # type: bool
 520
 521     def __init__(
 522             self,
 523             value: Optional[Union["VideotexString", str, bytes]]=...,
 524             bounds: Optional[Tuple[int, int]]=...,
 525             impl: Optional[bytes]=...,
 526             expl: Optional[bytes]=...,
 527             default: Optional[Union["VideotexString", str, bytes]]=...,
 528             optional: bool=...,
 529     ) -> None: ...
 530
 531
 532 class IA5String(CommonString):
 533     tag_default = ...  # type: bytes
 534     encoding = ...  # type: str
 535     asn1_type_name = ...  # type: str
 536     default = ...  # type: "IA5String"
 537     optional = ...  # type: bool
 538
 539     def __init__(
 540             self,
 541             value: Optional[Union["IA5String", str, bytes]]=...,
 542             bounds: Optional[Tuple[int, int]]=...,
 543             impl: Optional[bytes]=...,
 544             expl: Optional[bytes]=...,
 545             default: Optional[Union["IA5String", str, bytes]]=...,
 546             optional: bool=...,
 547     ) -> None: ...
 548
 549
 550 class UTCTime(CommonString):
 551     tag_default = ...  # type: bytes
 552     encoding = ...  # type: str
 553     asn1_type_name = ...  # type: str
 554     default = ...  # type: "UTCTime"
 555     optional = ...  # type: bool
 556
 557     def __init__(
 558             self,
 559             value: Optional[Union["UTCTime", datetime]]=...,
 560             impl: Optional[bytes]=...,
 561             expl: Optional[bytes]=...,
 562             default: Optional[Union["UTCTime", datetime]]=...,
 563             optional: bool=...,
 564     ) -> None: ...
 565
 566     def todatetime(self) -> datetime: ...
 567
 568     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...  # type: ignore
 569
 570
 571 class GeneralizedTime(UTCTime):
 572     tag_default = ...  # type: bytes
 573     asn1_type_name = ...  # type: str
 574     default = ...  # type: "GeneralizedTime"
 575     optional = ...  # type: bool
 576
 577     def todatetime(self) -> datetime: ...
 578
 579
 580 class GraphicString(CommonString):
 581     tag_default = ...  # type: bytes
 582     encoding = ...  # type: str
 583     asn1_type_name = ...  # type: str
 584     default = ...  # type: "GraphicString"
 585     optional = ...  # type: bool
 586
 587     def __init__(
 588             self,
 589             value: Optional[Union["GraphicString", str, bytes]]=...,
 590             bounds: Optional[Tuple[int, int]]=...,
 591             impl: Optional[bytes]=...,
 592             expl: Optional[bytes]=...,
 593             default: Optional[Union["GraphicString", str, bytes]]=...,
 594             optional: bool=...,
 595     ) -> None: ...
 596
 597
 598 class VisibleString(CommonString):
 599     tag_default = ...  # type: bytes
 600     encoding = ...  # type: str
 601     asn1_type_name = ...  # type: str
 602     default = ...  # type: "VisibleString"
 603     optional = ...  # type: bool
 604
 605     def __init__(
 606             self,
 607             value: Optional[Union["VisibleString", str, bytes]]=...,
 608             bounds: Optional[Tuple[int, int]]=...,
 609             impl: Optional[bytes]=...,
 610             expl: Optional[bytes]=...,
 611             default: Optional[Union["VisibleString", str, bytes]]=...,
 612             optional: bool=...,
 613     ) -> None: ...
 614
 615
 616 class ISO646String(VisibleString):
 617     asn1_type_name = ...  # type: str
 618     default = ...  # type: "ISO646String"
 619     optional = ...  # type: bool
 620
 621
 622 class GeneralString(CommonString):
 623     tag_default = ...  # type: bytes
 624     encoding = ...  # type: str
 625     asn1_type_name = ...  # type: str
 626     default = ...  # type: "GeneralString"
 627     optional = ...  # type: bool
 628
 629     def __init__(
 630             self,
 631             value: Optional[Union["GeneralString", str, bytes]]=...,
 632             bounds: Optional[Tuple[int, int]]=...,
 633             impl: Optional[bytes]=...,
 634             expl: Optional[bytes]=...,
 635             default: Optional[Union["GeneralString", str, bytes]]=...,
 636             optional: bool=...,
 637     ) -> None: ...
 638
 639
 640 class UniversalString(CommonString):
 641     tag_default = ...  # type: bytes
 642     encoding = ...  # type: str
 643     asn1_type_name = ...  # type: str
 644     default = ...  # type: "UniversalString"
 645     optional = ...  # type: bool
 646
 647     def __init__(
 648             self,
 649             value: Optional[Union["UniversalString", str, bytes]]=...,
 650             bounds: Optional[Tuple[int, int]]=...,
 651             impl: Optional[bytes]=...,
 652             expl: Optional[bytes]=...,
 653             default: Optional[Union["UniversalString", str, bytes]]=...,
 654             optional: bool=...,
 655     ) -> None: ...
 656
 657
 658 class BMPString(CommonString):
 659     tag_default = ...  # type: bytes
 660     encoding = ...  # type: str
 661     asn1_type_name = ...  # type: str
 662     default = ...  # type: "BMPString"
 663     optional = ...  # type: bool
 664
 665     def __init__(
 666             self,
 667             value: Optional[Union["BMPString", str, bytes]]=...,
 668             bounds: Optional[Tuple[int, int]]=...,
 669             impl: Optional[bytes]=...,
 670             expl: Optional[bytes]=...,
 671             default: Optional[Union["BMPString", str, bytes]]=...,
 672             optional: bool=...,
 673     ) -> None: ...
 674
 675
 676 class Choice(Obj):
 677     tag_default = ...  # type: bytes
 678     asn1_type_name = ...  # type: str
 679     specs = ...  # type: Dict[str, Obj]
 680     default = ...  # type: "Choice"
 681     optional = ...  # type: bool
 682
 683     def __init__(
 684             self,
 685             value: Optional[Union["Choice", Tuple[str, Obj]]]=...,
 686             impl: Optional[bytes]=...,
 687             expl: Optional[bytes]=...,
 688             default: Optional[Union["Choice", Tuple[str, Obj]]]=...,
 689             optional: bool=...,
 690     ) -> None: ...
 691
 692     @property
 693     def ready(self) -> bool: ...
 694
 695     def copy(self) -> "Choice": ...
 696
 697     def __call__(
 698             self,
 699             value: Optional[Union["Choice", Tuple[str, Obj]]]=...,
 700             expl: Optional[bytes]=...,
 701             default: Optional[Union["Choice", Tuple[str, Obj]]]=...,
 702             optional: Optional[bool]=...,
 703     ) -> "Choice": ...
 704
 705     def __getitem__(self, key: str) -> Optional[Obj]: ...
 706
 707     def __setitem__(self, key: str, value: Obj) -> None: ...
 708
 709     @property
 710     def choice(self) -> str: ...
 711
 712     @property
 713     def value(self) -> Obj: ...
 714
 715     @property
 716     def tlen(self) -> int: ...
 717
 718     @property
 719     def decoded(self) -> bool: ...
 720
 721     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
 722
 723
 724 class PrimitiveTypes(Choice):
 725     schema = ...  # type: Dict[str, Obj]
 726
 727
 728 class Any(Obj):
 729     tag_default = ...  # type: bytes
 730     asn1_type_name = ...  # type: str
 731     default = ...  # type: "Any"
 732     optional = ...  # type: bool
 733     defined = ...  # type: Tuple[ObjectIdentifier, Obj]
 734
 735     def __init__(
 736             self,
 737             value: Optional[Union[Obj, bytes]]=...,
 738             expl: Optional[bytes]=...,
 739             optional: bool=...,
 740     ) -> None: ...
 741
 742     @property
 743     def ready(self) -> bool: ...
 744
 745     def copy(self) -> "Any": ...
 746
 747     def __call__(
 748             self,
 749             value: Optional[Union[Obj, bytes]]=...,
 750             expl: Optional[bytes]=...,
 751             optional: Optional[bool]=...,
 752     ) -> "Any": ...
 753
 754     def __bytes__(self) -> bytes: ...
 755
 756     @property
 757     def tlen(self) -> int: ...
 758
 759     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
 760
 761
 762 class Sequence(Obj):
 763     tag_default = ...  # type: bytes
 764     asn1_type_name = ...  # type: str
 765     specs = ...  # type: Dict[str, Obj]
 766     default = ...  # type: "Sequence"
 767     optional = ...  # type: bool
 768
 769     def __init__(
 770             self,
 771             value: Optional["Sequence"]=...,
 772             impl: Optional[bytes]=...,
 773             expl: Optional[bytes]=...,
 774             default: Optional["Sequence"]=...,
 775             optional: bool=...,
 776     ) -> None: ...
 777
 778     @property
 779     def ready(self) -> bool: ...
 780
 781     def copy(self) -> "Sequence": ...
 782
 783     def __call__(
 784             self,
 785             value: Optional["Sequence"]=...,
 786             impl: Optional[bytes]=...,
 787             expl: Optional[bytes]=...,
 788             default: Optional["Sequence"]=...,
 789             optional: Optional[bool]=...,
 790     ) -> "Sequence": ...
 791
 792     def __getitem__(self, key: str) -> Optional[Obj]: ...
 793
 794     def __setitem__(self, key: str, value: Obj) -> None: ...
 795
 796     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
 797
 798
 799 class Set(Sequence):
 800     tag_default = ...  # type: bytes
 801     asn1_type_name = ...  # type: str
 802     default = ...  # type: "Set"
 803     optional = ...  # type: bool
 804
 805
 806 class SequenceOf(Obj):
 807     tag_default = ...  # type: bytes
 808     asn1_type_name = ...  # type: str
 809     spec = ...  # type: Obj
 810     default = ...  # type: "SequenceOf"
 811     optional = ...  # type: bool
 812
 813     def __init__(
 814             self,
 815             value: Optional[Union["SequenceOf", TSequence[Obj]]]=...,
 816             bounds: Optional[Tuple[int, int]]=...,
 817             impl: Optional[bytes]=...,
 818             expl: Optional[bytes]=...,
 819             default: Optional[Union["SequenceOf", TSequence[Obj]]]=...,
 820             optional: Optional[bool]=...,
 821     ) -> None: ...
 822
 823     @property
 824     def ready(self) -> bool: ...
 825
 826     def copy(self) -> "SequenceOf": ...
 827
 828     def __call__(
 829             self,
 830             value: Optional[Union["SequenceOf", TSequence[Obj]]]=...,
 831             bounds: Optional[Tuple[int, int]]=...,
 832             impl: Optional[bytes]=...,
 833             expl: Optional[bytes]=...,
 834             default: Optional[Union["SequenceOf", TSequence[Obj]]]=...,
 835             optional: Optional[bool]=...,
 836     ) -> "SequenceOf": ...
 837
 838     def __getitem__(self, key: int) -> Obj: ...
 839
 840     def __iter__(self) -> TSequence[Obj]: ...
 841
 842     def append(self, value: Obj) -> None: ...
 843
 844     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
 845
 846
 847 class SetOf(SequenceOf):
 848     tag_default = ...  # type: bytes
 849     asn1_type_name = ...  # type: str
 850     default = ...  # type: "SetOf"
 851     optional = ...  # type: bool
 852
 853
 854 def obj_by_path(pypath: str) -> TAny: ...