Initial revision
[pyderasn.git] / 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     ) -> Tuple[Obj, bytes]: ...
122
123     @property
124     def expled(self) -> bool: ...
125
126     @property
127     def expl_tag(self) -> bytes: ...
128
129     @property
130     def expl_tlen(self) -> int: ...
131
132     @property
133     def expl_llen(self) -> int: ...
134
135     @property
136     def expl_offset(self) -> int: ...
137
138     @property
139     def expl_vlen(self) -> int: ...
140
141     @property
142     def expl_tlvlen(self) -> int: ...
143
144
145 PP = NamedTuple("PP", (
146     ("asn1_type_name", str),
147     ("obj_name", str),
148     ("decode_path", Tuple[str, ...]),
149     ("value", Optional[str]),
150     ("blob", Optional[Union[bytes, Tuple[str, ...]]]),
151     ("optional", bool),
152     ("default", bool),
153     ("impl", Optional[Tuple[int, int, int]]),
154     ("expl", Optional[Tuple[int, int, int]]),
155     ("offset", int),
156     ("tlen", int),
157     ("llen", int),
158     ("vlen", int),
159     ("expl_offset", int),
160     ("expl_tlen", int),
161     ("expl_llen", int),
162     ("expl_vlen", int),
163 ))
164
165
166 def pp_console_row(
167         pp: PP,
168         oids: Optional[Dict[str, str]]=...,
169         with_offsets: bool=...,
170         with_blob: bool=...,
171 ): ...
172
173 def pp_console_blob(pp: PP) -> TSequence[str]: ...
174
175 def pprint(
176         obj: Obj,
177         oids: Optional[Dict[str, str]]=...,
178         big_blobs: bool=...,
179 ): ...
180
181
182 class Boolean(Obj):
183     tag_default = ...  # type: bytes
184     asn1_type_name = ...  # type: str
185     default = ...  # type: "Boolean"
186
187     def __init__(
188             self,
189             value: Optional[Union["Boolean", bool]]=...,
190             impl: Optional[bytes]=...,
191             expl: Optional[bytes]=...,
192             default: Optional[Union["Boolean", bool]]=...,
193             optional: bool=...,
194     ) -> None: ...
195
196     @property
197     def ready(self) -> bool: ...
198
199     def copy(self) -> "Boolean": ...
200
201     def __call__(
202             self,
203             value: Optional[Union["Boolean", bool]]=...,
204             impl: Optional[bytes]=...,
205             expl: Optional[bytes]=...,
206             default: Optional[Union["Boolean", bool]]=...,
207             optional: Optional[bool]=...,
208     ) -> "Boolean": ...
209
210     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
211
212
213 class Integer(Obj):
214     tag_default = ...  # type: bytes
215     asn1_type_name = ...  # type: str
216     specs = ...  # type: Dict[str, int]
217     default = ...  # type: "Integer"
218
219     def __init__(
220             self,
221             value: Optional[Union["Integer", int, str]]=...,
222             bounds: Optional[Tuple[int, int]]=...,
223             impl: Optional[bytes]=...,
224             expl: Optional[bytes]=...,
225             default: Optional[Union["Integer", int, str]]=...,
226             optional: bool=...,
227     ) -> None: ...
228
229     @property
230     def ready(self) -> bool: ...
231
232     def copy(self) -> "Integer": ...
233
234     @property
235     def named(self) -> Optional[str]: ...
236
237     def __call__(
238             self,
239             value: Optional[Union["Integer", int, str]]=...,
240             bounds: Optional[Tuple[int, int]]=...,
241             impl: Optional[bytes]=...,
242             expl: Optional[bytes]=...,
243             default: Optional[Union["Integer", int, str]]=...,
244             optional: Optional[bool]=...,
245     ) -> "Integer": ...
246
247     def __int__(self) -> int: ...
248
249     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
250
251
252 class BitString(Obj):
253     tag_default = ...  # type: bytes
254     asn1_type_name = ...  # type: str
255     specs = ...  # type: Dict[str, int]
256     default = ...  # type: "BitString"
257
258     def __init__(
259             self,
260             value: Optional[Union["BitString", bytes, Tuple[str, ...]]]=...,
261             impl: Optional[bytes]=...,
262             expl: Optional[bytes]=...,
263             default: Optional[Union["BitString", bytes, Tuple[str, ...]]]=...,
264             optional: bool=...,
265     ) -> None: ...
266
267     @property
268     def ready(self) -> bool: ...
269
270     def copy(self) -> "BitString": ...
271
272     @property
273     def bit_len(self) -> int: ...
274
275     @property
276     def named(self) -> TSequence[str]: ...
277
278     def __call__(
279             self,
280             value: Optional[Union["BitString", bytes, Tuple[str, ...]]]=...,
281             impl: Optional[bytes]=...,
282             expl: Optional[bytes]=...,
283             default: Optional[Union["BitString", bytes, Tuple[str, ...]]]=...,
284             optional: Optional[bool]=...,
285     ) -> "BitString": ...
286
287     def __bytes__(self) -> bytes: ...
288
289     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
290
291
292 class OctetString(Obj):
293     tag_default = ...  # type: bytes
294     asn1_type_name = ...  # type: str
295     default = ...  # type: "OctetString"
296
297     def __init__(
298             self,
299             value: Optional[Union["OctetString", bytes]]=...,
300             bounds: Optional[Tuple[int, int]]=...,
301             impl: Optional[bytes]=...,
302             expl: Optional[bytes]=...,
303             default: Optional[Union["OctetString", bytes]]=...,
304             optional: bool=...,
305     ) -> None: ...
306
307     @property
308     def ready(self) -> bool: ...
309
310     def copy(self) -> "OctetString": ...
311
312     def __call__(
313             self,
314             value: Optional[Union["OctetString", bytes]]=...,
315             bounds: Optional[Tuple[int, int]]=...,
316             impl: Optional[bytes]=...,
317             expl: Optional[bytes]=...,
318             default: Optional[Union["OctetString", bytes]]=...,
319             optional: Optional[bool]=...,
320     ) -> "OctetString": ...
321
322     def __bytes__(self) -> bytes: ...
323
324     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
325
326
327 class Null(Obj):
328     tag_default = ...  # type: bytes
329     asn1_type_name = ...  # type: str
330     default = ...  # type: "Null"
331
332     def __init__(
333             self,
334             impl: Optional[bytes]=...,
335             expl: Optional[bytes]=...,
336             optional: bool=...,
337     ) -> None: ...
338
339     @property
340     def ready(self) -> bool: ...
341
342     def copy(self) -> "Null": ...
343
344     def __call__(
345             self,
346             impl: Optional[bytes]=...,
347             expl: Optional[bytes]=...,
348             optional: Optional[bool]=...,
349     ) -> "Null": ...
350
351     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
352
353
354 class ObjectIdentifier(Obj):
355     tag_default = ...  # type: bytes
356     asn1_type_name = ...  # type: str
357     default = ...  # type: "ObjectIdentifier"
358
359     def __init__(
360             self,
361             value: Optional[Union["ObjectIdentifier", str, Tuple[int, ...]]]=...,
362             impl: Optional[bytes]=...,
363             expl: Optional[bytes]=...,
364             default: Optional[Union["ObjectIdentifier", str, Tuple[int, ...]]]=...,
365             optional: bool=...,
366     ) -> None: ...
367
368     @property
369     def ready(self) -> bool: ...
370
371     def copy(self) -> "ObjectIdentifier": ...
372
373     def __call__(
374             self,
375             value: Optional[Union["ObjectIdentifier", str, Tuple[int, ...]]]=...,
376             impl: Optional[bytes]=...,
377             expl: Optional[bytes]=...,
378             default: Optional[Union["ObjectIdentifier", str, Tuple[int, ...]]]=...,
379             optional: Optional[bool]=...,
380     ) -> "ObjectIdentifier": ...
381
382     def __add__(
383             self,
384             their: Union["ObjectIdentifier", Tuple[int, ...]],
385     ) -> "ObjectIdentifier": ...
386
387     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
388
389
390 class Enumerated(Integer):
391     tag_default = ...  # type: bytes
392     asn1_type_name = ...  # type: str
393     default = ...  # type: "Enumerated"
394
395     def __init__(
396             self,
397             value: Optional[Union["Enumerated", str, int]]=...,
398             impl: Optional[bytes]=...,
399             expl: Optional[bytes]=...,
400             default: Optional[Union["Enumerated", str, int]]=...,
401             optional: bool=...,
402     ) -> None: ...
403
404     def copy(self) -> "Enumerated": ...
405
406     def __call__(  # type: ignore
407             self,
408             value: Optional[Union["Enumerated", str, int]]=...,
409             impl: Optional[bytes]=...,
410             expl: Optional[bytes]=...,
411             default: Optional[Union["Enumerated", str, int]]=...,
412             optional: Optional[bool]=...,
413     ) -> "Enumerated": ...
414
415
416 class CommonString(OctetString):
417     def pps(
418             self,
419             decode_path: Tuple[str, ...]=...,
420             no_unicode: bool=...,
421     ) -> TSequence[PP]: ...
422
423
424 class UTF8String(CommonString):
425     tag_default = ...  # type: bytes
426     encoding = ...  # type: str
427     asn1_type_name = ...  # type: str
428     default = ...  # type: "UTF8String"
429
430     def __init__(
431             self,
432             value: Optional[Union["UTF8String", str, bytes]]=...,
433             bounds: Optional[Tuple[int, int]]=...,
434             impl: Optional[bytes]=...,
435             expl: Optional[bytes]=...,
436             default: Optional[Union["UTF8String", str, bytes]]=...,
437             optional: bool=...,
438     ) -> None: ...
439
440     def __str__(self) -> str: ...
441
442
443 class NumericString(CommonString):
444     tag_default = ...  # type: bytes
445     encoding = ...  # type: str
446     asn1_type_name = ...  # type: str
447     default = ...  # type: "NumericString"
448
449     def __init__(
450             self,
451             value: Optional[Union["NumericString", str, bytes]]=...,
452             bounds: Optional[Tuple[int, int]]=...,
453             impl: Optional[bytes]=...,
454             expl: Optional[bytes]=...,
455             default: Optional[Union["NumericString", str, bytes]]=...,
456             optional: bool=...,
457     ) -> None: ...
458
459
460 class PrintableString(CommonString):
461     tag_default = ...  # type: bytes
462     encoding = ...  # type: str
463     asn1_type_name = ...  # type: str
464     default = ...  # type: "PrintableString"
465
466     def __init__(
467             self,
468             value: Optional[Union["PrintableString", str, bytes]]=...,
469             bounds: Optional[Tuple[int, int]]=...,
470             impl: Optional[bytes]=...,
471             expl: Optional[bytes]=...,
472             default: Optional[Union["PrintableString", str, bytes]]=...,
473             optional: bool=...,
474     ) -> None: ...
475
476
477 class TeletexString(CommonString):
478     tag_default = ...  # type: bytes
479     encoding = ...  # type: str
480     asn1_type_name = ...  # type: str
481     default = ...  # type: "TeletexString"
482
483     def __init__(
484             self,
485             value: Optional[Union["TeletexString", str, bytes]]=...,
486             bounds: Optional[Tuple[int, int]]=...,
487             impl: Optional[bytes]=...,
488             expl: Optional[bytes]=...,
489             default: Optional[Union["TeletexString", str, bytes]]=...,
490             optional: bool=...,
491     ) -> None: ...
492
493
494 class T61String(TeletexString):
495     asn1_type_name = ...  # type: str
496     default = ...  # type: "T61String"
497
498
499 class VideotexString(CommonString):
500     tag_default = ...  # type: bytes
501     encoding = ...  # type: str
502     asn1_type_name = ...  # type: str
503     default = ...  # type: "VideotexString"
504
505     def __init__(
506             self,
507             value: Optional[Union["VideotexString", str, bytes]]=...,
508             bounds: Optional[Tuple[int, int]]=...,
509             impl: Optional[bytes]=...,
510             expl: Optional[bytes]=...,
511             default: Optional[Union["VideotexString", str, bytes]]=...,
512             optional: bool=...,
513     ) -> None: ...
514
515
516 class IA5String(CommonString):
517     tag_default = ...  # type: bytes
518     encoding = ...  # type: str
519     asn1_type_name = ...  # type: str
520     default = ...  # type: "IA5String"
521
522     def __init__(
523             self,
524             value: Optional[Union["IA5String", str, bytes]]=...,
525             bounds: Optional[Tuple[int, int]]=...,
526             impl: Optional[bytes]=...,
527             expl: Optional[bytes]=...,
528             default: Optional[Union["IA5String", str, bytes]]=...,
529             optional: bool=...,
530     ) -> None: ...
531
532
533 class UTCTime(CommonString):
534     tag_default = ...  # type: bytes
535     encoding = ...  # type: str
536     asn1_type_name = ...  # type: str
537     default = ...  # type: "UTCTime"
538
539     def __init__(
540             self,
541             value: Optional[Union["UTCTime", datetime]]=...,
542             impl: Optional[bytes]=...,
543             expl: Optional[bytes]=...,
544             default: Optional[Union["UTCTime", datetime]]=...,
545             optional: bool=...,
546     ) -> None: ...
547
548     def todatetime(self) -> datetime: ...
549
550     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...  # type: ignore
551
552
553 class GeneralizedTime(UTCTime):
554     tag_default = ...  # type: bytes
555     asn1_type_name = ...  # type: str
556     default = ...  # type: "GeneralizedTime"
557
558     def todatetime(self) -> datetime: ...
559
560
561 class GraphicString(CommonString):
562     tag_default = ...  # type: bytes
563     encoding = ...  # type: str
564     asn1_type_name = ...  # type: str
565     default = ...  # type: "GraphicString"
566
567     def __init__(
568             self,
569             value: Optional[Union["GraphicString", str, bytes]]=...,
570             bounds: Optional[Tuple[int, int]]=...,
571             impl: Optional[bytes]=...,
572             expl: Optional[bytes]=...,
573             default: Optional[Union["GraphicString", str, bytes]]=...,
574             optional: bool=...,
575     ) -> None: ...
576
577
578 class VisibleString(CommonString):
579     tag_default = ...  # type: bytes
580     encoding = ...  # type: str
581     asn1_type_name = ...  # type: str
582     default = ...  # type: "VisibleString"
583
584     def __init__(
585             self,
586             value: Optional[Union["VisibleString", str, bytes]]=...,
587             bounds: Optional[Tuple[int, int]]=...,
588             impl: Optional[bytes]=...,
589             expl: Optional[bytes]=...,
590             default: Optional[Union["VisibleString", str, bytes]]=...,
591             optional: bool=...,
592     ) -> None: ...
593
594
595 class ISO646String(VisibleString):
596     asn1_type_name = ...  # type: str
597     default = ...  # type: "ISO646String"
598
599
600 class GeneralString(CommonString):
601     tag_default = ...  # type: bytes
602     encoding = ...  # type: str
603     asn1_type_name = ...  # type: str
604     default = ...  # type: "GeneralString"
605
606     def __init__(
607             self,
608             value: Optional[Union["GeneralString", str, bytes]]=...,
609             bounds: Optional[Tuple[int, int]]=...,
610             impl: Optional[bytes]=...,
611             expl: Optional[bytes]=...,
612             default: Optional[Union["GeneralString", str, bytes]]=...,
613             optional: bool=...,
614     ) -> None: ...
615
616
617 class UniversalString(CommonString):
618     tag_default = ...  # type: bytes
619     encoding = ...  # type: str
620     asn1_type_name = ...  # type: str
621     default = ...  # type: "UniversalString"
622
623     def __init__(
624             self,
625             value: Optional[Union["UniversalString", str, bytes]]=...,
626             bounds: Optional[Tuple[int, int]]=...,
627             impl: Optional[bytes]=...,
628             expl: Optional[bytes]=...,
629             default: Optional[Union["UniversalString", str, bytes]]=...,
630             optional: bool=...,
631     ) -> None: ...
632
633
634 class BMPString(CommonString):
635     tag_default = ...  # type: bytes
636     encoding = ...  # type: str
637     asn1_type_name = ...  # type: str
638     default = ...  # type: "BMPString"
639
640     def __init__(
641             self,
642             value: Optional[Union["BMPString", str, bytes]]=...,
643             bounds: Optional[Tuple[int, int]]=...,
644             impl: Optional[bytes]=...,
645             expl: Optional[bytes]=...,
646             default: Optional[Union["BMPString", str, bytes]]=...,
647             optional: bool=...,
648     ) -> None: ...
649
650
651 class Choice(Obj):
652     tag_default = ...  # type: bytes
653     asn1_type_name = ...  # type: str
654     specs = ...  # type: Dict[str, Obj]
655     default = ...  # type: "Choice"
656
657     def __init__(
658             self,
659             value: Optional[Union["Choice", Tuple[str, Obj]]]=...,
660             impl: Optional[bytes]=...,
661             expl: Optional[bytes]=...,
662             default: Optional[Union["Choice", Tuple[str, Obj]]]=...,
663             optional: bool=...,
664     ) -> None: ...
665
666     @property
667     def ready(self) -> bool: ...
668
669     def copy(self) -> "Choice": ...
670
671     def __call__(
672             self,
673             value: Optional[Union["Choice", Tuple[str, Obj]]]=...,
674             expl: Optional[bytes]=...,
675             default: Optional[Union["Choice", Tuple[str, Obj]]]=...,
676             optional: Optional[bool]=...,
677     ) -> "Choice": ...
678
679     def __getitem__(self, key: str) -> Optional[Obj]: ...
680
681     def __setitem__(self, key: str, value: Obj) -> None: ...
682
683     @property
684     def choice(self) -> str: ...
685
686     @property
687     def value(self) -> Obj: ...
688
689     @property
690     def tlen(self) -> int: ...
691
692     @property
693     def decoded(self) -> bool: ...
694
695     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
696
697
698 class PrimitiveTypes(Choice):
699     schema = ...  # type: Dict[str, Obj]
700
701
702 class Any(Obj):
703     tag_default = ...  # type: bytes
704     asn1_type_name = ...  # type: str
705     default = ...  # type: "Any"
706
707     def __init__(
708             self,
709             value: Optional[Union[Obj, bytes]]=...,
710             expl: Optional[bytes]=...,
711             optional: bool=...,
712     ) -> None: ...
713
714     @property
715     def ready(self) -> bool: ...
716
717     def copy(self) -> "Any": ...
718
719     def __call__(
720             self,
721             value: Optional[Union[Obj, bytes]]=...,
722             expl: Optional[bytes]=...,
723             optional: Optional[bool]=...,
724     ) -> "Any": ...
725
726     def __bytes__(self) -> bytes: ...
727
728     @property
729     def tlen(self) -> int: ...
730
731     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
732
733
734 class Sequence(Obj):
735     tag_default = ...  # type: bytes
736     asn1_type_name = ...  # type: str
737     specs = ...  # type: Dict[str, Obj]
738     default = ...  # type: "Sequence"
739
740     def __init__(
741             self,
742             value: Optional["Sequence"]=...,
743             impl: Optional[bytes]=...,
744             expl: Optional[bytes]=...,
745             default: Optional["Sequence"]=...,
746             optional: bool=...,
747     ) -> None: ...
748
749     @property
750     def ready(self) -> bool: ...
751
752     def copy(self) -> "Sequence": ...
753
754     def __call__(
755             self,
756             value: Optional["Sequence"]=...,
757             impl: Optional[bytes]=...,
758             expl: Optional[bytes]=...,
759             default: Optional["Sequence"]=...,
760             optional: Optional[bool]=...,
761     ) -> "Sequence": ...
762
763     def __getitem__(self, key: str) -> Optional[Obj]: ...
764
765     def __setitem__(self, key: str, value: Obj) -> None: ...
766
767     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
768
769
770 class Set(Sequence):
771     tag_default = ...  # type: bytes
772     asn1_type_name = ...  # type: str
773     default = ...  # type: "Set"
774
775
776 class SequenceOf(Obj):
777     tag_default = ...  # type: bytes
778     asn1_type_name = ...  # type: str
779     spec = ...  # type: Obj
780     default = ...  # type: "SequenceOf"
781
782     def __init__(
783             self,
784             value: Optional[Union["SequenceOf", TSequence[Obj]]]=...,
785             bounds: Optional[Tuple[int, int]]=...,
786             impl: Optional[bytes]=...,
787             expl: Optional[bytes]=...,
788             default: Optional[Union["SequenceOf", TSequence[Obj]]]=...,
789             optional: Optional[bool]=...,
790     ) -> None: ...
791
792     @property
793     def ready(self) -> bool: ...
794
795     def copy(self) -> "SequenceOf": ...
796
797     def __call__(
798             self,
799             value: Optional[Union["SequenceOf", TSequence[Obj]]]=...,
800             bounds: Optional[Tuple[int, int]]=...,
801             impl: Optional[bytes]=...,
802             expl: Optional[bytes]=...,
803             default: Optional[Union["SequenceOf", TSequence[Obj]]]=...,
804             optional: Optional[bool]=...,
805     ) -> "SequenceOf": ...
806
807     def __getitem__(self, key: int) -> Obj: ...
808
809     def __iter__(self) -> TSequence[Obj]: ...
810
811     def append(self, value: Obj) -> None: ...
812
813     def pps(self, decode_path: Tuple[str, ...]=...) -> TSequence[PP]: ...
814
815
816 class SetOf(SequenceOf):
817     tag_default = ...  # type: bytes
818     asn1_type_name = ...  # type: str
819     default = ...  # type: "SetOf"
820
821
822 def obj_by_path(pypath: str) -> TAny: ...