Generated-output differences

quicktype output changed between the PR base and tested PR merge revisions.
← Back to the pull request
1test cases
1files differ
0modified
1new
0deleted
5,027changed lines
+5,027 −0insertions / deletions
Base d3014aaec4f7ed11fb83168f39211b755deeeb1d · PR merge 9f5a327756e6fe9a9804e8fe5eb8aca02073eb7a · Head a07cdd2297df32a6431a177b3d44fe859129820f · raw patch
Test case

test/inputs/schema/keyword-unions.schema

1 generated file · +5,027 −0
Aschema-pythondefault / quicktype.py+5,027 −0
@@ -0,0 +1,5027 @@
1+from dataclasses import dataclass
2+from typing import Any, TypeVar, Type, cast
3+
4+
5+T = TypeVar("T")
6+
7+
8+def from_float(x: Any) -> float:
9+ assert isinstance(x, (float, int)) and not isinstance(x, bool)
10+ return float(x)
11+
12+
13+def from_none(x: Any) -> Any:
14+ assert x is None
15+ return x
16+
17+
18+def from_union(fs, x):
19+ for f in fs:
20+ try:
21+ return f(x)
22+ except:
23+ pass
24+ assert False
25+
26+
27+def to_float(x: Any) -> float:
28+ assert isinstance(x, (int, float))
29+ return x
30+
31+
32+def to_class(c: Type[T], x: Any) -> dict:
33+ assert isinstance(x, c)
34+ return cast(Any, x).to_dict()
35+
36+
37+@dataclass
38+class Abstract:
39+ pass
40+
41+ @staticmethod
42+ def from_dict(obj: Any) -> 'Abstract':
43+ assert isinstance(obj, dict)
44+ return Abstract()
45+
46+ def to_dict(self) -> dict:
47+ result: dict = {}
48+ return result
49+
50+
51+@dataclass
52+class Alignas:
53+ pass
54+
55+ @staticmethod
56+ def from_dict(obj: Any) -> 'Alignas':
57+ assert isinstance(obj, dict)
58+ return Alignas()
59+
60+ def to_dict(self) -> dict:
61+ result: dict = {}
62+ return result
63+
64+
65+@dataclass
66+class Alignof:
67+ pass
68+
69+ @staticmethod
70+ def from_dict(obj: Any) -> 'Alignof':
71+ assert isinstance(obj, dict)
72+ return Alignof()
73+
74+ def to_dict(self) -> dict:
75+ result: dict = {}
76+ return result
77+
78+
79+@dataclass
80+class AndEq:
81+ pass
82+
83+ @staticmethod
84+ def from_dict(obj: Any) -> 'AndEq':
85+ assert isinstance(obj, dict)
86+ return AndEq()
87+
88+ def to_dict(self) -> dict:
89+ result: dict = {}
90+ return result
91+
92+
93+@dataclass
94+class AnyClass:
95+ pass
96+
97+ @staticmethod
98+ def from_dict(obj: Any) -> 'AnyClass':
99+ assert isinstance(obj, dict)
100+ return AnyClass()
101+
102+ def to_dict(self) -> dict:
103+ result: dict = {}
104+ return result
105+
106+
107+@dataclass
108+class Array:
109+ pass
110+
111+ @staticmethod
112+ def from_dict(obj: Any) -> 'Array':
113+ assert isinstance(obj, dict)
114+ return Array()
115+
116+ def to_dict(self) -> dict:
117+ result: dict = {}
118+ return result
119+
120+
121+@dataclass
122+class ASM:
123+ pass
124+
125+ @staticmethod
126+ def from_dict(obj: Any) -> 'ASM':
127+ assert isinstance(obj, dict)
128+ return ASM()
129+
130+ def to_dict(self) -> dict:
131+ result: dict = {}
132+ return result
133+
134+
135+@dataclass
136+class Associatedtype:
137+ pass
138+
139+ @staticmethod
140+ def from_dict(obj: Any) -> 'Associatedtype':
141+ assert isinstance(obj, dict)
142+ return Associatedtype()
143+
144+ def to_dict(self) -> dict:
145+ result: dict = {}
146+ return result
147+
148+
149+@dataclass
150+class Associativity:
151+ pass
152+
153+ @staticmethod
154+ def from_dict(obj: Any) -> 'Associativity':
155+ assert isinstance(obj, dict)
156+ return Associativity()
157+
158+ def to_dict(self) -> dict:
159+ result: dict = {}
160+ return result
161+
162+
163+@dataclass
164+class Atomic:
165+ pass
166+
167+ @staticmethod
168+ def from_dict(obj: Any) -> 'Atomic':
169+ assert isinstance(obj, dict)
170+ return Atomic()
171+
172+ def to_dict(self) -> dict:
173+ result: dict = {}
174+ return result
175+
176+
177+@dataclass
178+class AtomicCancel:
179+ pass
180+
181+ @staticmethod
182+ def from_dict(obj: Any) -> 'AtomicCancel':
183+ assert isinstance(obj, dict)
184+ return AtomicCancel()
185+
186+ def to_dict(self) -> dict:
187+ result: dict = {}
188+ return result
189+
190+
191+@dataclass
192+class AtomicCommit:
193+ pass
194+
195+ @staticmethod
196+ def from_dict(obj: Any) -> 'AtomicCommit':
197+ assert isinstance(obj, dict)
198+ return AtomicCommit()
199+
200+ def to_dict(self) -> dict:
201+ result: dict = {}
202+ return result
203+
204+
205+@dataclass
206+class AtomicNoexcept:
207+ pass
208+
209+ @staticmethod
210+ def from_dict(obj: Any) -> 'AtomicNoexcept':
211+ assert isinstance(obj, dict)
212+ return AtomicNoexcept()
213+
214+ def to_dict(self) -> dict:
215+ result: dict = {}
216+ return result
217+
218+
219+@dataclass
220+class Auto:
221+ pass
222+
223+ @staticmethod
224+ def from_dict(obj: Any) -> 'Auto':
225+ assert isinstance(obj, dict)
226+ return Auto()
227+
228+ def to_dict(self) -> dict:
229+ result: dict = {}
230+ return result
231+
232+
233+@dataclass
234+class Base:
235+ pass
236+
237+ @staticmethod
238+ def from_dict(obj: Any) -> 'Base':
239+ assert isinstance(obj, dict)
240+ return Base()
241+
242+ def to_dict(self) -> dict:
243+ result: dict = {}
244+ return result
245+
246+
247+@dataclass
248+class Bitand:
249+ pass
250+
251+ @staticmethod
252+ def from_dict(obj: Any) -> 'Bitand':
253+ assert isinstance(obj, dict)
254+ return Bitand()
255+
256+ def to_dict(self) -> dict:
257+ result: dict = {}
258+ return result
259+
260+
261+@dataclass
262+class Bitor:
263+ pass
264+
265+ @staticmethod
266+ def from_dict(obj: Any) -> 'Bitor':
267+ assert isinstance(obj, dict)
268+ return Bitor()
269+
270+ def to_dict(self) -> dict:
271+ result: dict = {}
272+ return result
273+
274+
275+@dataclass
276+class Boolean:
277+ pass
278+
279+ @staticmethod
280+ def from_dict(obj: Any) -> 'Boolean':
281+ assert isinstance(obj, dict)
282+ return Boolean()
283+
284+ def to_dict(self) -> dict:
285+ result: dict = {}
286+ return result
287+
288+
289+@dataclass
290+class Bycopy:
291+ pass
292+
293+ @staticmethod
294+ def from_dict(obj: Any) -> 'Bycopy':
295+ assert isinstance(obj, dict)
296+ return Bycopy()
297+
298+ def to_dict(self) -> dict:
299+ result: dict = {}
300+ return result
301+
302+
303+@dataclass
304+class Byref:
305+ pass
306+
307+ @staticmethod
308+ def from_dict(obj: Any) -> 'Byref':
309+ assert isinstance(obj, dict)
310+ return Byref()
311+
312+ def to_dict(self) -> dict:
313+ result: dict = {}
314+ return result
315+
316+
317+@dataclass
318+class Byte:
319+ pass
320+
321+ @staticmethod
322+ def from_dict(obj: Any) -> 'Byte':
323+ assert isinstance(obj, dict)
324+ return Byte()
325+
326+ def to_dict(self) -> dict:
327+ result: dict = {}
328+ return result
329+
330+
331+@dataclass
332+class Case:
333+ pass
334+
335+ @staticmethod
336+ def from_dict(obj: Any) -> 'Case':
337+ assert isinstance(obj, dict)
338+ return Case()
339+
340+ def to_dict(self) -> dict:
341+ result: dict = {}
342+ return result
343+
344+
345+@dataclass
346+class Catch:
347+ pass
348+
349+ @staticmethod
350+ def from_dict(obj: Any) -> 'Catch':
351+ assert isinstance(obj, dict)
352+ return Catch()
353+
354+ def to_dict(self) -> dict:
355+ result: dict = {}
356+ return result
357+
358+
359+@dataclass
360+class Chan:
361+ pass
362+
363+ @staticmethod
364+ def from_dict(obj: Any) -> 'Chan':
365+ assert isinstance(obj, dict)
366+ return Chan()
367+
368+ def to_dict(self) -> dict:
369+ result: dict = {}
370+ return result
371+
372+
373+@dataclass
374+class Char:
375+ pass
376+
377+ @staticmethod
378+ def from_dict(obj: Any) -> 'Char':
379+ assert isinstance(obj, dict)
380+ return Char()
381+
382+ def to_dict(self) -> dict:
383+ result: dict = {}
384+ return result
385+
386+
387+@dataclass
388+class Char16T:
389+ pass
390+
391+ @staticmethod
392+ def from_dict(obj: Any) -> 'Char16T':
393+ assert isinstance(obj, dict)
394+ return Char16T()
395+
396+ def to_dict(self) -> dict:
397+ result: dict = {}
398+ return result
399+
400+
401+@dataclass
402+class Char32T:
403+ pass
404+
405+ @staticmethod
406+ def from_dict(obj: Any) -> 'Char32T':
407+ assert isinstance(obj, dict)
408+ return Char32T()
409+
410+ def to_dict(self) -> dict:
411+ result: dict = {}
412+ return result
413+
414+
415+@dataclass
416+class Checked:
417+ pass
418+
419+ @staticmethod
420+ def from_dict(obj: Any) -> 'Checked':
421+ assert isinstance(obj, dict)
422+ return Checked()
423+
424+ def to_dict(self) -> dict:
425+ result: dict = {}
426+ return result
427+
428+
429+@dataclass
430+class CoAwait:
431+ pass
432+
433+ @staticmethod
434+ def from_dict(obj: Any) -> 'CoAwait':
435+ assert isinstance(obj, dict)
436+ return CoAwait()
437+
438+ def to_dict(self) -> dict:
439+ result: dict = {}
440+ return result
441+
442+
443+@dataclass
444+class CoReturn:
445+ pass
446+
447+ @staticmethod
448+ def from_dict(obj: Any) -> 'CoReturn':
449+ assert isinstance(obj, dict)
450+ return CoReturn()
451+
452+ def to_dict(self) -> dict:
453+ result: dict = {}
454+ return result
455+
456+
457+@dataclass
458+class CoYield:
459+ pass
460+
461+ @staticmethod
462+ def from_dict(obj: Any) -> 'CoYield':
463+ assert isinstance(obj, dict)
464+ return CoYield()
465+
466+ def to_dict(self) -> dict:
467+ result: dict = {}
468+ return result
469+
470+
471+@dataclass
472+class Compl:
473+ pass
474+
475+ @staticmethod
476+ def from_dict(obj: Any) -> 'Compl':
477+ assert isinstance(obj, dict)
478+ return Compl()
479+
480+ def to_dict(self) -> dict:
481+ result: dict = {}
482+ return result
483+
484+
485+@dataclass
486+class Complex:
487+ pass
488+
489+ @staticmethod
490+ def from_dict(obj: Any) -> 'Complex':
491+ assert isinstance(obj, dict)
492+ return Complex()
493+
494+ def to_dict(self) -> dict:
495+ result: dict = {}
496+ return result
497+
498+
499+@dataclass
500+class Concept:
501+ pass
502+
503+ @staticmethod
504+ def from_dict(obj: Any) -> 'Concept':
505+ assert isinstance(obj, dict)
506+ return Concept()
507+
508+ def to_dict(self) -> dict:
509+ result: dict = {}
510+ return result
511+
512+
513+@dataclass
514+class Console:
515+ pass
516+
517+ @staticmethod
518+ def from_dict(obj: Any) -> 'Console':
519+ assert isinstance(obj, dict)
520+ return Console()
521+
522+ def to_dict(self) -> dict:
523+ result: dict = {}
524+ return result
525+
526+
527+@dataclass
528+class Const:
529+ pass
530+
531+ @staticmethod
532+ def from_dict(obj: Any) -> 'Const':
533+ assert isinstance(obj, dict)
534+ return Const()
535+
536+ def to_dict(self) -> dict:
537+ result: dict = {}
538+ return result
539+
540+
541+@dataclass
542+class ConstCast:
543+ pass
544+
545+ @staticmethod
546+ def from_dict(obj: Any) -> 'ConstCast':
547+ assert isinstance(obj, dict)
548+ return ConstCast()
549+
550+ def to_dict(self) -> dict:
551+ result: dict = {}
552+ return result
553+
554+
555+@dataclass
556+class Constexpr:
557+ pass
558+
559+ @staticmethod
560+ def from_dict(obj: Any) -> 'Constexpr':
561+ assert isinstance(obj, dict)
562+ return Constexpr()
563+
564+ def to_dict(self) -> dict:
565+ result: dict = {}
566+ return result
567+
568+
569+@dataclass
570+class Constructor:
571+ pass
572+
573+ @staticmethod
574+ def from_dict(obj: Any) -> 'Constructor':
575+ assert isinstance(obj, dict)
576+ return Constructor()
577+
578+ def to_dict(self) -> dict:
579+ result: dict = {}
580+ return result
581+
582+
583+@dataclass
584+class Convenience:
585+ pass
586+
587+ @staticmethod
588+ def from_dict(obj: Any) -> 'Convenience':
589+ assert isinstance(obj, dict)
590+ return Convenience()
591+
592+ def to_dict(self) -> dict:
593+ result: dict = {}
594+ return result
595+
596+
597+@dataclass
598+class Convert:
599+ pass
600+
601+ @staticmethod
602+ def from_dict(obj: Any) -> 'Convert':
603+ assert isinstance(obj, dict)
604+ return Convert()
605+
606+ def to_dict(self) -> dict:
607+ result: dict = {}
608+ return result
609+
610+
611+@dataclass
612+class Converter:
613+ pass
614+
615+ @staticmethod
616+ def from_dict(obj: Any) -> 'Converter':
617+ assert isinstance(obj, dict)
618+ return Converter()
619+
620+ def to_dict(self) -> dict:
621+ result: dict = {}
622+ return result
623+
624+
625+@dataclass
626+class Date:
627+ pass
628+
629+ @staticmethod
630+ def from_dict(obj: Any) -> 'Date':
631+ assert isinstance(obj, dict)
632+ return Date()
633+
634+ def to_dict(self) -> dict:
635+ result: dict = {}
636+ return result
637+
638+
639+@dataclass
640+class DateParseHandling:
641+ pass
642+
643+ @staticmethod
644+ def from_dict(obj: Any) -> 'DateParseHandling':
645+ assert isinstance(obj, dict)
646+ return DateParseHandling()
647+
648+ def to_dict(self) -> dict:
649+ result: dict = {}
650+ return result
651+
652+
653+@dataclass
654+class Debugger:
655+ pass
656+
657+ @staticmethod
658+ def from_dict(obj: Any) -> 'Debugger':
659+ assert isinstance(obj, dict)
660+ return Debugger()
661+
662+ def to_dict(self) -> dict:
663+ result: dict = {}
664+ return result
665+
666+
667+@dataclass
668+class Decimal:
669+ pass
670+
671+ @staticmethod
672+ def from_dict(obj: Any) -> 'Decimal':
673+ assert isinstance(obj, dict)
674+ return Decimal()
675+
676+ def to_dict(self) -> dict:
677+ result: dict = {}
678+ return result
679+
680+
681+@dataclass
682+class Declare:
683+ pass
684+
685+ @staticmethod
686+ def from_dict(obj: Any) -> 'Declare':
687+ assert isinstance(obj, dict)
688+ return Declare()
689+
690+ def to_dict(self) -> dict:
691+ result: dict = {}
692+ return result
693+
694+
695+@dataclass
696+class Decltype:
697+ pass
698+
699+ @staticmethod
700+ def from_dict(obj: Any) -> 'Decltype':
701+ assert isinstance(obj, dict)
702+ return Decltype()
703+
704+ def to_dict(self) -> dict:
705+ result: dict = {}
706+ return result
707+
708+
709+@dataclass
710+class DecodeString:
711+ pass
712+
713+ @staticmethod
714+ def from_dict(obj: Any) -> 'DecodeString':
715+ assert isinstance(obj, dict)
716+ return DecodeString()
717+
718+ def to_dict(self) -> dict:
719+ result: dict = {}
720+ return result
721+
722+
723+@dataclass
724+class Default:
725+ pass
726+
727+ @staticmethod
728+ def from_dict(obj: Any) -> 'Default':
729+ assert isinstance(obj, dict)
730+ return Default()
731+
732+ def to_dict(self) -> dict:
733+ result: dict = {}
734+ return result
735+
736+
737+@dataclass
738+class Defer:
739+ pass
740+
741+ @staticmethod
742+ def from_dict(obj: Any) -> 'Defer':
743+ assert isinstance(obj, dict)
744+ return Defer()
745+
746+ def to_dict(self) -> dict:
747+ result: dict = {}
748+ return result
749+
750+
751+@dataclass
752+class Deinit:
753+ pass
754+
755+ @staticmethod
756+ def from_dict(obj: Any) -> 'Deinit':
757+ assert isinstance(obj, dict)
758+ return Deinit()
759+
760+ def to_dict(self) -> dict:
761+ result: dict = {}
762+ return result
763+
764+
765+@dataclass
766+class Delegate:
767+ pass
768+
769+ @staticmethod
770+ def from_dict(obj: Any) -> 'Delegate':
771+ assert isinstance(obj, dict)
772+ return Delegate()
773+
774+ def to_dict(self) -> dict:
775+ result: dict = {}
776+ return result
777+
778+
779+@dataclass
780+class Delete:
781+ pass
782+
783+ @staticmethod
784+ def from_dict(obj: Any) -> 'Delete':
785+ assert isinstance(obj, dict)
786+ return Delete()
787+
788+ def to_dict(self) -> dict:
789+ result: dict = {}
790+ return result
791+
792+
793+@dataclass
794+class Dictionary:
795+ pass
796+
797+ @staticmethod
798+ def from_dict(obj: Any) -> 'Dictionary':
799+ assert isinstance(obj, dict)
800+ return Dictionary()
801+
802+ def to_dict(self) -> dict:
803+ result: dict = {}
804+ return result
805+
806+
807+@dataclass
808+class DidSet:
809+ pass
810+
811+ @staticmethod
812+ def from_dict(obj: Any) -> 'DidSet':
813+ assert isinstance(obj, dict)
814+ return DidSet()
815+
816+ def to_dict(self) -> dict:
817+ result: dict = {}
818+ return result
819+
820+
821+@dataclass
822+class Do:
823+ pass
824+
825+ @staticmethod
826+ def from_dict(obj: Any) -> 'Do':
827+ assert isinstance(obj, dict)
828+ return Do()
829+
830+ def to_dict(self) -> dict:
831+ result: dict = {}
832+ return result
833+
834+
835+@dataclass
836+class Double:
837+ pass
838+
839+ @staticmethod
840+ def from_dict(obj: Any) -> 'Double':
841+ assert isinstance(obj, dict)
842+ return Double()
843+
844+ def to_dict(self) -> dict:
845+ result: dict = {}
846+ return result
847+
848+
849+@dataclass
850+class Dynamic:
851+ pass
852+
853+ @staticmethod
854+ def from_dict(obj: Any) -> 'Dynamic':
855+ assert isinstance(obj, dict)
856+ return Dynamic()
857+
858+ def to_dict(self) -> dict:
859+ result: dict = {}
860+ return result
861+
862+
863+@dataclass
864+class DynamicCast:
865+ pass
866+
867+ @staticmethod
868+ def from_dict(obj: Any) -> 'DynamicCast':
869+ assert isinstance(obj, dict)
870+ return DynamicCast()
871+
872+ def to_dict(self) -> dict:
873+ result: dict = {}
874+ return result
875+
876+
877+@dataclass
878+class Empty:
879+ pass
880+
881+ @staticmethod
882+ def from_dict(obj: Any) -> 'Empty':
883+ assert isinstance(obj, dict)
884+ return Empty()
885+
886+ def to_dict(self) -> dict:
887+ result: dict = {}
888+ return result
889+
890+
891+@dataclass
892+class EncodeQuickType:
893+ pass
894+
895+ @staticmethod
896+ def from_dict(obj: Any) -> 'EncodeQuickType':
897+ assert isinstance(obj, dict)
898+ return EncodeQuickType()
899+
900+ def to_dict(self) -> dict:
901+ result: dict = {}
902+ return result
903+
904+
905+@dataclass
906+class EnumClass:
907+ pass
908+
909+ @staticmethod
910+ def from_dict(obj: Any) -> 'EnumClass':
911+ assert isinstance(obj, dict)
912+ return EnumClass()
913+
914+ def to_dict(self) -> dict:
915+ result: dict = {}
916+ return result
917+
918+
919+@dataclass
920+class Event:
921+ pass
922+
923+ @staticmethod
924+ def from_dict(obj: Any) -> 'Event':
925+ assert isinstance(obj, dict)
926+ return Event()
927+
928+ def to_dict(self) -> dict:
929+ result: dict = {}
930+ return result
931+
932+
933+@dataclass
934+class Exception:
935+ pass
936+
937+ @staticmethod
938+ def from_dict(obj: Any) -> 'Exception':
939+ assert isinstance(obj, dict)
940+ return Exception()
941+
942+ def to_dict(self) -> dict:
943+ result: dict = {}
944+ return result
945+
946+
947+@dataclass
948+class Explicit:
949+ pass
950+
951+ @staticmethod
952+ def from_dict(obj: Any) -> 'Explicit':
953+ assert isinstance(obj, dict)
954+ return Explicit()
955+
956+ def to_dict(self) -> dict:
957+ result: dict = {}
958+ return result
959+
960+
961+@dataclass
962+class Export:
963+ pass
964+
965+ @staticmethod
966+ def from_dict(obj: Any) -> 'Export':
967+ assert isinstance(obj, dict)
968+ return Export()
969+
970+ def to_dict(self) -> dict:
971+ result: dict = {}
972+ return result
973+
974+
975+@dataclass
976+class Exposing:
977+ pass
978+
979+ @staticmethod
980+ def from_dict(obj: Any) -> 'Exposing':
981+ assert isinstance(obj, dict)
982+ return Exposing()
983+
984+ def to_dict(self) -> dict:
985+ result: dict = {}
986+ return result
987+
988+
989+@dataclass
990+class Extends:
991+ pass
992+
993+ @staticmethod
994+ def from_dict(obj: Any) -> 'Extends':
995+ assert isinstance(obj, dict)
996+ return Extends()
997+
998+ def to_dict(self) -> dict:
999+ result: dict = {}
1000+ return result
1001+
1002+
1003+@dataclass
1004+class Extension:
1005+ pass
1006+
1007+ @staticmethod
1008+ def from_dict(obj: Any) -> 'Extension':
1009+ assert isinstance(obj, dict)
1010+ return Extension()
1011+
1012+ def to_dict(self) -> dict:
1013+ result: dict = {}
1014+ return result
1015+
1016+
1017+@dataclass
1018+class Extern:
1019+ pass
1020+
1021+ @staticmethod
1022+ def from_dict(obj: Any) -> 'Extern':
1023+ assert isinstance(obj, dict)
1024+ return Extern()
1025+
1026+ def to_dict(self) -> dict:
1027+ result: dict = {}
1028+ return result
1029+
1030+
1031+@dataclass
1032+class Fallthrough:
1033+ pass
1034+
1035+ @staticmethod
1036+ def from_dict(obj: Any) -> 'Fallthrough':
1037+ assert isinstance(obj, dict)
1038+ return Fallthrough()
1039+
1040+ def to_dict(self) -> dict:
1041+ result: dict = {}
1042+ return result
1043+
1044+
1045+@dataclass
1046+class FalseClass:
1047+ pass
1048+
1049+ @staticmethod
1050+ def from_dict(obj: Any) -> 'FalseClass':
1051+ assert isinstance(obj, dict)
1052+ return FalseClass()
1053+
1054+ def to_dict(self) -> dict:
1055+ result: dict = {}
1056+ return result
1057+
1058+
1059+@dataclass
1060+class Fileprivate:
1061+ pass
1062+
1063+ @staticmethod
1064+ def from_dict(obj: Any) -> 'Fileprivate':
1065+ assert isinstance(obj, dict)
1066+ return Fileprivate()
1067+
1068+ def to_dict(self) -> dict:
1069+ result: dict = {}
1070+ return result
1071+
1072+
1073+@dataclass
1074+class Final:
1075+ pass
1076+
1077+ @staticmethod
1078+ def from_dict(obj: Any) -> 'Final':
1079+ assert isinstance(obj, dict)
1080+ return Final()
1081+
1082+ def to_dict(self) -> dict:
1083+ result: dict = {}
1084+ return result
1085+
1086+
1087+@dataclass
1088+class Fixed:
1089+ pass
1090+
1091+ @staticmethod
1092+ def from_dict(obj: Any) -> 'Fixed':
1093+ assert isinstance(obj, dict)
1094+ return Fixed()
1095+
1096+ def to_dict(self) -> dict:
1097+ result: dict = {}
1098+ return result
1099+
1100+
1101+@dataclass
1102+class UnionBoolBool:
1103+ pass
1104+
1105+ @staticmethod
1106+ def from_dict(obj: Any) -> 'UnionBoolBool':
1107+ assert isinstance(obj, dict)
1108+ return UnionBoolBool()
1109+
1110+ def to_dict(self) -> dict:
1111+ result: dict = {}
1112+ return result
1113+
1114+
1115+@dataclass
1116+class Foreach:
1117+ pass
1118+
1119+ @staticmethod
1120+ def from_dict(obj: Any) -> 'Foreach':
1121+ assert isinstance(obj, dict)
1122+ return Foreach()
1123+
1124+ def to_dict(self) -> dict:
1125+ result: dict = {}
1126+ return result
1127+
1128+
1129+@dataclass
1130+class Friend:
1131+ pass
1132+
1133+ @staticmethod
1134+ def from_dict(obj: Any) -> 'Friend':
1135+ assert isinstance(obj, dict)
1136+ return Friend()
1137+
1138+ def to_dict(self) -> dict:
1139+ result: dict = {}
1140+ return result
1141+
1142+
1143+@dataclass
1144+class FromJSON:
1145+ pass
1146+
1147+ @staticmethod
1148+ def from_dict(obj: Any) -> 'FromJSON':
1149+ assert isinstance(obj, dict)
1150+ return FromJSON()
1151+
1152+ def to_dict(self) -> dict:
1153+ result: dict = {}
1154+ return result
1155+
1156+
1157+@dataclass
1158+class Func:
1159+ pass
1160+
1161+ @staticmethod
1162+ def from_dict(obj: Any) -> 'Func':
1163+ assert isinstance(obj, dict)
1164+ return Func()
1165+
1166+ def to_dict(self) -> dict:
1167+ result: dict = {}
1168+ return result
1169+
1170+
1171+@dataclass
1172+class Function:
1173+ pass
1174+
1175+ @staticmethod
1176+ def from_dict(obj: Any) -> 'Function':
1177+ assert isinstance(obj, dict)
1178+ return Function()
1179+
1180+ def to_dict(self) -> dict:
1181+ result: dict = {}
1182+ return result
1183+
1184+
1185+@dataclass
1186+class Get:
1187+ pass
1188+
1189+ @staticmethod
1190+ def from_dict(obj: Any) -> 'Get':
1191+ assert isinstance(obj, dict)
1192+ return Get()
1193+
1194+ def to_dict(self) -> dict:
1195+ result: dict = {}
1196+ return result
1197+
1198+
1199+@dataclass
1200+class Go:
1201+ pass
1202+
1203+ @staticmethod
1204+ def from_dict(obj: Any) -> 'Go':
1205+ assert isinstance(obj, dict)
1206+ return Go()
1207+
1208+ def to_dict(self) -> dict:
1209+ result: dict = {}
1210+ return result
1211+
1212+
1213+@dataclass
1214+class Goto:
1215+ pass
1216+
1217+ @staticmethod
1218+ def from_dict(obj: Any) -> 'Goto':
1219+ assert isinstance(obj, dict)
1220+ return Goto()
1221+
1222+ def to_dict(self) -> dict:
1223+ result: dict = {}
1224+ return result
1225+
1226+
1227+@dataclass
1228+class Guard:
1229+ pass
1230+
1231+ @staticmethod
1232+ def from_dict(obj: Any) -> 'Guard':
1233+ assert isinstance(obj, dict)
1234+ return Guard()
1235+
1236+ def to_dict(self) -> dict:
1237+ result: dict = {}
1238+ return result
1239+
1240+
1241+@dataclass
1242+class HasOwnProperty:
1243+ pass
1244+
1245+ @staticmethod
1246+ def from_dict(obj: Any) -> 'HasOwnProperty':
1247+ assert isinstance(obj, dict)
1248+ return HasOwnProperty()
1249+
1250+ def to_dict(self) -> dict:
1251+ result: dict = {}
1252+ return result
1253+
1254+
1255+@dataclass
1256+class ID:
1257+ pass
1258+
1259+ @staticmethod
1260+ def from_dict(obj: Any) -> 'ID':
1261+ assert isinstance(obj, dict)
1262+ return ID()
1263+
1264+ def to_dict(self) -> dict:
1265+ result: dict = {}
1266+ return result
1267+
1268+
1269+@dataclass
1270+class Imaginery:
1271+ pass
1272+
1273+ @staticmethod
1274+ def from_dict(obj: Any) -> 'Imaginery':
1275+ assert isinstance(obj, dict)
1276+ return Imaginery()
1277+
1278+ def to_dict(self) -> dict:
1279+ result: dict = {}
1280+ return result
1281+
1282+
1283+@dataclass
1284+class Imp:
1285+ pass
1286+
1287+ @staticmethod
1288+ def from_dict(obj: Any) -> 'Imp':
1289+ assert isinstance(obj, dict)
1290+ return Imp()
1291+
1292+ def to_dict(self) -> dict:
1293+ result: dict = {}
1294+ return result
1295+
1296+
1297+@dataclass
1298+class Implements:
1299+ pass
1300+
1301+ @staticmethod
1302+ def from_dict(obj: Any) -> 'Implements':
1303+ assert isinstance(obj, dict)
1304+ return Implements()
1305+
1306+ def to_dict(self) -> dict:
1307+ result: dict = {}
1308+ return result
1309+
1310+
1311+@dataclass
1312+class Implicit:
1313+ pass
1314+
1315+ @staticmethod
1316+ def from_dict(obj: Any) -> 'Implicit':
1317+ assert isinstance(obj, dict)
1318+ return Implicit()
1319+
1320+ def to_dict(self) -> dict:
1321+ result: dict = {}
1322+ return result
1323+
1324+
1325+@dataclass
1326+class Indirect:
1327+ pass
1328+
1329+ @staticmethod
1330+ def from_dict(obj: Any) -> 'Indirect':
1331+ assert isinstance(obj, dict)
1332+ return Indirect()
1333+
1334+ def to_dict(self) -> dict:
1335+ result: dict = {}
1336+ return result
1337+
1338+
1339+@dataclass
1340+class Infix:
1341+ pass
1342+
1343+ @staticmethod
1344+ def from_dict(obj: Any) -> 'Infix':
1345+ assert isinstance(obj, dict)
1346+ return Infix()
1347+
1348+ def to_dict(self) -> dict:
1349+ result: dict = {}
1350+ return result
1351+
1352+
1353+@dataclass
1354+class Init:
1355+ pass
1356+
1357+ @staticmethod
1358+ def from_dict(obj: Any) -> 'Init':
1359+ assert isinstance(obj, dict)
1360+ return Init()
1361+
1362+ def to_dict(self) -> dict:
1363+ result: dict = {}
1364+ return result
1365+
1366+
1367+@dataclass
1368+class Inline:
1369+ pass
1370+
1371+ @staticmethod
1372+ def from_dict(obj: Any) -> 'Inline':
1373+ assert isinstance(obj, dict)
1374+ return Inline()
1375+
1376+ def to_dict(self) -> dict:
1377+ result: dict = {}
1378+ return result
1379+
1380+
1381+@dataclass
1382+class Inout:
1383+ pass
1384+
1385+ @staticmethod
1386+ def from_dict(obj: Any) -> 'Inout':
1387+ assert isinstance(obj, dict)
1388+ return Inout()
1389+
1390+ def to_dict(self) -> dict:
1391+ result: dict = {}
1392+ return result
1393+
1394+
1395+@dataclass
1396+class Instanceof:
1397+ pass
1398+
1399+ @staticmethod
1400+ def from_dict(obj: Any) -> 'Instanceof':
1401+ assert isinstance(obj, dict)
1402+ return Instanceof()
1403+
1404+ def to_dict(self) -> dict:
1405+ result: dict = {}
1406+ return result
1407+
1408+
1409+@dataclass
1410+class Interface:
1411+ pass
1412+
1413+ @staticmethod
1414+ def from_dict(obj: Any) -> 'Interface':
1415+ assert isinstance(obj, dict)
1416+ return Interface()
1417+
1418+ def to_dict(self) -> dict:
1419+ result: dict = {}
1420+ return result
1421+
1422+
1423+@dataclass
1424+class Internal:
1425+ pass
1426+
1427+ @staticmethod
1428+ def from_dict(obj: Any) -> 'Internal':
1429+ assert isinstance(obj, dict)
1430+ return Internal()
1431+
1432+ def to_dict(self) -> dict:
1433+ result: dict = {}
1434+ return result
1435+
1436+
1437+@dataclass
1438+class IterableClass:
1439+ pass
1440+
1441+ @staticmethod
1442+ def from_dict(obj: Any) -> 'IterableClass':
1443+ assert isinstance(obj, dict)
1444+ return IterableClass()
1445+
1446+ def to_dict(self) -> dict:
1447+ result: dict = {}
1448+ return result
1449+
1450+
1451+@dataclass
1452+class Jdec:
1453+ pass
1454+
1455+ @staticmethod
1456+ def from_dict(obj: Any) -> 'Jdec':
1457+ assert isinstance(obj, dict)
1458+ return Jdec()
1459+
1460+ def to_dict(self) -> dict:
1461+ result: dict = {}
1462+ return result
1463+
1464+
1465+@dataclass
1466+class Jenc:
1467+ pass
1468+
1469+ @staticmethod
1470+ def from_dict(obj: Any) -> 'Jenc':
1471+ assert isinstance(obj, dict)
1472+ return Jenc()
1473+
1474+ def to_dict(self) -> dict:
1475+ result: dict = {}
1476+ return result
1477+
1478+
1479+@dataclass
1480+class Jpipe:
1481+ pass
1482+
1483+ @staticmethod
1484+ def from_dict(obj: Any) -> 'Jpipe':
1485+ assert isinstance(obj, dict)
1486+ return Jpipe()
1487+
1488+ def to_dict(self) -> dict:
1489+ result: dict = {}
1490+ return result
1491+
1492+
1493+@dataclass
1494+class JSON:
1495+ pass
1496+
1497+ @staticmethod
1498+ def from_dict(obj: Any) -> 'JSON':
1499+ assert isinstance(obj, dict)
1500+ return JSON()
1501+
1502+ def to_dict(self) -> dict:
1503+ result: dict = {}
1504+ return result
1505+
1506+
1507+@dataclass
1508+class JSONConverter:
1509+ pass
1510+
1511+ @staticmethod
1512+ def from_dict(obj: Any) -> 'JSONConverter':
1513+ assert isinstance(obj, dict)
1514+ return JSONConverter()
1515+
1516+ def to_dict(self) -> dict:
1517+ result: dict = {}
1518+ return result
1519+
1520+
1521+@dataclass
1522+class JSONSerializer:
1523+ pass
1524+
1525+ @staticmethod
1526+ def from_dict(obj: Any) -> 'JSONSerializer':
1527+ assert isinstance(obj, dict)
1528+ return JSONSerializer()
1529+
1530+ def to_dict(self) -> dict:
1531+ result: dict = {}
1532+ return result
1533+
1534+
1535+@dataclass
1536+class JSONToken:
1537+ pass
1538+
1539+ @staticmethod
1540+ def from_dict(obj: Any) -> 'JSONToken':
1541+ assert isinstance(obj, dict)
1542+ return JSONToken()
1543+
1544+ def to_dict(self) -> dict:
1545+ result: dict = {}
1546+ return result
1547+
1548+
1549+@dataclass
1550+class JSONWriter:
1551+ pass
1552+
1553+ @staticmethod
1554+ def from_dict(obj: Any) -> 'JSONWriter':
1555+ assert isinstance(obj, dict)
1556+ return JSONWriter()
1557+
1558+ def to_dict(self) -> dict:
1559+ result: dict = {}
1560+ return result
1561+
1562+
1563+@dataclass
1564+class Lazy:
1565+ pass
1566+
1567+ @staticmethod
1568+ def from_dict(obj: Any) -> 'Lazy':
1569+ assert isinstance(obj, dict)
1570+ return Lazy()
1571+
1572+ def to_dict(self) -> dict:
1573+ result: dict = {}
1574+ return result
1575+
1576+
1577+@dataclass
1578+class Left:
1579+ pass
1580+
1581+ @staticmethod
1582+ def from_dict(obj: Any) -> 'Left':
1583+ assert isinstance(obj, dict)
1584+ return Left()
1585+
1586+ def to_dict(self) -> dict:
1587+ result: dict = {}
1588+ return result
1589+
1590+
1591+@dataclass
1592+class Let:
1593+ pass
1594+
1595+ @staticmethod
1596+ def from_dict(obj: Any) -> 'Let':
1597+ assert isinstance(obj, dict)
1598+ return Let()
1599+
1600+ def to_dict(self) -> dict:
1601+ result: dict = {}
1602+ return result
1603+
1604+
1605+@dataclass
1606+class ListClass:
1607+ pass
1608+
1609+ @staticmethod
1610+ def from_dict(obj: Any) -> 'ListClass':
1611+ assert isinstance(obj, dict)
1612+ return ListClass()
1613+
1614+ def to_dict(self) -> dict:
1615+ result: dict = {}
1616+ return result
1617+
1618+
1619+@dataclass
1620+class Lock:
1621+ pass
1622+
1623+ @staticmethod
1624+ def from_dict(obj: Any) -> 'Lock':
1625+ assert isinstance(obj, dict)
1626+ return Lock()
1627+
1628+ def to_dict(self) -> dict:
1629+ result: dict = {}
1630+ return result
1631+
1632+
1633+@dataclass
1634+class Long:
1635+ pass
1636+
1637+ @staticmethod
1638+ def from_dict(obj: Any) -> 'Long':
1639+ assert isinstance(obj, dict)
1640+ return Long()
1641+
1642+ def to_dict(self) -> dict:
1643+ result: dict = {}
1644+ return result
1645+
1646+
1647+@dataclass
1648+class Map:
1649+ pass
1650+
1651+ @staticmethod
1652+ def from_dict(obj: Any) -> 'Map':
1653+ assert isinstance(obj, dict)
1654+ return Map()
1655+
1656+ def to_dict(self) -> dict:
1657+ result: dict = {}
1658+ return result
1659+
1660+
1661+@dataclass
1662+class MetadataPropertyHandling:
1663+ pass
1664+
1665+ @staticmethod
1666+ def from_dict(obj: Any) -> 'MetadataPropertyHandling':
1667+ assert isinstance(obj, dict)
1668+ return MetadataPropertyHandling()
1669+
1670+ def to_dict(self) -> dict:
1671+ result: dict = {}
1672+ return result
1673+
1674+
1675+@dataclass
1676+class Module:
1677+ pass
1678+
1679+ @staticmethod
1680+ def from_dict(obj: Any) -> 'Module':
1681+ assert isinstance(obj, dict)
1682+ return Module()
1683+
1684+ def to_dict(self) -> dict:
1685+ result: dict = {}
1686+ return result
1687+
1688+
1689+@dataclass
1690+class Mutable:
1691+ pass
1692+
1693+ @staticmethod
1694+ def from_dict(obj: Any) -> 'Mutable':
1695+ assert isinstance(obj, dict)
1696+ return Mutable()
1697+
1698+ def to_dict(self) -> dict:
1699+ result: dict = {}
1700+ return result
1701+
1702+
1703+@dataclass
1704+class Mutating:
1705+ pass
1706+
1707+ @staticmethod
1708+ def from_dict(obj: Any) -> 'Mutating':
1709+ assert isinstance(obj, dict)
1710+ return Mutating()
1711+
1712+ def to_dict(self) -> dict:
1713+ result: dict = {}
1714+ return result
1715+
1716+
1717+@dataclass
1718+class Namespace:
1719+ pass
1720+
1721+ @staticmethod
1722+ def from_dict(obj: Any) -> 'Namespace':
1723+ assert isinstance(obj, dict)
1724+ return Namespace()
1725+
1726+ def to_dict(self) -> dict:
1727+ result: dict = {}
1728+ return result
1729+
1730+
1731+@dataclass
1732+class Native:
1733+ pass
1734+
1735+ @staticmethod
1736+ def from_dict(obj: Any) -> 'Native':
1737+ assert isinstance(obj, dict)
1738+ return Native()
1739+
1740+ def to_dict(self) -> dict:
1741+ result: dict = {}
1742+ return result
1743+
1744+
1745+@dataclass
1746+class New:
1747+ pass
1748+
1749+ @staticmethod
1750+ def from_dict(obj: Any) -> 'New':
1751+ assert isinstance(obj, dict)
1752+ return New()
1753+
1754+ def to_dict(self) -> dict:
1755+ result: dict = {}
1756+ return result
1757+
1758+
1759+@dataclass
1760+class Newtonsoft:
1761+ pass
1762+
1763+ @staticmethod
1764+ def from_dict(obj: Any) -> 'Newtonsoft':
1765+ assert isinstance(obj, dict)
1766+ return Newtonsoft()
1767+
1768+ def to_dict(self) -> dict:
1769+ result: dict = {}
1770+ return result
1771+
1772+
1773+@dataclass
1774+class Nil:
1775+ pass
1776+
1777+ @staticmethod
1778+ def from_dict(obj: Any) -> 'Nil':
1779+ assert isinstance(obj, dict)
1780+ return Nil()
1781+
1782+ def to_dict(self) -> dict:
1783+ result: dict = {}
1784+ return result
1785+
1786+
1787+@dataclass
1788+class No:
1789+ pass
1790+
1791+ @staticmethod
1792+ def from_dict(obj: Any) -> 'No':
1793+ assert isinstance(obj, dict)
1794+ return No()
1795+
1796+ def to_dict(self) -> dict:
1797+ result: dict = {}
1798+ return result
1799+
1800+
1801+@dataclass
1802+class Noexcept:
1803+ pass
1804+
1805+ @staticmethod
1806+ def from_dict(obj: Any) -> 'Noexcept':
1807+ assert isinstance(obj, dict)
1808+ return Noexcept()
1809+
1810+ def to_dict(self) -> dict:
1811+ result: dict = {}
1812+ return result
1813+
1814+
1815+@dataclass
1816+class Nonatomic:
1817+ pass
1818+
1819+ @staticmethod
1820+ def from_dict(obj: Any) -> 'Nonatomic':
1821+ assert isinstance(obj, dict)
1822+ return Nonatomic()
1823+
1824+ def to_dict(self) -> dict:
1825+ result: dict = {}
1826+ return result
1827+
1828+
1829+@dataclass
1830+class NoneClass:
1831+ pass
1832+
1833+ @staticmethod
1834+ def from_dict(obj: Any) -> 'NoneClass':
1835+ assert isinstance(obj, dict)
1836+ return NoneClass()
1837+
1838+ def to_dict(self) -> dict:
1839+ result: dict = {}
1840+ return result
1841+
1842+
1843+@dataclass
1844+class Nonmutating:
1845+ pass
1846+
1847+ @staticmethod
1848+ def from_dict(obj: Any) -> 'Nonmutating':
1849+ assert isinstance(obj, dict)
1850+ return Nonmutating()
1851+
1852+ def to_dict(self) -> dict:
1853+ result: dict = {}
1854+ return result
1855+
1856+
1857+@dataclass
1858+class NotEq:
1859+ pass
1860+
1861+ @staticmethod
1862+ def from_dict(obj: Any) -> 'NotEq':
1863+ assert isinstance(obj, dict)
1864+ return NotEq()
1865+
1866+ def to_dict(self) -> dict:
1867+ result: dict = {}
1868+ return result
1869+
1870+
1871+@dataclass
1872+class NSString:
1873+ pass
1874+
1875+ @staticmethod
1876+ def from_dict(obj: Any) -> 'NSString':
1877+ assert isinstance(obj, dict)
1878+ return NSString()
1879+
1880+ def to_dict(self) -> dict:
1881+ result: dict = {}
1882+ return result
1883+
1884+
1885+@dataclass
1886+class Null:
1887+ pass
1888+
1889+ @staticmethod
1890+ def from_dict(obj: Any) -> 'Null':
1891+ assert isinstance(obj, dict)
1892+ return Null()
1893+
1894+ def to_dict(self) -> dict:
1895+ result: dict = {}
1896+ return result
1897+
1898+
1899+@dataclass
1900+class Nullptr:
1901+ pass
1902+
1903+ @staticmethod
1904+ def from_dict(obj: Any) -> 'Nullptr':
1905+ assert isinstance(obj, dict)
1906+ return Nullptr()
1907+
1908+ def to_dict(self) -> dict:
1909+ result: dict = {}
1910+ return result
1911+
1912+
1913+@dataclass
1914+class Number:
1915+ pass
1916+
1917+ @staticmethod
1918+ def from_dict(obj: Any) -> 'Number':
1919+ assert isinstance(obj, dict)
1920+ return Number()
1921+
1922+ def to_dict(self) -> dict:
1923+ result: dict = {}
1924+ return result
1925+
1926+
1927+@dataclass
1928+class Object:
1929+ pass
1930+
1931+ @staticmethod
1932+ def from_dict(obj: Any) -> 'Object':
1933+ assert isinstance(obj, dict)
1934+ return Object()
1935+
1936+ def to_dict(self) -> dict:
1937+ result: dict = {}
1938+ return result
1939+
1940+
1941+@dataclass
1942+class Of:
1943+ pass
1944+
1945+ @staticmethod
1946+ def from_dict(obj: Any) -> 'Of':
1947+ assert isinstance(obj, dict)
1948+ return Of()
1949+
1950+ def to_dict(self) -> dict:
1951+ result: dict = {}
1952+ return result
1953+
1954+
1955+@dataclass
1956+class Oneway:
1957+ pass
1958+
1959+ @staticmethod
1960+ def from_dict(obj: Any) -> 'Oneway':
1961+ assert isinstance(obj, dict)
1962+ return Oneway()
1963+
1964+ def to_dict(self) -> dict:
1965+ result: dict = {}
1966+ return result
1967+
1968+
1969+@dataclass
1970+class Open:
1971+ pass
1972+
1973+ @staticmethod
1974+ def from_dict(obj: Any) -> 'Open':
1975+ assert isinstance(obj, dict)
1976+ return Open()
1977+
1978+ def to_dict(self) -> dict:
1979+ result: dict = {}
1980+ return result
1981+
1982+
1983+@dataclass
1984+class Operator:
1985+ pass
1986+
1987+ @staticmethod
1988+ def from_dict(obj: Any) -> 'Operator':
1989+ assert isinstance(obj, dict)
1990+ return Operator()
1991+
1992+ def to_dict(self) -> dict:
1993+ result: dict = {}
1994+ return result
1995+
1996+
1997+@dataclass
1998+class OptionalClass:
1999+ pass
2000+
2001+ @staticmethod
2002+ def from_dict(obj: Any) -> 'OptionalClass':
2003+ assert isinstance(obj, dict)
2004+ return OptionalClass()
2005+
2006+ def to_dict(self) -> dict:
2007+ result: dict = {}
2008+ return result
2009+
2010+
2011+@dataclass
2012+class OrEq:
2013+ pass
2014+
2015+ @staticmethod
2016+ def from_dict(obj: Any) -> 'OrEq':
2017+ assert isinstance(obj, dict)
2018+ return OrEq()
2019+
2020+ def to_dict(self) -> dict:
2021+ result: dict = {}
2022+ return result
2023+
2024+
2025+@dataclass
2026+class Out:
2027+ pass
2028+
2029+ @staticmethod
2030+ def from_dict(obj: Any) -> 'Out':
2031+ assert isinstance(obj, dict)
2032+ return Out()
2033+
2034+ def to_dict(self) -> dict:
2035+ result: dict = {}
2036+ return result
2037+
2038+
2039+@dataclass
2040+class Override:
2041+ pass
2042+
2043+ @staticmethod
2044+ def from_dict(obj: Any) -> 'Override':
2045+ assert isinstance(obj, dict)
2046+ return Override()
2047+
2048+ def to_dict(self) -> dict:
2049+ result: dict = {}
2050+ return result
2051+
2052+
2053+@dataclass
2054+class Package:
2055+ pass
2056+
2057+ @staticmethod
2058+ def from_dict(obj: Any) -> 'Package':
2059+ assert isinstance(obj, dict)
2060+ return Package()
2061+
2062+ def to_dict(self) -> dict:
2063+ result: dict = {}
2064+ return result
2065+
2066+
2067+@dataclass
2068+class Params:
2069+ pass
2070+
2071+ @staticmethod
2072+ def from_dict(obj: Any) -> 'Params':
2073+ assert isinstance(obj, dict)
2074+ return Params()
2075+
2076+ def to_dict(self) -> dict:
2077+ result: dict = {}
2078+ return result
2079+
2080+
2081+@dataclass
2082+class Port:
2083+ pass
2084+
2085+ @staticmethod
2086+ def from_dict(obj: Any) -> 'Port':
2087+ assert isinstance(obj, dict)
2088+ return Port()
2089+
2090+ def to_dict(self) -> dict:
2091+ result: dict = {}
2092+ return result
2093+
2094+
2095+@dataclass
2096+class Postfix:
2097+ pass
2098+
2099+ @staticmethod
2100+ def from_dict(obj: Any) -> 'Postfix':
2101+ assert isinstance(obj, dict)
2102+ return Postfix()
2103+
2104+ def to_dict(self) -> dict:
2105+ result: dict = {}
2106+ return result
2107+
2108+
2109+@dataclass
2110+class Precedence:
2111+ pass
2112+
2113+ @staticmethod
2114+ def from_dict(obj: Any) -> 'Precedence':
2115+ assert isinstance(obj, dict)
2116+ return Precedence()
2117+
2118+ def to_dict(self) -> dict:
2119+ result: dict = {}
2120+ return result
2121+
2122+
2123+@dataclass
2124+class Prefix:
2125+ pass
2126+
2127+ @staticmethod
2128+ def from_dict(obj: Any) -> 'Prefix':
2129+ assert isinstance(obj, dict)
2130+ return Prefix()
2131+
2132+ def to_dict(self) -> dict:
2133+ result: dict = {}
2134+ return result
2135+
2136+
2137+@dataclass
2138+class Printf:
2139+ pass
2140+
2141+ @staticmethod
2142+ def from_dict(obj: Any) -> 'Printf':
2143+ assert isinstance(obj, dict)
2144+ return Printf()
2145+
2146+ def to_dict(self) -> dict:
2147+ result: dict = {}
2148+ return result
2149+
2150+
2151+@dataclass
2152+class Private:
2153+ pass
2154+
2155+ @staticmethod
2156+ def from_dict(obj: Any) -> 'Private':
2157+ assert isinstance(obj, dict)
2158+ return Private()
2159+
2160+ def to_dict(self) -> dict:
2161+ result: dict = {}
2162+ return result
2163+
2164+
2165+@dataclass
2166+class Protected:
2167+ pass
2168+
2169+ @staticmethod
2170+ def from_dict(obj: Any) -> 'Protected':
2171+ assert isinstance(obj, dict)
2172+ return Protected()
2173+
2174+ def to_dict(self) -> dict:
2175+ result: dict = {}
2176+ return result
2177+
2178+
2179+@dataclass
2180+class Protocol:
2181+ pass
2182+
2183+ @staticmethod
2184+ def from_dict(obj: Any) -> 'Protocol':
2185+ assert isinstance(obj, dict)
2186+ return Protocol()
2187+
2188+ def to_dict(self) -> dict:
2189+ result: dict = {}
2190+ return result
2191+
2192+
2193+@dataclass
2194+class Public:
2195+ pass
2196+
2197+ @staticmethod
2198+ def from_dict(obj: Any) -> 'Public':
2199+ assert isinstance(obj, dict)
2200+ return Public()
2201+
2202+ def to_dict(self) -> dict:
2203+ result: dict = {}
2204+ return result
2205+
2206+
2207+@dataclass
2208+class BoolClass:
2209+ pass
2210+
2211+ @staticmethod
2212+ def from_dict(obj: Any) -> 'BoolClass':
2213+ assert isinstance(obj, dict)
2214+ return BoolClass()
2215+
2216+ def to_dict(self) -> dict:
2217+ result: dict = {}
2218+ return result
2219+
2220+
2221+@dataclass
2222+class ClassClass:
2223+ pass
2224+
2225+ @staticmethod
2226+ def from_dict(obj: Any) -> 'ClassClass':
2227+ assert isinstance(obj, dict)
2228+ return ClassClass()
2229+
2230+ def to_dict(self) -> dict:
2231+ result: dict = {}
2232+ return result
2233+
2234+
2235+@dataclass
2236+class SelfClass:
2237+ pass
2238+
2239+ @staticmethod
2240+ def from_dict(obj: Any) -> 'SelfClass':
2241+ assert isinstance(obj, dict)
2242+ return SelfClass()
2243+
2244+ def to_dict(self) -> dict:
2245+ result: dict = {}
2246+ return result
2247+
2248+
2249+@dataclass
2250+class Quicktype:
2251+ pass
2252+
2253+ @staticmethod
2254+ def from_dict(obj: Any) -> 'Quicktype':
2255+ assert isinstance(obj, dict)
2256+ return Quicktype()
2257+
2258+ def to_dict(self) -> dict:
2259+ result: dict = {}
2260+ return result
2261+
2262+
2263+@dataclass
2264+class Range:
2265+ pass
2266+
2267+ @staticmethod
2268+ def from_dict(obj: Any) -> 'Range':
2269+ assert isinstance(obj, dict)
2270+ return Range()
2271+
2272+ def to_dict(self) -> dict:
2273+ result: dict = {}
2274+ return result
2275+
2276+
2277+@dataclass
2278+class Readonly:
2279+ pass
2280+
2281+ @staticmethod
2282+ def from_dict(obj: Any) -> 'Readonly':
2283+ assert isinstance(obj, dict)
2284+ return Readonly()
2285+
2286+ def to_dict(self) -> dict:
2287+ result: dict = {}
2288+ return result
2289+
2290+
2291+@dataclass
2292+class Ref:
2293+ pass
2294+
2295+ @staticmethod
2296+ def from_dict(obj: Any) -> 'Ref':
2297+ assert isinstance(obj, dict)
2298+ return Ref()
2299+
2300+ def to_dict(self) -> dict:
2301+ result: dict = {}
2302+ return result
2303+
2304+
2305+@dataclass
2306+class Register:
2307+ pass
2308+
2309+ @staticmethod
2310+ def from_dict(obj: Any) -> 'Register':
2311+ assert isinstance(obj, dict)
2312+ return Register()
2313+
2314+ def to_dict(self) -> dict:
2315+ result: dict = {}
2316+ return result
2317+
2318+
2319+@dataclass
2320+class ReinterpretCast:
2321+ pass
2322+
2323+ @staticmethod
2324+ def from_dict(obj: Any) -> 'ReinterpretCast':
2325+ assert isinstance(obj, dict)
2326+ return ReinterpretCast()
2327+
2328+ def to_dict(self) -> dict:
2329+ result: dict = {}
2330+ return result
2331+
2332+
2333+@dataclass
2334+class Repeat:
2335+ pass
2336+
2337+ @staticmethod
2338+ def from_dict(obj: Any) -> 'Repeat':
2339+ assert isinstance(obj, dict)
2340+ return Repeat()
2341+
2342+ def to_dict(self) -> dict:
2343+ result: dict = {}
2344+ return result
2345+
2346+
2347+@dataclass
2348+class Require:
2349+ pass
2350+
2351+ @staticmethod
2352+ def from_dict(obj: Any) -> 'Require':
2353+ assert isinstance(obj, dict)
2354+ return Require()
2355+
2356+ def to_dict(self) -> dict:
2357+ result: dict = {}
2358+ return result
2359+
2360+
2361+@dataclass
2362+class Required:
2363+ pass
2364+
2365+ @staticmethod
2366+ def from_dict(obj: Any) -> 'Required':
2367+ assert isinstance(obj, dict)
2368+ return Required()
2369+
2370+ def to_dict(self) -> dict:
2371+ result: dict = {}
2372+ return result
2373+
2374+
2375+@dataclass
2376+class Requires:
2377+ pass
2378+
2379+ @staticmethod
2380+ def from_dict(obj: Any) -> 'Requires':
2381+ assert isinstance(obj, dict)
2382+ return Requires()
2383+
2384+ def to_dict(self) -> dict:
2385+ result: dict = {}
2386+ return result
2387+
2388+
2389+@dataclass
2390+class Restrict:
2391+ pass
2392+
2393+ @staticmethod
2394+ def from_dict(obj: Any) -> 'Restrict':
2395+ assert isinstance(obj, dict)
2396+ return Restrict()
2397+
2398+ def to_dict(self) -> dict:
2399+ result: dict = {}
2400+ return result
2401+
2402+
2403+@dataclass
2404+class Retain:
2405+ pass
2406+
2407+ @staticmethod
2408+ def from_dict(obj: Any) -> 'Retain':
2409+ assert isinstance(obj, dict)
2410+ return Retain()
2411+
2412+ def to_dict(self) -> dict:
2413+ result: dict = {}
2414+ return result
2415+
2416+
2417+@dataclass
2418+class Rethrows:
2419+ pass
2420+
2421+ @staticmethod
2422+ def from_dict(obj: Any) -> 'Rethrows':
2423+ assert isinstance(obj, dict)
2424+ return Rethrows()
2425+
2426+ def to_dict(self) -> dict:
2427+ result: dict = {}
2428+ return result
2429+
2430+
2431+@dataclass
2432+class Right:
2433+ pass
2434+
2435+ @staticmethod
2436+ def from_dict(obj: Any) -> 'Right':
2437+ assert isinstance(obj, dict)
2438+ return Right()
2439+
2440+ def to_dict(self) -> dict:
2441+ result: dict = {}
2442+ return result
2443+
2444+
2445+@dataclass
2446+class Sbyte:
2447+ pass
2448+
2449+ @staticmethod
2450+ def from_dict(obj: Any) -> 'Sbyte':
2451+ assert isinstance(obj, dict)
2452+ return Sbyte()
2453+
2454+ def to_dict(self) -> dict:
2455+ result: dict = {}
2456+ return result
2457+
2458+
2459+@dataclass
2460+class Sealed:
2461+ pass
2462+
2463+ @staticmethod
2464+ def from_dict(obj: Any) -> 'Sealed':
2465+ assert isinstance(obj, dict)
2466+ return Sealed()
2467+
2468+ def to_dict(self) -> dict:
2469+ result: dict = {}
2470+ return result
2471+
2472+
2473+@dataclass
2474+class Sel:
2475+ pass
2476+
2477+ @staticmethod
2478+ def from_dict(obj: Any) -> 'Sel':
2479+ assert isinstance(obj, dict)
2480+ return Sel()
2481+
2482+ def to_dict(self) -> dict:
2483+ result: dict = {}
2484+ return result
2485+
2486+
2487+@dataclass
2488+class Select:
2489+ pass
2490+
2491+ @staticmethod
2492+ def from_dict(obj: Any) -> 'Select':
2493+ assert isinstance(obj, dict)
2494+ return Select()
2495+
2496+ def to_dict(self) -> dict:
2497+ result: dict = {}
2498+ return result
2499+
2500+
2501+@dataclass
2502+class Serialize:
2503+ pass
2504+
2505+ @staticmethod
2506+ def from_dict(obj: Any) -> 'Serialize':
2507+ assert isinstance(obj, dict)
2508+ return Serialize()
2509+
2510+ def to_dict(self) -> dict:
2511+ result: dict = {}
2512+ return result
2513+
2514+
2515+@dataclass
2516+class Set:
2517+ pass
2518+
2519+ @staticmethod
2520+ def from_dict(obj: Any) -> 'Set':
2521+ assert isinstance(obj, dict)
2522+ return Set()
2523+
2524+ def to_dict(self) -> dict:
2525+ result: dict = {}
2526+ return result
2527+
2528+
2529+@dataclass
2530+class Short:
2531+ pass
2532+
2533+ @staticmethod
2534+ def from_dict(obj: Any) -> 'Short':
2535+ assert isinstance(obj, dict)
2536+ return Short()
2537+
2538+ def to_dict(self) -> dict:
2539+ result: dict = {}
2540+ return result
2541+
2542+
2543+@dataclass
2544+class Signed:
2545+ pass
2546+
2547+ @staticmethod
2548+ def from_dict(obj: Any) -> 'Signed':
2549+ assert isinstance(obj, dict)
2550+ return Signed()
2551+
2552+ def to_dict(self) -> dict:
2553+ result: dict = {}
2554+ return result
2555+
2556+
2557+@dataclass
2558+class Sizeof:
2559+ pass
2560+
2561+ @staticmethod
2562+ def from_dict(obj: Any) -> 'Sizeof':
2563+ assert isinstance(obj, dict)
2564+ return Sizeof()
2565+
2566+ def to_dict(self) -> dict:
2567+ result: dict = {}
2568+ return result
2569+
2570+
2571+@dataclass
2572+class Stackalloc:
2573+ pass
2574+
2575+ @staticmethod
2576+ def from_dict(obj: Any) -> 'Stackalloc':
2577+ assert isinstance(obj, dict)
2578+ return Stackalloc()
2579+
2580+ def to_dict(self) -> dict:
2581+ result: dict = {}
2582+ return result
2583+
2584+
2585+@dataclass
2586+class Static:
2587+ pass
2588+
2589+ @staticmethod
2590+ def from_dict(obj: Any) -> 'Static':
2591+ assert isinstance(obj, dict)
2592+ return Static()
2593+
2594+ def to_dict(self) -> dict:
2595+ result: dict = {}
2596+ return result
2597+
2598+
2599+@dataclass
2600+class StaticAssert:
2601+ pass
2602+
2603+ @staticmethod
2604+ def from_dict(obj: Any) -> 'StaticAssert':
2605+ assert isinstance(obj, dict)
2606+ return StaticAssert()
2607+
2608+ def to_dict(self) -> dict:
2609+ result: dict = {}
2610+ return result
2611+
2612+
2613+@dataclass
2614+class StaticCast:
2615+ pass
2616+
2617+ @staticmethod
2618+ def from_dict(obj: Any) -> 'StaticCast':
2619+ assert isinstance(obj, dict)
2620+ return StaticCast()
2621+
2622+ def to_dict(self) -> dict:
2623+ result: dict = {}
2624+ return result
2625+
2626+
2627+@dataclass
2628+class Strictfp:
2629+ pass
2630+
2631+ @staticmethod
2632+ def from_dict(obj: Any) -> 'Strictfp':
2633+ assert isinstance(obj, dict)
2634+ return Strictfp()
2635+
2636+ def to_dict(self) -> dict:
2637+ result: dict = {}
2638+ return result
2639+
2640+
2641+@dataclass
2642+class String:
2643+ pass
2644+
2645+ @staticmethod
2646+ def from_dict(obj: Any) -> 'String':
2647+ assert isinstance(obj, dict)
2648+ return String()
2649+
2650+ def to_dict(self) -> dict:
2651+ result: dict = {}
2652+ return result
2653+
2654+
2655+@dataclass
2656+class Struct:
2657+ pass
2658+
2659+ @staticmethod
2660+ def from_dict(obj: Any) -> 'Struct':
2661+ assert isinstance(obj, dict)
2662+ return Struct()
2663+
2664+ def to_dict(self) -> dict:
2665+ result: dict = {}
2666+ return result
2667+
2668+
2669+@dataclass
2670+class Subscript:
2671+ pass
2672+
2673+ @staticmethod
2674+ def from_dict(obj: Any) -> 'Subscript':
2675+ assert isinstance(obj, dict)
2676+ return Subscript()
2677+
2678+ def to_dict(self) -> dict:
2679+ result: dict = {}
2680+ return result
2681+
2682+
2683+@dataclass
2684+class Super:
2685+ pass
2686+
2687+ @staticmethod
2688+ def from_dict(obj: Any) -> 'Super':
2689+ assert isinstance(obj, dict)
2690+ return Super()
2691+
2692+ def to_dict(self) -> dict:
2693+ result: dict = {}
2694+ return result
2695+
2696+
2697+@dataclass
2698+class Switch:
2699+ pass
2700+
2701+ @staticmethod
2702+ def from_dict(obj: Any) -> 'Switch':
2703+ assert isinstance(obj, dict)
2704+ return Switch()
2705+
2706+ def to_dict(self) -> dict:
2707+ result: dict = {}
2708+ return result
2709+
2710+
2711+@dataclass
2712+class Symbol:
2713+ pass
2714+
2715+ @staticmethod
2716+ def from_dict(obj: Any) -> 'Symbol':
2717+ assert isinstance(obj, dict)
2718+ return Symbol()
2719+
2720+ def to_dict(self) -> dict:
2721+ result: dict = {}
2722+ return result
2723+
2724+
2725+@dataclass
2726+class Synchronized:
2727+ pass
2728+
2729+ @staticmethod
2730+ def from_dict(obj: Any) -> 'Synchronized':
2731+ assert isinstance(obj, dict)
2732+ return Synchronized()
2733+
2734+ def to_dict(self) -> dict:
2735+ result: dict = {}
2736+ return result
2737+
2738+
2739+@dataclass
2740+class System:
2741+ pass
2742+
2743+ @staticmethod
2744+ def from_dict(obj: Any) -> 'System':
2745+ assert isinstance(obj, dict)
2746+ return System()
2747+
2748+ def to_dict(self) -> dict:
2749+ result: dict = {}
2750+ return result
2751+
2752+
2753+@dataclass
2754+class Template:
2755+ pass
2756+
2757+ @staticmethod
2758+ def from_dict(obj: Any) -> 'Template':
2759+ assert isinstance(obj, dict)
2760+ return Template()
2761+
2762+ def to_dict(self) -> dict:
2763+ result: dict = {}
2764+ return result
2765+
2766+
2767+@dataclass
2768+class Then:
2769+ pass
2770+
2771+ @staticmethod
2772+ def from_dict(obj: Any) -> 'Then':
2773+ assert isinstance(obj, dict)
2774+ return Then()
2775+
2776+ def to_dict(self) -> dict:
2777+ result: dict = {}
2778+ return result
2779+
2780+
2781+@dataclass
2782+class This:
2783+ pass
2784+
2785+ @staticmethod
2786+ def from_dict(obj: Any) -> 'This':
2787+ assert isinstance(obj, dict)
2788+ return This()
2789+
2790+ def to_dict(self) -> dict:
2791+ result: dict = {}
2792+ return result
2793+
2794+
2795+@dataclass
2796+class ThreadLocal:
2797+ pass
2798+
2799+ @staticmethod
2800+ def from_dict(obj: Any) -> 'ThreadLocal':
2801+ assert isinstance(obj, dict)
2802+ return ThreadLocal()
2803+
2804+ def to_dict(self) -> dict:
2805+ result: dict = {}
2806+ return result
2807+
2808+
2809+@dataclass
2810+class Throw:
2811+ pass
2812+
2813+ @staticmethod
2814+ def from_dict(obj: Any) -> 'Throw':
2815+ assert isinstance(obj, dict)
2816+ return Throw()
2817+
2818+ def to_dict(self) -> dict:
2819+ result: dict = {}
2820+ return result
2821+
2822+
2823+@dataclass
2824+class Throws:
2825+ pass
2826+
2827+ @staticmethod
2828+ def from_dict(obj: Any) -> 'Throws':
2829+ assert isinstance(obj, dict)
2830+ return Throws()
2831+
2832+ def to_dict(self) -> dict:
2833+ result: dict = {}
2834+ return result
2835+
2836+
2837+@dataclass
2838+class ToJSON:
2839+ pass
2840+
2841+ @staticmethod
2842+ def from_dict(obj: Any) -> 'ToJSON':
2843+ assert isinstance(obj, dict)
2844+ return ToJSON()
2845+
2846+ def to_dict(self) -> dict:
2847+ result: dict = {}
2848+ return result
2849+
2850+
2851+@dataclass
2852+class TopLevelClass:
2853+ pass
2854+
2855+ @staticmethod
2856+ def from_dict(obj: Any) -> 'TopLevelClass':
2857+ assert isinstance(obj, dict)
2858+ return TopLevelClass()
2859+
2860+ def to_dict(self) -> dict:
2861+ result: dict = {}
2862+ return result
2863+
2864+
2865+@dataclass
2866+class And:
2867+ pass
2868+
2869+ @staticmethod
2870+ def from_dict(obj: Any) -> 'And':
2871+ assert isinstance(obj, dict)
2872+ return And()
2873+
2874+ def to_dict(self) -> dict:
2875+ result: dict = {}
2876+ return result
2877+
2878+
2879+@dataclass
2880+class UnionAnyAny:
2881+ pass
2882+
2883+ @staticmethod
2884+ def from_dict(obj: Any) -> 'UnionAnyAny':
2885+ assert isinstance(obj, dict)
2886+ return UnionAnyAny()
2887+
2888+ def to_dict(self) -> dict:
2889+ result: dict = {}
2890+ return result
2891+
2892+
2893+@dataclass
2894+class As:
2895+ pass
2896+
2897+ @staticmethod
2898+ def from_dict(obj: Any) -> 'As':
2899+ assert isinstance(obj, dict)
2900+ return As()
2901+
2902+ def to_dict(self) -> dict:
2903+ result: dict = {}
2904+ return result
2905+
2906+
2907+@dataclass
2908+class Assert:
2909+ pass
2910+
2911+ @staticmethod
2912+ def from_dict(obj: Any) -> 'Assert':
2913+ assert isinstance(obj, dict)
2914+ return Assert()
2915+
2916+ def to_dict(self) -> dict:
2917+ result: dict = {}
2918+ return result
2919+
2920+
2921+@dataclass
2922+class Async:
2923+ pass
2924+
2925+ @staticmethod
2926+ def from_dict(obj: Any) -> 'Async':
2927+ assert isinstance(obj, dict)
2928+ return Async()
2929+
2930+ def to_dict(self) -> dict:
2931+ result: dict = {}
2932+ return result
2933+
2934+
2935+@dataclass
2936+class Await:
2937+ pass
2938+
2939+ @staticmethod
2940+ def from_dict(obj: Any) -> 'Await':
2941+ assert isinstance(obj, dict)
2942+ return Await()
2943+
2944+ def to_dict(self) -> dict:
2945+ result: dict = {}
2946+ return result
2947+
2948+
2949+@dataclass
2950+class Bool:
2951+ pass
2952+
2953+ @staticmethod
2954+ def from_dict(obj: Any) -> 'Bool':
2955+ assert isinstance(obj, dict)
2956+ return Bool()
2957+
2958+ def to_dict(self) -> dict:
2959+ result: dict = {}
2960+ return result
2961+
2962+
2963+@dataclass
2964+class Break:
2965+ pass
2966+
2967+ @staticmethod
2968+ def from_dict(obj: Any) -> 'Break':
2969+ assert isinstance(obj, dict)
2970+ return Break()
2971+
2972+ def to_dict(self) -> dict:
2973+ result: dict = {}
2974+ return result
2975+
2976+
2977+@dataclass
2978+class Class:
2979+ pass
2980+
2981+ @staticmethod
2982+ def from_dict(obj: Any) -> 'Class':
2983+ assert isinstance(obj, dict)
2984+ return Class()
2985+
2986+ def to_dict(self) -> dict:
2987+ result: dict = {}
2988+ return result
2989+
2990+
2991+@dataclass
2992+class Continue:
2993+ pass
2994+
2995+ @staticmethod
2996+ def from_dict(obj: Any) -> 'Continue':
2997+ assert isinstance(obj, dict)
2998+ return Continue()
2999+
3000+ def to_dict(self) -> dict:
3001+ result: dict = {}
3002+ return result
3003+
3004+
3005+@dataclass
3006+class Def:
3007+ pass
3008+
3009+ @staticmethod
3010+ def from_dict(obj: Any) -> 'Def':
3011+ assert isinstance(obj, dict)
3012+ return Def()
3013+
3014+ def to_dict(self) -> dict:
3015+ result: dict = {}
3016+ return result
3017+
3018+
3019+@dataclass
3020+class Del:
3021+ pass
3022+
3023+ @staticmethod
3024+ def from_dict(obj: Any) -> 'Del':
3025+ assert isinstance(obj, dict)
3026+ return Del()
3027+
3028+ def to_dict(self) -> dict:
3029+ result: dict = {}
3030+ return result
3031+
3032+
3033+@dataclass
3034+class DictClass:
3035+ pass
3036+
3037+ @staticmethod
3038+ def from_dict(obj: Any) -> 'DictClass':
3039+ assert isinstance(obj, dict)
3040+ return DictClass()
3041+
3042+ def to_dict(self) -> dict:
3043+ result: dict = {}
3044+ return result
3045+
3046+
3047+@dataclass
3048+class Elif:
3049+ pass
3050+
3051+ @staticmethod
3052+ def from_dict(obj: Any) -> 'Elif':
3053+ assert isinstance(obj, dict)
3054+ return Elif()
3055+
3056+ def to_dict(self) -> dict:
3057+ result: dict = {}
3058+ return result
3059+
3060+
3061+@dataclass
3062+class Else:
3063+ pass
3064+
3065+ @staticmethod
3066+ def from_dict(obj: Any) -> 'Else':
3067+ assert isinstance(obj, dict)
3068+ return Else()
3069+
3070+ def to_dict(self) -> dict:
3071+ result: dict = {}
3072+ return result
3073+
3074+
3075+@dataclass
3076+class Except:
3077+ pass
3078+
3079+ @staticmethod
3080+ def from_dict(obj: Any) -> 'Except':
3081+ assert isinstance(obj, dict)
3082+ return Except()
3083+
3084+ def to_dict(self) -> dict:
3085+ result: dict = {}
3086+ return result
3087+
3088+
3089+@dataclass
3090+class UnionFalseFalse:
3091+ pass
3092+
3093+ @staticmethod
3094+ def from_dict(obj: Any) -> 'UnionFalseFalse':
3095+ assert isinstance(obj, dict)
3096+ return UnionFalseFalse()
3097+
3098+ def to_dict(self) -> dict:
3099+ result: dict = {}
3100+ return result
3101+
3102+
3103+@dataclass
3104+class Finally:
3105+ pass
3106+
3107+ @staticmethod
3108+ def from_dict(obj: Any) -> 'Finally':
3109+ assert isinstance(obj, dict)
3110+ return Finally()
3111+
3112+ def to_dict(self) -> dict:
3113+ result: dict = {}
3114+ return result
3115+
3116+
3117+@dataclass
3118+class Float:
3119+ pass
3120+
3121+ @staticmethod
3122+ def from_dict(obj: Any) -> 'Float':
3123+ assert isinstance(obj, dict)
3124+ return Float()
3125+
3126+ def to_dict(self) -> dict:
3127+ result: dict = {}
3128+ return result
3129+
3130+
3131+@dataclass
3132+class For:
3133+ pass
3134+
3135+ @staticmethod
3136+ def from_dict(obj: Any) -> 'For':
3137+ assert isinstance(obj, dict)
3138+ return For()
3139+
3140+ def to_dict(self) -> dict:
3141+ result: dict = {}
3142+ return result
3143+
3144+
3145+@dataclass
3146+class From:
3147+ pass
3148+
3149+ @staticmethod
3150+ def from_dict(obj: Any) -> 'From':
3151+ assert isinstance(obj, dict)
3152+ return From()
3153+
3154+ def to_dict(self) -> dict:
3155+ result: dict = {}
3156+ return result
3157+
3158+
3159+@dataclass
3160+class Global:
3161+ pass
3162+
3163+ @staticmethod
3164+ def from_dict(obj: Any) -> 'Global':
3165+ assert isinstance(obj, dict)
3166+ return Global()
3167+
3168+ def to_dict(self) -> dict:
3169+ result: dict = {}
3170+ return result
3171+
3172+
3173+@dataclass
3174+class If:
3175+ pass
3176+
3177+ @staticmethod
3178+ def from_dict(obj: Any) -> 'If':
3179+ assert isinstance(obj, dict)
3180+ return If()
3181+
3182+ def to_dict(self) -> dict:
3183+ result: dict = {}
3184+ return result
3185+
3186+
3187+@dataclass
3188+class Import:
3189+ pass
3190+
3191+ @staticmethod
3192+ def from_dict(obj: Any) -> 'Import':
3193+ assert isinstance(obj, dict)
3194+ return Import()
3195+
3196+ def to_dict(self) -> dict:
3197+ result: dict = {}
3198+ return result
3199+
3200+
3201+@dataclass
3202+class In:
3203+ pass
3204+
3205+ @staticmethod
3206+ def from_dict(obj: Any) -> 'In':
3207+ assert isinstance(obj, dict)
3208+ return In()
3209+
3210+ def to_dict(self) -> dict:
3211+ result: dict = {}
3212+ return result
3213+
3214+
3215+@dataclass
3216+class Int:
3217+ pass
3218+
3219+ @staticmethod
3220+ def from_dict(obj: Any) -> 'Int':
3221+ assert isinstance(obj, dict)
3222+ return Int()
3223+
3224+ def to_dict(self) -> dict:
3225+ result: dict = {}
3226+ return result
3227+
3228+
3229+@dataclass
3230+class Is:
3231+ pass
3232+
3233+ @staticmethod
3234+ def from_dict(obj: Any) -> 'Is':
3235+ assert isinstance(obj, dict)
3236+ return Is()
3237+
3238+ def to_dict(self) -> dict:
3239+ result: dict = {}
3240+ return result
3241+
3242+
3243+@dataclass
3244+class Lambda:
3245+ pass
3246+
3247+ @staticmethod
3248+ def from_dict(obj: Any) -> 'Lambda':
3249+ assert isinstance(obj, dict)
3250+ return Lambda()
3251+
3252+ def to_dict(self) -> dict:
3253+ result: dict = {}
3254+ return result
3255+
3256+
3257+@dataclass
3258+class UnionNoneNone:
3259+ pass
3260+
3261+ @staticmethod
3262+ def from_dict(obj: Any) -> 'UnionNoneNone':
3263+ assert isinstance(obj, dict)
3264+ return UnionNoneNone()
3265+
3266+ def to_dict(self) -> dict:
3267+ result: dict = {}
3268+ return result
3269+
3270+
3271+@dataclass
3272+class Nonlocal:
3273+ pass
3274+
3275+ @staticmethod
3276+ def from_dict(obj: Any) -> 'Nonlocal':
3277+ assert isinstance(obj, dict)
3278+ return Nonlocal()
3279+
3280+ def to_dict(self) -> dict:
3281+ result: dict = {}
3282+ return result
3283+
3284+
3285+@dataclass
3286+class Not:
3287+ pass
3288+
3289+ @staticmethod
3290+ def from_dict(obj: Any) -> 'Not':
3291+ assert isinstance(obj, dict)
3292+ return Not()
3293+
3294+ def to_dict(self) -> dict:
3295+ result: dict = {}
3296+ return result
3297+
3298+
3299+@dataclass
3300+class NullClass:
3301+ pass
3302+
3303+ @staticmethod
3304+ def from_dict(obj: Any) -> 'NullClass':
3305+ assert isinstance(obj, dict)
3306+ return NullClass()
3307+
3308+ def to_dict(self) -> dict:
3309+ result: dict = {}
3310+ return result
3311+
3312+
3313+@dataclass
3314+class Or:
3315+ pass
3316+
3317+ @staticmethod
3318+ def from_dict(obj: Any) -> 'Or':
3319+ assert isinstance(obj, dict)
3320+ return Or()
3321+
3322+ def to_dict(self) -> dict:
3323+ result: dict = {}
3324+ return result
3325+
3326+
3327+@dataclass
3328+class Pass:
3329+ pass
3330+
3331+ @staticmethod
3332+ def from_dict(obj: Any) -> 'Pass':
3333+ assert isinstance(obj, dict)
3334+ return Pass()
3335+
3336+ def to_dict(self) -> dict:
3337+ result: dict = {}
3338+ return result
3339+
3340+
3341+@dataclass
3342+class Print:
3343+ pass
3344+
3345+ @staticmethod
3346+ def from_dict(obj: Any) -> 'Print':
3347+ assert isinstance(obj, dict)
3348+ return Print()
3349+
3350+ def to_dict(self) -> dict:
3351+ result: dict = {}
3352+ return result
3353+
3354+
3355+@dataclass
3356+class ProtocolClass:
3357+ pass
3358+
3359+ @staticmethod
3360+ def from_dict(obj: Any) -> 'ProtocolClass':
3361+ assert isinstance(obj, dict)
3362+ return ProtocolClass()
3363+
3364+ def to_dict(self) -> dict:
3365+ result: dict = {}
3366+ return result
3367+
3368+
3369+@dataclass
3370+class Raise:
3371+ pass
3372+
3373+ @staticmethod
3374+ def from_dict(obj: Any) -> 'Raise':
3375+ assert isinstance(obj, dict)
3376+ return Raise()
3377+
3378+ def to_dict(self) -> dict:
3379+ result: dict = {}
3380+ return result
3381+
3382+
3383+@dataclass
3384+class Return:
3385+ pass
3386+
3387+ @staticmethod
3388+ def from_dict(obj: Any) -> 'Return':
3389+ assert isinstance(obj, dict)
3390+ return Return()
3391+
3392+ def to_dict(self) -> dict:
3393+ result: dict = {}
3394+ return result
3395+
3396+
3397+@dataclass
3398+class Self:
3399+ pass
3400+
3401+ @staticmethod
3402+ def from_dict(obj: Any) -> 'Self':
3403+ assert isinstance(obj, dict)
3404+ return Self()
3405+
3406+ def to_dict(self) -> dict:
3407+ result: dict = {}
3408+ return result
3409+
3410+
3411+@dataclass
3412+class UnionTrueTrue:
3413+ pass
3414+
3415+ @staticmethod
3416+ def from_dict(obj: Any) -> 'UnionTrueTrue':
3417+ assert isinstance(obj, dict)
3418+ return UnionTrueTrue()
3419+
3420+ def to_dict(self) -> dict:
3421+ result: dict = {}
3422+ return result
3423+
3424+
3425+@dataclass
3426+class Try:
3427+ pass
3428+
3429+ @staticmethod
3430+ def from_dict(obj: Any) -> 'Try':
3431+ assert isinstance(obj, dict)
3432+ return Try()
3433+
3434+ def to_dict(self) -> dict:
3435+ result: dict = {}
3436+ return result
3437+
3438+
3439+@dataclass
3440+class UnionTypeType:
3441+ pass
3442+
3443+ @staticmethod
3444+ def from_dict(obj: Any) -> 'UnionTypeType':
3445+ assert isinstance(obj, dict)
3446+ return UnionTypeType()
3447+
3448+ def to_dict(self) -> dict:
3449+ result: dict = {}
3450+ return result
3451+
3452+
3453+@dataclass
3454+class While:
3455+ pass
3456+
3457+ @staticmethod
3458+ def from_dict(obj: Any) -> 'While':
3459+ assert isinstance(obj, dict)
3460+ return While()
3461+
3462+ def to_dict(self) -> dict:
3463+ result: dict = {}
3464+ return result
3465+
3466+
3467+@dataclass
3468+class With:
3469+ pass
3470+
3471+ @staticmethod
3472+ def from_dict(obj: Any) -> 'With':
3473+ assert isinstance(obj, dict)
3474+ return With()
3475+
3476+ def to_dict(self) -> dict:
3477+ result: dict = {}
3478+ return result
3479+
3480+
3481+@dataclass
3482+class Yield:
3483+ pass
3484+
3485+ @staticmethod
3486+ def from_dict(obj: Any) -> 'Yield':
3487+ assert isinstance(obj, dict)
3488+ return Yield()
3489+
3490+ def to_dict(self) -> dict:
3491+ result: dict = {}
3492+ return result
3493+
3494+
3495+@dataclass
3496+class Transient:
3497+ pass
3498+
3499+ @staticmethod
3500+ def from_dict(obj: Any) -> 'Transient':
3501+ assert isinstance(obj, dict)
3502+ return Transient()
3503+
3504+ def to_dict(self) -> dict:
3505+ result: dict = {}
3506+ return result
3507+
3508+
3509+@dataclass
3510+class TrueClass:
3511+ pass
3512+
3513+ @staticmethod
3514+ def from_dict(obj: Any) -> 'TrueClass':
3515+ assert isinstance(obj, dict)
3516+ return TrueClass()
3517+
3518+ def to_dict(self) -> dict:
3519+ result: dict = {}
3520+ return result
3521+
3522+
3523+@dataclass
3524+class TypeClass:
3525+ pass
3526+
3527+ @staticmethod
3528+ def from_dict(obj: Any) -> 'TypeClass':
3529+ assert isinstance(obj, dict)
3530+ return TypeClass()
3531+
3532+ def to_dict(self) -> dict:
3533+ result: dict = {}
3534+ return result
3535+
3536+
3537+@dataclass
3538+class Typealias:
3539+ pass
3540+
3541+ @staticmethod
3542+ def from_dict(obj: Any) -> 'Typealias':
3543+ assert isinstance(obj, dict)
3544+ return Typealias()
3545+
3546+ def to_dict(self) -> dict:
3547+ result: dict = {}
3548+ return result
3549+
3550+
3551+@dataclass
3552+class Typedef:
3553+ pass
3554+
3555+ @staticmethod
3556+ def from_dict(obj: Any) -> 'Typedef':
3557+ assert isinstance(obj, dict)
3558+ return Typedef()
3559+
3560+ def to_dict(self) -> dict:
3561+ result: dict = {}
3562+ return result
3563+
3564+
3565+@dataclass
3566+class Typeid:
3567+ pass
3568+
3569+ @staticmethod
3570+ def from_dict(obj: Any) -> 'Typeid':
3571+ assert isinstance(obj, dict)
3572+ return Typeid()
3573+
3574+ def to_dict(self) -> dict:
3575+ result: dict = {}
3576+ return result
3577+
3578+
3579+@dataclass
3580+class Typename:
3581+ pass
3582+
3583+ @staticmethod
3584+ def from_dict(obj: Any) -> 'Typename':
3585+ assert isinstance(obj, dict)
3586+ return Typename()
3587+
3588+ def to_dict(self) -> dict:
3589+ result: dict = {}
3590+ return result
3591+
3592+
3593+@dataclass
3594+class Typeof:
3595+ pass
3596+
3597+ @staticmethod
3598+ def from_dict(obj: Any) -> 'Typeof':
3599+ assert isinstance(obj, dict)
3600+ return Typeof()
3601+
3602+ def to_dict(self) -> dict:
3603+ result: dict = {}
3604+ return result
3605+
3606+
3607+@dataclass
3608+class Uint:
3609+ pass
3610+
3611+ @staticmethod
3612+ def from_dict(obj: Any) -> 'Uint':
3613+ assert isinstance(obj, dict)
3614+ return Uint()
3615+
3616+ def to_dict(self) -> dict:
3617+ result: dict = {}
3618+ return result
3619+
3620+
3621+@dataclass
3622+class Ulong:
3623+ pass
3624+
3625+ @staticmethod
3626+ def from_dict(obj: Any) -> 'Ulong':
3627+ assert isinstance(obj, dict)
3628+ return Ulong()
3629+
3630+ def to_dict(self) -> dict:
3631+ result: dict = {}
3632+ return result
3633+
3634+
3635+@dataclass
3636+class Unchecked:
3637+ pass
3638+
3639+ @staticmethod
3640+ def from_dict(obj: Any) -> 'Unchecked':
3641+ assert isinstance(obj, dict)
3642+ return Unchecked()
3643+
3644+ def to_dict(self) -> dict:
3645+ result: dict = {}
3646+ return result
3647+
3648+
3649+@dataclass
3650+class Undefined:
3651+ pass
3652+
3653+ @staticmethod
3654+ def from_dict(obj: Any) -> 'Undefined':
3655+ assert isinstance(obj, dict)
3656+ return Undefined()
3657+
3658+ def to_dict(self) -> dict:
3659+ result: dict = {}
3660+ return result
3661+
3662+
3663+@dataclass
3664+class UnionClass:
3665+ pass
3666+
3667+ @staticmethod
3668+ def from_dict(obj: Any) -> 'UnionClass':
3669+ assert isinstance(obj, dict)
3670+ return UnionClass()
3671+
3672+ def to_dict(self) -> dict:
3673+ result: dict = {}
3674+ return result
3675+
3676+
3677+@dataclass
3678+class Unowned:
3679+ pass
3680+
3681+ @staticmethod
3682+ def from_dict(obj: Any) -> 'Unowned':
3683+ assert isinstance(obj, dict)
3684+ return Unowned()
3685+
3686+ def to_dict(self) -> dict:
3687+ result: dict = {}
3688+ return result
3689+
3690+
3691+@dataclass
3692+class Unsafe:
3693+ pass
3694+
3695+ @staticmethod
3696+ def from_dict(obj: Any) -> 'Unsafe':
3697+ assert isinstance(obj, dict)
3698+ return Unsafe()
3699+
3700+ def to_dict(self) -> dict:
3701+ result: dict = {}
3702+ return result
3703+
3704+
3705+@dataclass
3706+class Unsigned:
3707+ pass
3708+
3709+ @staticmethod
3710+ def from_dict(obj: Any) -> 'Unsigned':
3711+ assert isinstance(obj, dict)
3712+ return Unsigned()
3713+
3714+ def to_dict(self) -> dict:
3715+ result: dict = {}
3716+ return result
3717+
3718+
3719+@dataclass
3720+class Ushort:
3721+ pass
3722+
3723+ @staticmethod
3724+ def from_dict(obj: Any) -> 'Ushort':
3725+ assert isinstance(obj, dict)
3726+ return Ushort()
3727+
3728+ def to_dict(self) -> dict:
3729+ result: dict = {}
3730+ return result
3731+
3732+
3733+@dataclass
3734+class Using:
3735+ pass
3736+
3737+ @staticmethod
3738+ def from_dict(obj: Any) -> 'Using':
3739+ assert isinstance(obj, dict)
3740+ return Using()
3741+
3742+ def to_dict(self) -> dict:
3743+ result: dict = {}
3744+ return result
3745+
3746+
3747+@dataclass
3748+class Var:
3749+ pass
3750+
3751+ @staticmethod
3752+ def from_dict(obj: Any) -> 'Var':
3753+ assert isinstance(obj, dict)
3754+ return Var()
3755+
3756+ def to_dict(self) -> dict:
3757+ result: dict = {}
3758+ return result
3759+
3760+
3761+@dataclass
3762+class Virtual:
3763+ pass
3764+
3765+ @staticmethod
3766+ def from_dict(obj: Any) -> 'Virtual':
3767+ assert isinstance(obj, dict)
3768+ return Virtual()
3769+
3770+ def to_dict(self) -> dict:
3771+ result: dict = {}
3772+ return result
3773+
3774+
3775+@dataclass
3776+class Void:
3777+ pass
3778+
3779+ @staticmethod
3780+ def from_dict(obj: Any) -> 'Void':
3781+ assert isinstance(obj, dict)
3782+ return Void()
3783+
3784+ def to_dict(self) -> dict:
3785+ result: dict = {}
3786+ return result
3787+
3788+
3789+@dataclass
3790+class Volatile:
3791+ pass
3792+
3793+ @staticmethod
3794+ def from_dict(obj: Any) -> 'Volatile':
3795+ assert isinstance(obj, dict)
3796+ return Volatile()
3797+
3798+ def to_dict(self) -> dict:
3799+ result: dict = {}
3800+ return result
3801+
3802+
3803+@dataclass
3804+class WcharT:
3805+ pass
3806+
3807+ @staticmethod
3808+ def from_dict(obj: Any) -> 'WcharT':
3809+ assert isinstance(obj, dict)
3810+ return WcharT()
3811+
3812+ def to_dict(self) -> dict:
3813+ result: dict = {}
3814+ return result
3815+
3816+
3817+@dataclass
3818+class Weak:
3819+ pass
3820+
3821+ @staticmethod
3822+ def from_dict(obj: Any) -> 'Weak':
3823+ assert isinstance(obj, dict)
3824+ return Weak()
3825+
3826+ def to_dict(self) -> dict:
3827+ result: dict = {}
3828+ return result
3829+
3830+
3831+@dataclass
3832+class Where:
3833+ pass
3834+
3835+ @staticmethod
3836+ def from_dict(obj: Any) -> 'Where':
3837+ assert isinstance(obj, dict)
3838+ return Where()
3839+
3840+ def to_dict(self) -> dict:
3841+ result: dict = {}
3842+ return result
3843+
3844+
3845+@dataclass
3846+class WillSet:
3847+ pass
3848+
3849+ @staticmethod
3850+ def from_dict(obj: Any) -> 'WillSet':
3851+ assert isinstance(obj, dict)
3852+ return WillSet()
3853+
3854+ def to_dict(self) -> dict:
3855+ result: dict = {}
3856+ return result
3857+
3858+
3859+@dataclass
3860+class Xor:
3861+ pass
3862+
3863+ @staticmethod
3864+ def from_dict(obj: Any) -> 'Xor':
3865+ assert isinstance(obj, dict)
3866+ return Xor()
3867+
3868+ def to_dict(self) -> dict:
3869+ result: dict = {}
3870+ return result
3871+
3872+
3873+@dataclass
3874+class XorEq:
3875+ pass
3876+
3877+ @staticmethod
3878+ def from_dict(obj: Any) -> 'XorEq':
3879+ assert isinstance(obj, dict)
3880+ return XorEq()
3881+
3882+ def to_dict(self) -> dict:
3883+ result: dict = {}
3884+ return result
3885+
3886+
3887+@dataclass
3888+class Yes:
3889+ pass
3890+
3891+ @staticmethod
3892+ def from_dict(obj: Any) -> 'Yes':
3893+ assert isinstance(obj, dict)
3894+ return Yes()
3895+
3896+ def to_dict(self) -> dict:
3897+ result: dict = {}
3898+ return result
3899+
3900+
3901+@dataclass
3902+class TopLevel:
3903+ empty: float | Empty | None = None
3904+ purple_bool: float | BoolClass | None = None
3905+ complex: float | Complex | None = None
3906+ imaginery: float | Imaginery | None = None
3907+ abstract: float | Abstract | None = None
3908+ alignas: float | Alignas | None = None
3909+ alignof: float | Alignof | None = None
3910+ top_level_and: float | And | None = None
3911+ and_eq: float | AndEq | None = None
3912+ top_level_any: float | UnionAnyAny | None = None
3913+ any: float | AnyClass | None = None
3914+ array: float | Array | None = None
3915+ top_level_as: float | As | None = None
3916+ asm: float | ASM | None = None
3917+ top_level_assert: float | Assert | None = None
3918+ associatedtype: float | Associatedtype | None = None
3919+ associativity: float | Associativity | None = None
3920+ top_level_async: float | Async | None = None
3921+ atomic: float | Atomic | None = None
3922+ atomic_cancel: float | AtomicCancel | None = None
3923+ atomic_commit: float | AtomicCommit | None = None
3924+ atomic_noexcept: float | AtomicNoexcept | None = None
3925+ auto: float | Auto | None = None
3926+ top_level_await: float | Await | None = None
3927+ base: float | Base | None = None
3928+ bitand: float | Bitand | None = None
3929+ bitor: float | Bitor | None = None
3930+ top_level_bool: float | Bool | None = None
3931+ fluffy_bool: float | UnionBoolBool | None = None
3932+ boolean: float | Boolean | None = None
3933+ top_level_break: float | Break | None = None
3934+ bycopy: float | Bycopy | None = None
3935+ byref: float | Byref | None = None
3936+ byte: float | Byte | None = None
3937+ case: float | Case | None = None
3938+ catch: float | Catch | None = None
3939+ chan: float | Chan | None = None
3940+ char: float | Char | None = None
3941+ char16_t: float | Char16T | None = None
3942+ char32_t: float | Char32T | None = None
3943+ checked: float | Checked | None = None
3944+ purple_class: float | ClassClass | None = None
3945+ top_level_class: float | Class | None = None
3946+ co_await: float | CoAwait | None = None
3947+ co_return: float | CoReturn | None = None
3948+ co_yield: float | CoYield | None = None
3949+ compl: float | Compl | None = None
3950+ concept: float | Concept | None = None
3951+ console: float | Console | None = None
3952+ const: float | Const | None = None
3953+ const_cast: float | ConstCast | None = None
3954+ constexpr: float | Constexpr | None = None
3955+ constructor: float | Constructor | None = None
3956+ top_level_continue: float | Continue | None = None
3957+ convenience: float | Convenience | None = None
3958+ convert: float | Convert | None = None
3959+ converter: float | Converter | None = None
3960+ date: float | Date | None = None
3961+ date_parse_handling: float | DateParseHandling | None = None
3962+ debugger: float | Debugger | None = None
3963+ decimal: float | Decimal | None = None
3964+ declare: float | Declare | None = None
3965+ decltype: float | Decltype | None = None
3966+ decode_string: float | DecodeString | None = None
3967+ top_level_def: float | Def | None = None
3968+ default: float | Default | None = None
3969+ defer: float | Defer | None = None
3970+ deinit: float | Deinit | None = None
3971+ top_level_del: float | Del | None = None
3972+ delegate: float | Delegate | None = None
3973+ delete: float | Delete | None = None
3974+ top_level_dict: float | DictClass | None = None
3975+ dictionary: float | Dictionary | None = None
3976+ did_set: float | DidSet | None = None
3977+ do: float | Do | None = None
3978+ double: float | Double | None = None
3979+ dummy: float | None = None
3980+ dynamic: float | Dynamic | None = None
3981+ dynamic_cast: float | DynamicCast | None = None
3982+ top_level_elif: float | Elif | None = None
3983+ top_level_else: float | Else | None = None
3984+ encode_quick_type: float | EncodeQuickType | None = None
3985+ enum: float | EnumClass | None = None
3986+ event: float | Event | None = None
3987+ top_level_except: float | Except | None = None
3988+ exception: float | Exception | None = None
3989+ explicit: float | Explicit | None = None
3990+ export: float | Export | None = None
3991+ exposing: float | Exposing | None = None
3992+ extends: float | Extends | None = None
3993+ extension: float | Extension | None = None
3994+ extern: float | Extern | None = None
3995+ fallthrough: float | Fallthrough | None = None
3996+ top_level_false: float | UnionFalseFalse | None = None
3997+ false: float | FalseClass | None = None
3998+ fileprivate: float | Fileprivate | None = None
3999+ final: float | Final | None = None
4000+ top_level_finally: float | Finally | None = None
4001+ fixed: float | Fixed | None = None
4002+ top_level_float: float | Float | None = None
4003+ top_level_for: float | For | None = None
4004+ foreach: float | Foreach | None = None
4005+ friend: float | Friend | None = None
4006+ top_level_from: float | From | None = None
4007+ from_json: float | FromJSON | None = None
4008+ func: float | Func | None = None
4009+ function: float | Function | None = None
4010+ get: float | Get | None = None
4011+ top_level_global: float | Global | None = None
4012+ go: float | Go | None = None
4013+ goto: float | Goto | None = None
4014+ guard: float | Guard | None = None
4015+ has_own_property: float | HasOwnProperty | None = None
4016+ id: float | ID | None = None
4017+ top_level_if: float | If | None = None
4018+ imp: float | Imp | None = None
4019+ implements: float | Implements | None = None
4020+ implicit: float | Implicit | None = None
4021+ top_level_import: float | Import | None = None
4022+ top_level_in: float | In | None = None
4023+ indirect: float | Indirect | None = None
4024+ infix: float | Infix | None = None
4025+ init: float | Init | None = None
4026+ inline: float | Inline | None = None
4027+ inout: float | Inout | None = None
4028+ instanceof: float | Instanceof | None = None
4029+ top_level_int: float | Int | None = None
4030+ interface: float | Interface | None = None
4031+ internal: float | Internal | None = None
4032+ top_level_is: float | Is | None = None
4033+ iterable: float | IterableClass | None = None
4034+ jdec: float | Jdec | None = None
4035+ jenc: float | Jenc | None = None
4036+ jpipe: float | Jpipe | None = None
4037+ json: float | JSON | None = None
4038+ json_converter: float | JSONConverter | None = None
4039+ json_serializer: float | JSONSerializer | None = None
4040+ json_token: float | JSONToken | None = None
4041+ json_writer: float | JSONWriter | None = None
4042+ top_level_lambda: float | Lambda | None = None
4043+ lazy: float | Lazy | None = None
4044+ left: float | Left | None = None
4045+ let: float | Let | None = None
4046+ list: float | ListClass | None = None
4047+ lock: float | Lock | None = None
4048+ long: float | Long | None = None
4049+ map: float | Map | None = None
4050+ metadata_property_handling: float | MetadataPropertyHandling | None = None
4051+ module: float | Module | None = None
4052+ mutable: float | Mutable | None = None
4053+ mutating: float | Mutating | None = None
4054+ namespace: float | Namespace | None = None
4055+ native: float | Native | None = None
4056+ new: float | New | None = None
4057+ newtonsoft: float | Newtonsoft | None = None
4058+ nil: float | Nil | None = None
4059+ no: float | No | None = None
4060+ noexcept: float | Noexcept | None = None
4061+ nonatomic: float | Nonatomic | None = None
4062+ top_level_none: float | UnionNoneNone | None = None
4063+ none: float | NoneClass | None = None
4064+ top_level_nonlocal: float | Nonlocal | None = None
4065+ nonmutating: float | Nonmutating | None = None
4066+ top_level_not: float | Not | None = None
4067+ not_eq: float | NotEq | None = None
4068+ ns_string: float | NSString | None = None
4069+ null: float | Null | None = None
4070+ top_level_null: float | NullClass | None = None
4071+ nullptr: float | Nullptr | None = None
4072+ number: float | Number | None = None
4073+ object: float | Object | None = None
4074+ of: float | Of | None = None
4075+ oneway: float | Oneway | None = None
4076+ open: float | Open | None = None
4077+ operator: float | Operator | None = None
4078+ optional: float | OptionalClass | None = None
4079+ top_level_or: float | Or | None = None
4080+ or_eq: float | OrEq | None = None
4081+ out: float | Out | None = None
4082+ override: float | Override | None = None
4083+ package: float | Package | None = None
4084+ params: float | Params | None = None
4085+ top_level_pass: float | Pass | None = None
4086+ port: float | Port | None = None
4087+ postfix: float | Postfix | None = None
4088+ precedence: float | Precedence | None = None
4089+ prefix: float | Prefix | None = None
4090+ top_level_print: float | Print | None = None
4091+ printf: float | Printf | None = None
4092+ private: float | Private | None = None
4093+ protected: float | Protected | None = None
4094+ protocol: float | Protocol | None = None
4095+ top_level_protocol: float | ProtocolClass | None = None
4096+ public: float | Public | None = None
4097+ quicktype: float | Quicktype | None = None
4098+ top_level_raise: float | Raise | None = None
4099+ range: float | Range | None = None
4100+ readonly: float | Readonly | None = None
4101+ ref: float | Ref | None = None
4102+ register: float | Register | None = None
4103+ reinterpret_cast: float | ReinterpretCast | None = None
4104+ repeat: float | Repeat | None = None
4105+ require: float | Require | None = None
4106+ required: float | Required | None = None
4107+ requires: float | Requires | None = None
4108+ restrict: float | Restrict | None = None
4109+ retain: float | Retain | None = None
4110+ rethrows: float | Rethrows | None = None
4111+ top_level_return: float | Return | None = None
4112+ right: float | Right | None = None
4113+ sbyte: float | Sbyte | None = None
4114+ sealed: float | Sealed | None = None
4115+ sel: float | Sel | None = None
4116+ select: float | Select | None = None
4117+ top_level_self: float | Self | None = None
4118+ purple_self: float | SelfClass | None = None
4119+ serialize: float | Serialize | None = None
4120+ set: float | Set | None = None
4121+ short: float | Short | None = None
4122+ signed: float | Signed | None = None
4123+ sizeof: float | Sizeof | None = None
4124+ stackalloc: float | Stackalloc | None = None
4125+ static: float | Static | None = None
4126+ static_assert: float | StaticAssert | None = None
4127+ static_cast: float | StaticCast | None = None
4128+ strictfp: float | Strictfp | None = None
4129+ string: float | String | None = None
4130+ struct: float | Struct | None = None
4131+ subscript: float | Subscript | None = None
4132+ super: float | Super | None = None
4133+ switch: float | Switch | None = None
4134+ symbol: float | Symbol | None = None
4135+ synchronized: float | Synchronized | None = None
4136+ system: float | System | None = None
4137+ template: float | Template | None = None
4138+ then: float | Then | None = None
4139+ this: float | This | None = None
4140+ thread_local: float | ThreadLocal | None = None
4141+ throw: float | Throw | None = None
4142+ throws: float | Throws | None = None
4143+ to_json: float | ToJSON | None = None
4144+ top_level: float | TopLevelClass | None = None
4145+ transient: float | Transient | None = None
4146+ true: float | TrueClass | None = None
4147+ top_level_true: float | UnionTrueTrue | None = None
4148+ top_level_try: float | Try | None = None
4149+ type: float | TypeClass | None = None
4150+ top_level_type: float | UnionTypeType | None = None
4151+ typealias: float | Typealias | None = None
4152+ typedef: float | Typedef | None = None
4153+ typeid: float | Typeid | None = None
4154+ typename: float | Typename | None = None
4155+ typeof: float | Typeof | None = None
4156+ uint: float | Uint | None = None
4157+ ulong: float | Ulong | None = None
4158+ unchecked: float | Unchecked | None = None
4159+ undefined: float | Undefined | None = None
4160+ union: float | UnionClass | None = None
4161+ unowned: float | Unowned | None = None
4162+ unsafe: float | Unsafe | None = None
4163+ unsigned: float | Unsigned | None = None
4164+ ushort: float | Ushort | None = None
4165+ using: float | Using | None = None
4166+ var: float | Var | None = None
4167+ virtual: float | Virtual | None = None
4168+ void: float | Void | None = None
4169+ volatile: float | Volatile | None = None
4170+ wchar_t: float | WcharT | None = None
4171+ weak: float | Weak | None = None
4172+ where: float | Where | None = None
4173+ top_level_while: float | While | None = None
4174+ will_set: float | WillSet | None = None
4175+ top_level_with: float | With | None = None
4176+ xor: float | Xor | None = None
4177+ xor_eq: float | XorEq | None = None
4178+ yes: float | Yes | None = None
4179+ top_level_yield: float | Yield | None = None
4180+
4181+ @staticmethod
4182+ def from_dict(obj: Any) -> 'TopLevel':
4183+ assert isinstance(obj, dict)
4184+ empty = from_union([from_float, Empty.from_dict, from_none], obj.get("_"))
4185+ purple_bool = from_union([from_float, BoolClass.from_dict, from_none], obj.get("_Bool"))
4186+ complex = from_union([from_float, Complex.from_dict, from_none], obj.get("_Complex"))
4187+ imaginery = from_union([from_float, Imaginery.from_dict, from_none], obj.get("_Imaginery"))
4188+ abstract = from_union([from_float, Abstract.from_dict, from_none], obj.get("abstract"))
4189+ alignas = from_union([from_float, Alignas.from_dict, from_none], obj.get("alignas"))
4190+ alignof = from_union([from_float, Alignof.from_dict, from_none], obj.get("alignof"))
4191+ top_level_and = from_union([from_float, And.from_dict, from_none], obj.get("and"))
4192+ and_eq = from_union([from_float, AndEq.from_dict, from_none], obj.get("and_eq"))
4193+ top_level_any = from_union([from_float, UnionAnyAny.from_dict, from_none], obj.get("any"))
4194+ any = from_union([from_float, AnyClass.from_dict, from_none], obj.get("Any"))
4195+ array = from_union([from_float, Array.from_dict, from_none], obj.get("array"))
4196+ top_level_as = from_union([from_float, As.from_dict, from_none], obj.get("as"))
4197+ asm = from_union([from_float, ASM.from_dict, from_none], obj.get("asm"))
4198+ top_level_assert = from_union([from_float, Assert.from_dict, from_none], obj.get("assert"))
4199+ associatedtype = from_union([from_float, Associatedtype.from_dict, from_none], obj.get("associatedtype"))
4200+ associativity = from_union([from_float, Associativity.from_dict, from_none], obj.get("associativity"))
4201+ top_level_async = from_union([from_float, Async.from_dict, from_none], obj.get("async"))
4202+ atomic = from_union([from_float, Atomic.from_dict, from_none], obj.get("atomic"))
4203+ atomic_cancel = from_union([from_float, AtomicCancel.from_dict, from_none], obj.get("atomic_cancel"))
4204+ atomic_commit = from_union([from_float, AtomicCommit.from_dict, from_none], obj.get("atomic_commit"))
4205+ atomic_noexcept = from_union([from_float, AtomicNoexcept.from_dict, from_none], obj.get("atomic_noexcept"))
4206+ auto = from_union([from_float, Auto.from_dict, from_none], obj.get("auto"))
4207+ top_level_await = from_union([from_float, Await.from_dict, from_none], obj.get("await"))
4208+ base = from_union([from_float, Base.from_dict, from_none], obj.get("base"))
4209+ bitand = from_union([from_float, Bitand.from_dict, from_none], obj.get("bitand"))
4210+ bitor = from_union([from_float, Bitor.from_dict, from_none], obj.get("bitor"))
4211+ top_level_bool = from_union([from_float, Bool.from_dict, from_none], obj.get("BOOL"))
4212+ fluffy_bool = from_union([from_float, UnionBoolBool.from_dict, from_none], obj.get("bool"))
4213+ boolean = from_union([from_float, Boolean.from_dict, from_none], obj.get("boolean"))
4214+ top_level_break = from_union([from_float, Break.from_dict, from_none], obj.get("break"))
4215+ bycopy = from_union([from_float, Bycopy.from_dict, from_none], obj.get("bycopy"))
4216+ byref = from_union([from_float, Byref.from_dict, from_none], obj.get("byref"))
4217+ byte = from_union([from_float, Byte.from_dict, from_none], obj.get("byte"))
4218+ case = from_union([from_float, Case.from_dict, from_none], obj.get("case"))
4219+ catch = from_union([from_float, Catch.from_dict, from_none], obj.get("catch"))
4220+ chan = from_union([from_float, Chan.from_dict, from_none], obj.get("chan"))
4221+ char = from_union([from_float, Char.from_dict, from_none], obj.get("char"))
4222+ char16_t = from_union([from_float, Char16T.from_dict, from_none], obj.get("char16_t"))
4223+ char32_t = from_union([from_float, Char32T.from_dict, from_none], obj.get("char32_t"))
4224+ checked = from_union([from_float, Checked.from_dict, from_none], obj.get("checked"))
4225+ purple_class = from_union([from_float, ClassClass.from_dict, from_none], obj.get("class"))
4226+ top_level_class = from_union([from_float, Class.from_dict, from_none], obj.get("Class"))
4227+ co_await = from_union([from_float, CoAwait.from_dict, from_none], obj.get("co_await"))
4228+ co_return = from_union([from_float, CoReturn.from_dict, from_none], obj.get("co_return"))
4229+ co_yield = from_union([from_float, CoYield.from_dict, from_none], obj.get("co_yield"))
4230+ compl = from_union([from_float, Compl.from_dict, from_none], obj.get("compl"))
4231+ concept = from_union([from_float, Concept.from_dict, from_none], obj.get("concept"))
4232+ console = from_union([from_float, Console.from_dict, from_none], obj.get("console"))
4233+ const = from_union([from_float, Const.from_dict, from_none], obj.get("const"))
4234+ const_cast = from_union([from_float, ConstCast.from_dict, from_none], obj.get("const_cast"))
4235+ constexpr = from_union([from_float, Constexpr.from_dict, from_none], obj.get("constexpr"))
4236+ constructor = from_union([from_float, Constructor.from_dict, from_none], obj.get("constructor"))
4237+ top_level_continue = from_union([from_float, Continue.from_dict, from_none], obj.get("continue"))
4238+ convenience = from_union([from_float, Convenience.from_dict, from_none], obj.get("convenience"))
4239+ convert = from_union([from_float, Convert.from_dict, from_none], obj.get("convert"))
4240+ converter = from_union([from_float, Converter.from_dict, from_none], obj.get("converter"))
4241+ date = from_union([from_float, Date.from_dict, from_none], obj.get("date"))
4242+ date_parse_handling = from_union([from_float, DateParseHandling.from_dict, from_none], obj.get("date_parse_handling"))
4243+ debugger = from_union([from_float, Debugger.from_dict, from_none], obj.get("debugger"))
4244+ decimal = from_union([from_float, Decimal.from_dict, from_none], obj.get("decimal"))
4245+ declare = from_union([from_float, Declare.from_dict, from_none], obj.get("declare"))
4246+ decltype = from_union([from_float, Decltype.from_dict, from_none], obj.get("decltype"))
4247+ decode_string = from_union([from_float, DecodeString.from_dict, from_none], obj.get("decode_string"))
4248+ top_level_def = from_union([from_float, Def.from_dict, from_none], obj.get("def"))
4249+ default = from_union([from_float, Default.from_dict, from_none], obj.get("default"))
4250+ defer = from_union([from_float, Defer.from_dict, from_none], obj.get("defer"))
4251+ deinit = from_union([from_float, Deinit.from_dict, from_none], obj.get("deinit"))
4252+ top_level_del = from_union([from_float, Del.from_dict, from_none], obj.get("del"))
4253+ delegate = from_union([from_float, Delegate.from_dict, from_none], obj.get("delegate"))
4254+ delete = from_union([from_float, Delete.from_dict, from_none], obj.get("delete"))
4255+ top_level_dict = from_union([from_float, DictClass.from_dict, from_none], obj.get("dict"))
4256+ dictionary = from_union([from_float, Dictionary.from_dict, from_none], obj.get("dictionary"))
4257+ did_set = from_union([from_float, DidSet.from_dict, from_none], obj.get("didSet"))
4258+ do = from_union([from_float, Do.from_dict, from_none], obj.get("do"))
4259+ double = from_union([from_float, Double.from_dict, from_none], obj.get("double"))
4260+ dummy = from_union([from_float, from_none], obj.get("dummy"))
4261+ dynamic = from_union([from_float, Dynamic.from_dict, from_none], obj.get("dynamic"))
4262+ dynamic_cast = from_union([from_float, DynamicCast.from_dict, from_none], obj.get("dynamic_cast"))
4263+ top_level_elif = from_union([from_float, Elif.from_dict, from_none], obj.get("elif"))
4264+ top_level_else = from_union([from_float, Else.from_dict, from_none], obj.get("else"))
4265+ encode_quick_type = from_union([from_float, EncodeQuickType.from_dict, from_none], obj.get("encode_quick_type"))
4266+ enum = from_union([from_float, EnumClass.from_dict, from_none], obj.get("enum"))
4267+ event = from_union([from_float, Event.from_dict, from_none], obj.get("event"))
4268+ top_level_except = from_union([from_float, Except.from_dict, from_none], obj.get("except"))
4269+ exception = from_union([from_float, Exception.from_dict, from_none], obj.get("exception"))
4270+ explicit = from_union([from_float, Explicit.from_dict, from_none], obj.get("explicit"))
4271+ export = from_union([from_float, Export.from_dict, from_none], obj.get("export"))
4272+ exposing = from_union([from_float, Exposing.from_dict, from_none], obj.get("exposing"))
4273+ extends = from_union([from_float, Extends.from_dict, from_none], obj.get("extends"))
4274+ extension = from_union([from_float, Extension.from_dict, from_none], obj.get("extension"))
4275+ extern = from_union([from_float, Extern.from_dict, from_none], obj.get("extern"))
4276+ fallthrough = from_union([from_float, Fallthrough.from_dict, from_none], obj.get("fallthrough"))
4277+ top_level_false = from_union([from_float, UnionFalseFalse.from_dict, from_none], obj.get("false"))
4278+ false = from_union([from_float, FalseClass.from_dict, from_none], obj.get("False"))
4279+ fileprivate = from_union([from_float, Fileprivate.from_dict, from_none], obj.get("fileprivate"))
4280+ final = from_union([from_float, Final.from_dict, from_none], obj.get("final"))
4281+ top_level_finally = from_union([from_float, Finally.from_dict, from_none], obj.get("finally"))
4282+ fixed = from_union([from_float, Fixed.from_dict, from_none], obj.get("fixed"))
4283+ top_level_float = from_union([from_float, Float.from_dict, from_none], obj.get("float"))
4284+ top_level_for = from_union([from_float, For.from_dict, from_none], obj.get("for"))
4285+ foreach = from_union([from_float, Foreach.from_dict, from_none], obj.get("foreach"))
4286+ friend = from_union([from_float, Friend.from_dict, from_none], obj.get("friend"))
4287+ top_level_from = from_union([from_float, From.from_dict, from_none], obj.get("from"))
4288+ from_json = from_union([from_float, FromJSON.from_dict, from_none], obj.get("from_json"))
4289+ func = from_union([from_float, Func.from_dict, from_none], obj.get("func"))
4290+ function = from_union([from_float, Function.from_dict, from_none], obj.get("function"))
4291+ get = from_union([from_float, Get.from_dict, from_none], obj.get("get"))
4292+ top_level_global = from_union([from_float, Global.from_dict, from_none], obj.get("global"))
4293+ go = from_union([from_float, Go.from_dict, from_none], obj.get("go"))
4294+ goto = from_union([from_float, Goto.from_dict, from_none], obj.get("goto"))
4295+ guard = from_union([from_float, Guard.from_dict, from_none], obj.get("guard"))
4296+ has_own_property = from_union([from_float, HasOwnProperty.from_dict, from_none], obj.get("hasOwnProperty"))
4297+ id = from_union([from_float, ID.from_dict, from_none], obj.get("id"))
4298+ top_level_if = from_union([from_float, If.from_dict, from_none], obj.get("if"))
4299+ imp = from_union([from_float, Imp.from_dict, from_none], obj.get("IMP"))
4300+ implements = from_union([from_float, Implements.from_dict, from_none], obj.get("implements"))
4301+ implicit = from_union([from_float, Implicit.from_dict, from_none], obj.get("implicit"))
4302+ top_level_import = from_union([from_float, Import.from_dict, from_none], obj.get("import"))
4303+ top_level_in = from_union([from_float, In.from_dict, from_none], obj.get("in"))
4304+ indirect = from_union([from_float, Indirect.from_dict, from_none], obj.get("indirect"))
4305+ infix = from_union([from_float, Infix.from_dict, from_none], obj.get("infix"))
4306+ init = from_union([from_float, Init.from_dict, from_none], obj.get("init"))
4307+ inline = from_union([from_float, Inline.from_dict, from_none], obj.get("inline"))
4308+ inout = from_union([from_float, Inout.from_dict, from_none], obj.get("inout"))
4309+ instanceof = from_union([from_float, Instanceof.from_dict, from_none], obj.get("instanceof"))
4310+ top_level_int = from_union([from_float, Int.from_dict, from_none], obj.get("int"))
4311+ interface = from_union([from_float, Interface.from_dict, from_none], obj.get("interface"))
4312+ internal = from_union([from_float, Internal.from_dict, from_none], obj.get("internal"))
4313+ top_level_is = from_union([from_float, Is.from_dict, from_none], obj.get("is"))
4314+ iterable = from_union([from_float, IterableClass.from_dict, from_none], obj.get("iterable"))
4315+ jdec = from_union([from_float, Jdec.from_dict, from_none], obj.get("jdec"))
4316+ jenc = from_union([from_float, Jenc.from_dict, from_none], obj.get("jenc"))
4317+ jpipe = from_union([from_float, Jpipe.from_dict, from_none], obj.get("jpipe"))
4318+ json = from_union([from_float, JSON.from_dict, from_none], obj.get("json"))
4319+ json_converter = from_union([from_float, JSONConverter.from_dict, from_none], obj.get("json_converter"))
4320+ json_serializer = from_union([from_float, JSONSerializer.from_dict, from_none], obj.get("json_serializer"))
4321+ json_token = from_union([from_float, JSONToken.from_dict, from_none], obj.get("json_token"))
4322+ json_writer = from_union([from_float, JSONWriter.from_dict, from_none], obj.get("json_writer"))
4323+ top_level_lambda = from_union([from_float, Lambda.from_dict, from_none], obj.get("lambda"))
4324+ lazy = from_union([from_float, Lazy.from_dict, from_none], obj.get("lazy"))
4325+ left = from_union([from_float, Left.from_dict, from_none], obj.get("left"))
4326+ let = from_union([from_float, Let.from_dict, from_none], obj.get("let"))
4327+ list = from_union([from_float, ListClass.from_dict, from_none], obj.get("list"))
4328+ lock = from_union([from_float, Lock.from_dict, from_none], obj.get("lock"))
4329+ long = from_union([from_float, Long.from_dict, from_none], obj.get("long"))
4330+ map = from_union([from_float, Map.from_dict, from_none], obj.get("map"))
4331+ metadata_property_handling = from_union([from_float, MetadataPropertyHandling.from_dict, from_none], obj.get("metadata_property_handling"))
4332+ module = from_union([from_float, Module.from_dict, from_none], obj.get("module"))
4333+ mutable = from_union([from_float, Mutable.from_dict, from_none], obj.get("mutable"))
4334+ mutating = from_union([from_float, Mutating.from_dict, from_none], obj.get("mutating"))
4335+ namespace = from_union([from_float, Namespace.from_dict, from_none], obj.get("namespace"))
4336+ native = from_union([from_float, Native.from_dict, from_none], obj.get("native"))
4337+ new = from_union([from_float, New.from_dict, from_none], obj.get("new"))
4338+ newtonsoft = from_union([from_float, Newtonsoft.from_dict, from_none], obj.get("newtonsoft"))
4339+ nil = from_union([from_float, Nil.from_dict, from_none], obj.get("nil"))
4340+ no = from_union([from_float, No.from_dict, from_none], obj.get("NO"))
4341+ noexcept = from_union([from_float, Noexcept.from_dict, from_none], obj.get("noexcept"))
4342+ nonatomic = from_union([from_float, Nonatomic.from_dict, from_none], obj.get("nonatomic"))
4343+ top_level_none = from_union([from_float, UnionNoneNone.from_dict, from_none], obj.get("none"))
4344+ none = from_union([from_float, NoneClass.from_dict, from_none], obj.get("None"))
4345+ top_level_nonlocal = from_union([from_float, Nonlocal.from_dict, from_none], obj.get("nonlocal"))
4346+ nonmutating = from_union([from_float, Nonmutating.from_dict, from_none], obj.get("nonmutating"))
4347+ top_level_not = from_union([from_float, Not.from_dict, from_none], obj.get("not"))
4348+ not_eq = from_union([from_float, NotEq.from_dict, from_none], obj.get("not_eq"))
4349+ ns_string = from_union([from_float, NSString.from_dict, from_none], obj.get("NSString"))
4350+ null = from_union([from_float, Null.from_dict, from_none], obj.get("NULL"))
4351+ top_level_null = from_union([from_float, NullClass.from_dict, from_none], obj.get("null"))
4352+ nullptr = from_union([from_float, Nullptr.from_dict, from_none], obj.get("nullptr"))
4353+ number = from_union([from_float, Number.from_dict, from_none], obj.get("number"))
4354+ object = from_union([from_float, Object.from_dict, from_none], obj.get("object"))
4355+ of = from_union([from_float, Of.from_dict, from_none], obj.get("of"))
4356+ oneway = from_union([from_float, Oneway.from_dict, from_none], obj.get("oneway"))
4357+ open = from_union([from_float, Open.from_dict, from_none], obj.get("open"))
4358+ operator = from_union([from_float, Operator.from_dict, from_none], obj.get("operator"))
4359+ optional = from_union([from_float, OptionalClass.from_dict, from_none], obj.get("optional"))
4360+ top_level_or = from_union([from_float, Or.from_dict, from_none], obj.get("or"))
4361+ or_eq = from_union([from_float, OrEq.from_dict, from_none], obj.get("or_eq"))
4362+ out = from_union([from_float, Out.from_dict, from_none], obj.get("out"))
4363+ override = from_union([from_float, Override.from_dict, from_none], obj.get("override"))
4364+ package = from_union([from_float, Package.from_dict, from_none], obj.get("package"))
4365+ params = from_union([from_float, Params.from_dict, from_none], obj.get("params"))
4366+ top_level_pass = from_union([from_float, Pass.from_dict, from_none], obj.get("pass"))
4367+ port = from_union([from_float, Port.from_dict, from_none], obj.get("port"))
4368+ postfix = from_union([from_float, Postfix.from_dict, from_none], obj.get("postfix"))
4369+ precedence = from_union([from_float, Precedence.from_dict, from_none], obj.get("precedence"))
4370+ prefix = from_union([from_float, Prefix.from_dict, from_none], obj.get("prefix"))
4371+ top_level_print = from_union([from_float, Print.from_dict, from_none], obj.get("print"))
4372+ printf = from_union([from_float, Printf.from_dict, from_none], obj.get("printf"))
4373+ private = from_union([from_float, Private.from_dict, from_none], obj.get("private"))
4374+ protected = from_union([from_float, Protected.from_dict, from_none], obj.get("protected"))
4375+ protocol = from_union([from_float, Protocol.from_dict, from_none], obj.get("Protocol"))
4376+ top_level_protocol = from_union([from_float, ProtocolClass.from_dict, from_none], obj.get("protocol"))
4377+ public = from_union([from_float, Public.from_dict, from_none], obj.get("public"))
4378+ quicktype = from_union([from_float, Quicktype.from_dict, from_none], obj.get("quicktype"))
4379+ top_level_raise = from_union([from_float, Raise.from_dict, from_none], obj.get("raise"))
4380+ range = from_union([from_float, Range.from_dict, from_none], obj.get("range"))
4381+ readonly = from_union([from_float, Readonly.from_dict, from_none], obj.get("readonly"))
4382+ ref = from_union([from_float, Ref.from_dict, from_none], obj.get("ref"))
4383+ register = from_union([from_float, Register.from_dict, from_none], obj.get("register"))
4384+ reinterpret_cast = from_union([from_float, ReinterpretCast.from_dict, from_none], obj.get("reinterpret_cast"))
4385+ repeat = from_union([from_float, Repeat.from_dict, from_none], obj.get("repeat"))
4386+ require = from_union([from_float, Require.from_dict, from_none], obj.get("require"))
4387+ required = from_union([from_float, Required.from_dict, from_none], obj.get("required"))
4388+ requires = from_union([from_float, Requires.from_dict, from_none], obj.get("requires"))
4389+ restrict = from_union([from_float, Restrict.from_dict, from_none], obj.get("restrict"))
4390+ retain = from_union([from_float, Retain.from_dict, from_none], obj.get("retain"))
4391+ rethrows = from_union([from_float, Rethrows.from_dict, from_none], obj.get("rethrows"))
4392+ top_level_return = from_union([from_float, Return.from_dict, from_none], obj.get("return"))
4393+ right = from_union([from_float, Right.from_dict, from_none], obj.get("right"))
4394+ sbyte = from_union([from_float, Sbyte.from_dict, from_none], obj.get("sbyte"))
4395+ sealed = from_union([from_float, Sealed.from_dict, from_none], obj.get("sealed"))
4396+ sel = from_union([from_float, Sel.from_dict, from_none], obj.get("SEL"))
4397+ select = from_union([from_float, Select.from_dict, from_none], obj.get("select"))
4398+ top_level_self = from_union([from_float, Self.from_dict, from_none], obj.get("Self"))
4399+ purple_self = from_union([from_float, SelfClass.from_dict, from_none], obj.get("self"))
4400+ serialize = from_union([from_float, Serialize.from_dict, from_none], obj.get("serialize"))
4401+ set = from_union([from_float, Set.from_dict, from_none], obj.get("set"))
4402+ short = from_union([from_float, Short.from_dict, from_none], obj.get("short"))
4403+ signed = from_union([from_float, Signed.from_dict, from_none], obj.get("signed"))
4404+ sizeof = from_union([from_float, Sizeof.from_dict, from_none], obj.get("sizeof"))
4405+ stackalloc = from_union([from_float, Stackalloc.from_dict, from_none], obj.get("stackalloc"))
4406+ static = from_union([from_float, Static.from_dict, from_none], obj.get("static"))
4407+ static_assert = from_union([from_float, StaticAssert.from_dict, from_none], obj.get("static_assert"))
4408+ static_cast = from_union([from_float, StaticCast.from_dict, from_none], obj.get("static_cast"))
4409+ strictfp = from_union([from_float, Strictfp.from_dict, from_none], obj.get("strictfp"))
4410+ string = from_union([from_float, String.from_dict, from_none], obj.get("string"))
4411+ struct = from_union([from_float, Struct.from_dict, from_none], obj.get("struct"))
4412+ subscript = from_union([from_float, Subscript.from_dict, from_none], obj.get("subscript"))
4413+ super = from_union([from_float, Super.from_dict, from_none], obj.get("super"))
4414+ switch = from_union([from_float, Switch.from_dict, from_none], obj.get("switch"))
4415+ symbol = from_union([from_float, Symbol.from_dict, from_none], obj.get("symbol"))
4416+ synchronized = from_union([from_float, Synchronized.from_dict, from_none], obj.get("synchronized"))
4417+ system = from_union([from_float, System.from_dict, from_none], obj.get("system"))
4418+ template = from_union([from_float, Template.from_dict, from_none], obj.get("template"))
4419+ then = from_union([from_float, Then.from_dict, from_none], obj.get("then"))
4420+ this = from_union([from_float, This.from_dict, from_none], obj.get("this"))
4421+ thread_local = from_union([from_float, ThreadLocal.from_dict, from_none], obj.get("thread_local"))
4422+ throw = from_union([from_float, Throw.from_dict, from_none], obj.get("throw"))
4423+ throws = from_union([from_float, Throws.from_dict, from_none], obj.get("throws"))
4424+ to_json = from_union([from_float, ToJSON.from_dict, from_none], obj.get("to_json"))
4425+ top_level = from_union([from_float, TopLevelClass.from_dict, from_none], obj.get("top_level"))
4426+ transient = from_union([from_float, Transient.from_dict, from_none], obj.get("transient"))
4427+ true = from_union([from_float, TrueClass.from_dict, from_none], obj.get("True"))
4428+ top_level_true = from_union([from_float, UnionTrueTrue.from_dict, from_none], obj.get("true"))
4429+ top_level_try = from_union([from_float, Try.from_dict, from_none], obj.get("try"))
4430+ type = from_union([from_float, TypeClass.from_dict, from_none], obj.get("Type"))
4431+ top_level_type = from_union([from_float, UnionTypeType.from_dict, from_none], obj.get("type"))
4432+ typealias = from_union([from_float, Typealias.from_dict, from_none], obj.get("typealias"))
4433+ typedef = from_union([from_float, Typedef.from_dict, from_none], obj.get("typedef"))
4434+ typeid = from_union([from_float, Typeid.from_dict, from_none], obj.get("typeid"))
4435+ typename = from_union([from_float, Typename.from_dict, from_none], obj.get("typename"))
4436+ typeof = from_union([from_float, Typeof.from_dict, from_none], obj.get("typeof"))
4437+ uint = from_union([from_float, Uint.from_dict, from_none], obj.get("uint"))
4438+ ulong = from_union([from_float, Ulong.from_dict, from_none], obj.get("ulong"))
4439+ unchecked = from_union([from_float, Unchecked.from_dict, from_none], obj.get("unchecked"))
4440+ undefined = from_union([from_float, Undefined.from_dict, from_none], obj.get("undefined"))
4441+ union = from_union([from_float, UnionClass.from_dict, from_none], obj.get("union"))
4442+ unowned = from_union([from_float, Unowned.from_dict, from_none], obj.get("unowned"))
4443+ unsafe = from_union([from_float, Unsafe.from_dict, from_none], obj.get("unsafe"))
4444+ unsigned = from_union([from_float, Unsigned.from_dict, from_none], obj.get("unsigned"))
4445+ ushort = from_union([from_float, Ushort.from_dict, from_none], obj.get("ushort"))
4446+ using = from_union([from_float, Using.from_dict, from_none], obj.get("using"))
4447+ var = from_union([from_float, Var.from_dict, from_none], obj.get("var"))
4448+ virtual = from_union([from_float, Virtual.from_dict, from_none], obj.get("virtual"))
4449+ void = from_union([from_float, Void.from_dict, from_none], obj.get("void"))
4450+ volatile = from_union([from_float, Volatile.from_dict, from_none], obj.get("volatile"))
4451+ wchar_t = from_union([from_float, WcharT.from_dict, from_none], obj.get("wchar_t"))
4452+ weak = from_union([from_float, Weak.from_dict, from_none], obj.get("weak"))
4453+ where = from_union([from_float, Where.from_dict, from_none], obj.get("where"))
4454+ top_level_while = from_union([from_float, While.from_dict, from_none], obj.get("while"))
4455+ will_set = from_union([from_float, WillSet.from_dict, from_none], obj.get("willSet"))
4456+ top_level_with = from_union([from_float, With.from_dict, from_none], obj.get("with"))
4457+ xor = from_union([from_float, Xor.from_dict, from_none], obj.get("xor"))
4458+ xor_eq = from_union([from_float, XorEq.from_dict, from_none], obj.get("xor_eq"))
4459+ yes = from_union([from_float, Yes.from_dict, from_none], obj.get("YES"))
4460+ top_level_yield = from_union([from_float, Yield.from_dict, from_none], obj.get("yield"))
4461+ return TopLevel(empty, purple_bool, complex, imaginery, abstract, alignas, alignof, top_level_and, and_eq, top_level_any, any, array, top_level_as, asm, top_level_assert, associatedtype, associativity, top_level_async, atomic, atomic_cancel, atomic_commit, atomic_noexcept, auto, top_level_await, base, bitand, bitor, top_level_bool, fluffy_bool, boolean, top_level_break, bycopy, byref, byte, case, catch, chan, char, char16_t, char32_t, checked, purple_class, top_level_class, co_await, co_return, co_yield, compl, concept, console, const, const_cast, constexpr, constructor, top_level_continue, convenience, convert, converter, date, date_parse_handling, debugger, decimal, declare, decltype, decode_string, top_level_def, default, defer, deinit, top_level_del, delegate, delete, top_level_dict, dictionary, did_set, do, double, dummy, dynamic, dynamic_cast, top_level_elif, top_level_else, encode_quick_type, enum, event, top_level_except, exception, explicit, export, exposing, extends, extension, extern, fallthrough, top_level_false, false, fileprivate, final, top_level_finally, fixed, top_level_float, top_level_for, foreach, friend, top_level_from, from_json, func, function, get, top_level_global, go, goto, guard, has_own_property, id, top_level_if, imp, implements, implicit, top_level_import, top_level_in, indirect, infix, init, inline, inout, instanceof, top_level_int, interface, internal, top_level_is, iterable, jdec, jenc, jpipe, json, json_converter, json_serializer, json_token, json_writer, top_level_lambda, lazy, left, let, list, lock, long, map, metadata_property_handling, module, mutable, mutating, namespace, native, new, newtonsoft, nil, no, noexcept, nonatomic, top_level_none, none, top_level_nonlocal, nonmutating, top_level_not, not_eq, ns_string, null, top_level_null, nullptr, number, object, of, oneway, open, operator, optional, top_level_or, or_eq, out, override, package, params, top_level_pass, port, postfix, precedence, prefix, top_level_print, printf, private, protected, protocol, top_level_protocol, public, quicktype, top_level_raise, range, readonly, ref, register, reinterpret_cast, repeat, require, required, requires, restrict, retain, rethrows, top_level_return, right, sbyte, sealed, sel, select, top_level_self, purple_self, serialize, set, short, signed, sizeof, stackalloc, static, static_assert, static_cast, strictfp, string, struct, subscript, super, switch, symbol, synchronized, system, template, then, this, thread_local, throw, throws, to_json, top_level, transient, true, top_level_true, top_level_try, type, top_level_type, typealias, typedef, typeid, typename, typeof, uint, ulong, unchecked, undefined, union, unowned, unsafe, unsigned, ushort, using, var, virtual, void, volatile, wchar_t, weak, where, top_level_while, will_set, top_level_with, xor, xor_eq, yes, top_level_yield)
4462+
4463+ def to_dict(self) -> dict:
4464+ result: dict = {}
4465+ if self.empty is not None:
4466+ result["_"] = from_union([to_float, lambda x: to_class(Empty, x), from_none], self.empty)
4467+ if self.purple_bool is not None:
4468+ result["_Bool"] = from_union([to_float, lambda x: to_class(BoolClass, x), from_none], self.purple_bool)
4469+ if self.complex is not None:
4470+ result["_Complex"] = from_union([to_float, lambda x: to_class(Complex, x), from_none], self.complex)
4471+ if self.imaginery is not None:
4472+ result["_Imaginery"] = from_union([to_float, lambda x: to_class(Imaginery, x), from_none], self.imaginery)
4473+ if self.abstract is not None:
4474+ result["abstract"] = from_union([to_float, lambda x: to_class(Abstract, x), from_none], self.abstract)
4475+ if self.alignas is not None:
4476+ result["alignas"] = from_union([to_float, lambda x: to_class(Alignas, x), from_none], self.alignas)
4477+ if self.alignof is not None:
4478+ result["alignof"] = from_union([to_float, lambda x: to_class(Alignof, x), from_none], self.alignof)
4479+ if self.top_level_and is not None:
4480+ result["and"] = from_union([to_float, lambda x: to_class(And, x), from_none], self.top_level_and)
4481+ if self.and_eq is not None:
4482+ result["and_eq"] = from_union([to_float, lambda x: to_class(AndEq, x), from_none], self.and_eq)
4483+ if self.top_level_any is not None:
4484+ result["any"] = from_union([to_float, lambda x: to_class(UnionAnyAny, x), from_none], self.top_level_any)
4485+ if self.any is not None:
4486+ result["Any"] = from_union([to_float, lambda x: to_class(AnyClass, x), from_none], self.any)
4487+ if self.array is not None:
4488+ result["array"] = from_union([to_float, lambda x: to_class(Array, x), from_none], self.array)
4489+ if self.top_level_as is not None:
4490+ result["as"] = from_union([to_float, lambda x: to_class(As, x), from_none], self.top_level_as)
4491+ if self.asm is not None:
4492+ result["asm"] = from_union([to_float, lambda x: to_class(ASM, x), from_none], self.asm)
4493+ if self.top_level_assert is not None:
4494+ result["assert"] = from_union([to_float, lambda x: to_class(Assert, x), from_none], self.top_level_assert)
4495+ if self.associatedtype is not None:
4496+ result["associatedtype"] = from_union([to_float, lambda x: to_class(Associatedtype, x), from_none], self.associatedtype)
4497+ if self.associativity is not None:
4498+ result["associativity"] = from_union([to_float, lambda x: to_class(Associativity, x), from_none], self.associativity)
4499+ if self.top_level_async is not None:
4500+ result["async"] = from_union([to_float, lambda x: to_class(Async, x), from_none], self.top_level_async)
4501+ if self.atomic is not None:
4502+ result["atomic"] = from_union([to_float, lambda x: to_class(Atomic, x), from_none], self.atomic)
4503+ if self.atomic_cancel is not None:
4504+ result["atomic_cancel"] = from_union([to_float, lambda x: to_class(AtomicCancel, x), from_none], self.atomic_cancel)
4505+ if self.atomic_commit is not None:
4506+ result["atomic_commit"] = from_union([to_float, lambda x: to_class(AtomicCommit, x), from_none], self.atomic_commit)
4507+ if self.atomic_noexcept is not None:
4508+ result["atomic_noexcept"] = from_union([to_float, lambda x: to_class(AtomicNoexcept, x), from_none], self.atomic_noexcept)
4509+ if self.auto is not None:
4510+ result["auto"] = from_union([to_float, lambda x: to_class(Auto, x), from_none], self.auto)
4511+ if self.top_level_await is not None:
4512+ result["await"] = from_union([to_float, lambda x: to_class(Await, x), from_none], self.top_level_await)
4513+ if self.base is not None:
4514+ result["base"] = from_union([to_float, lambda x: to_class(Base, x), from_none], self.base)
4515+ if self.bitand is not None:
4516+ result["bitand"] = from_union([to_float, lambda x: to_class(Bitand, x), from_none], self.bitand)
4517+ if self.bitor is not None:
4518+ result["bitor"] = from_union([to_float, lambda x: to_class(Bitor, x), from_none], self.bitor)
4519+ if self.top_level_bool is not None:
4520+ result["BOOL"] = from_union([to_float, lambda x: to_class(Bool, x), from_none], self.top_level_bool)
4521+ if self.fluffy_bool is not None:
4522+ result["bool"] = from_union([to_float, lambda x: to_class(UnionBoolBool, x), from_none], self.fluffy_bool)
4523+ if self.boolean is not None:
4524+ result["boolean"] = from_union([to_float, lambda x: to_class(Boolean, x), from_none], self.boolean)
4525+ if self.top_level_break is not None:
4526+ result["break"] = from_union([to_float, lambda x: to_class(Break, x), from_none], self.top_level_break)
4527+ if self.bycopy is not None:
4528+ result["bycopy"] = from_union([to_float, lambda x: to_class(Bycopy, x), from_none], self.bycopy)
4529+ if self.byref is not None:
4530+ result["byref"] = from_union([to_float, lambda x: to_class(Byref, x), from_none], self.byref)
4531+ if self.byte is not None:
4532+ result["byte"] = from_union([to_float, lambda x: to_class(Byte, x), from_none], self.byte)
4533+ if self.case is not None:
4534+ result["case"] = from_union([to_float, lambda x: to_class(Case, x), from_none], self.case)
4535+ if self.catch is not None:
4536+ result["catch"] = from_union([to_float, lambda x: to_class(Catch, x), from_none], self.catch)
4537+ if self.chan is not None:
4538+ result["chan"] = from_union([to_float, lambda x: to_class(Chan, x), from_none], self.chan)
4539+ if self.char is not None:
4540+ result["char"] = from_union([to_float, lambda x: to_class(Char, x), from_none], self.char)
4541+ if self.char16_t is not None:
4542+ result["char16_t"] = from_union([to_float, lambda x: to_class(Char16T, x), from_none], self.char16_t)
4543+ if self.char32_t is not None:
4544+ result["char32_t"] = from_union([to_float, lambda x: to_class(Char32T, x), from_none], self.char32_t)
4545+ if self.checked is not None:
4546+ result["checked"] = from_union([to_float, lambda x: to_class(Checked, x), from_none], self.checked)
4547+ if self.purple_class is not None:
4548+ result["class"] = from_union([to_float, lambda x: to_class(ClassClass, x), from_none], self.purple_class)
4549+ if self.top_level_class is not None:
4550+ result["Class"] = from_union([to_float, lambda x: to_class(Class, x), from_none], self.top_level_class)
4551+ if self.co_await is not None:
4552+ result["co_await"] = from_union([to_float, lambda x: to_class(CoAwait, x), from_none], self.co_await)
4553+ if self.co_return is not None:
4554+ result["co_return"] = from_union([to_float, lambda x: to_class(CoReturn, x), from_none], self.co_return)
4555+ if self.co_yield is not None:
4556+ result["co_yield"] = from_union([to_float, lambda x: to_class(CoYield, x), from_none], self.co_yield)
4557+ if self.compl is not None:
4558+ result["compl"] = from_union([to_float, lambda x: to_class(Compl, x), from_none], self.compl)
4559+ if self.concept is not None:
4560+ result["concept"] = from_union([to_float, lambda x: to_class(Concept, x), from_none], self.concept)
4561+ if self.console is not None:
4562+ result["console"] = from_union([to_float, lambda x: to_class(Console, x), from_none], self.console)
4563+ if self.const is not None:
4564+ result["const"] = from_union([to_float, lambda x: to_class(Const, x), from_none], self.const)
4565+ if self.const_cast is not None:
4566+ result["const_cast"] = from_union([to_float, lambda x: to_class(ConstCast, x), from_none], self.const_cast)
4567+ if self.constexpr is not None:
4568+ result["constexpr"] = from_union([to_float, lambda x: to_class(Constexpr, x), from_none], self.constexpr)
4569+ if self.constructor is not None:
4570+ result["constructor"] = from_union([to_float, lambda x: to_class(Constructor, x), from_none], self.constructor)
4571+ if self.top_level_continue is not None:
4572+ result["continue"] = from_union([to_float, lambda x: to_class(Continue, x), from_none], self.top_level_continue)
4573+ if self.convenience is not None:
4574+ result["convenience"] = from_union([to_float, lambda x: to_class(Convenience, x), from_none], self.convenience)
4575+ if self.convert is not None:
4576+ result["convert"] = from_union([to_float, lambda x: to_class(Convert, x), from_none], self.convert)
4577+ if self.converter is not None:
4578+ result["converter"] = from_union([to_float, lambda x: to_class(Converter, x), from_none], self.converter)
4579+ if self.date is not None:
4580+ result["date"] = from_union([to_float, lambda x: to_class(Date, x), from_none], self.date)
4581+ if self.date_parse_handling is not None:
4582+ result["date_parse_handling"] = from_union([to_float, lambda x: to_class(DateParseHandling, x), from_none], self.date_parse_handling)
4583+ if self.debugger is not None:
4584+ result["debugger"] = from_union([to_float, lambda x: to_class(Debugger, x), from_none], self.debugger)
4585+ if self.decimal is not None:
4586+ result["decimal"] = from_union([to_float, lambda x: to_class(Decimal, x), from_none], self.decimal)
4587+ if self.declare is not None:
4588+ result["declare"] = from_union([to_float, lambda x: to_class(Declare, x), from_none], self.declare)
4589+ if self.decltype is not None:
4590+ result["decltype"] = from_union([to_float, lambda x: to_class(Decltype, x), from_none], self.decltype)
4591+ if self.decode_string is not None:
4592+ result["decode_string"] = from_union([to_float, lambda x: to_class(DecodeString, x), from_none], self.decode_string)
4593+ if self.top_level_def is not None:
4594+ result["def"] = from_union([to_float, lambda x: to_class(Def, x), from_none], self.top_level_def)
4595+ if self.default is not None:
4596+ result["default"] = from_union([to_float, lambda x: to_class(Default, x), from_none], self.default)
4597+ if self.defer is not None:
4598+ result["defer"] = from_union([to_float, lambda x: to_class(Defer, x), from_none], self.defer)
4599+ if self.deinit is not None:
4600+ result["deinit"] = from_union([to_float, lambda x: to_class(Deinit, x), from_none], self.deinit)
4601+ if self.top_level_del is not None:
4602+ result["del"] = from_union([to_float, lambda x: to_class(Del, x), from_none], self.top_level_del)
4603+ if self.delegate is not None:
4604+ result["delegate"] = from_union([to_float, lambda x: to_class(Delegate, x), from_none], self.delegate)
4605+ if self.delete is not None:
4606+ result["delete"] = from_union([to_float, lambda x: to_class(Delete, x), from_none], self.delete)
4607+ if self.top_level_dict is not None:
4608+ result["dict"] = from_union([to_float, lambda x: to_class(DictClass, x), from_none], self.top_level_dict)
4609+ if self.dictionary is not None:
4610+ result["dictionary"] = from_union([to_float, lambda x: to_class(Dictionary, x), from_none], self.dictionary)
4611+ if self.did_set is not None:
4612+ result["didSet"] = from_union([to_float, lambda x: to_class(DidSet, x), from_none], self.did_set)
4613+ if self.do is not None:
4614+ result["do"] = from_union([to_float, lambda x: to_class(Do, x), from_none], self.do)
4615+ if self.double is not None:
4616+ result["double"] = from_union([to_float, lambda x: to_class(Double, x), from_none], self.double)
4617+ if self.dummy is not None:
4618+ result["dummy"] = from_union([to_float, from_none], self.dummy)
4619+ if self.dynamic is not None:
4620+ result["dynamic"] = from_union([to_float, lambda x: to_class(Dynamic, x), from_none], self.dynamic)
4621+ if self.dynamic_cast is not None:
4622+ result["dynamic_cast"] = from_union([to_float, lambda x: to_class(DynamicCast, x), from_none], self.dynamic_cast)
4623+ if self.top_level_elif is not None:
4624+ result["elif"] = from_union([to_float, lambda x: to_class(Elif, x), from_none], self.top_level_elif)
4625+ if self.top_level_else is not None:
4626+ result["else"] = from_union([to_float, lambda x: to_class(Else, x), from_none], self.top_level_else)
4627+ if self.encode_quick_type is not None:
4628+ result["encode_quick_type"] = from_union([to_float, lambda x: to_class(EncodeQuickType, x), from_none], self.encode_quick_type)
4629+ if self.enum is not None:
4630+ result["enum"] = from_union([to_float, lambda x: to_class(EnumClass, x), from_none], self.enum)
4631+ if self.event is not None:
4632+ result["event"] = from_union([to_float, lambda x: to_class(Event, x), from_none], self.event)
4633+ if self.top_level_except is not None:
4634+ result["except"] = from_union([to_float, lambda x: to_class(Except, x), from_none], self.top_level_except)
4635+ if self.exception is not None:
4636+ result["exception"] = from_union([to_float, lambda x: to_class(Exception, x), from_none], self.exception)
4637+ if self.explicit is not None:
4638+ result["explicit"] = from_union([to_float, lambda x: to_class(Explicit, x), from_none], self.explicit)
4639+ if self.export is not None:
4640+ result["export"] = from_union([to_float, lambda x: to_class(Export, x), from_none], self.export)
4641+ if self.exposing is not None:
4642+ result["exposing"] = from_union([to_float, lambda x: to_class(Exposing, x), from_none], self.exposing)
4643+ if self.extends is not None:
4644+ result["extends"] = from_union([to_float, lambda x: to_class(Extends, x), from_none], self.extends)
4645+ if self.extension is not None:
4646+ result["extension"] = from_union([to_float, lambda x: to_class(Extension, x), from_none], self.extension)
4647+ if self.extern is not None:
4648+ result["extern"] = from_union([to_float, lambda x: to_class(Extern, x), from_none], self.extern)
4649+ if self.fallthrough is not None:
4650+ result["fallthrough"] = from_union([to_float, lambda x: to_class(Fallthrough, x), from_none], self.fallthrough)
4651+ if self.top_level_false is not None:
4652+ result["false"] = from_union([to_float, lambda x: to_class(UnionFalseFalse, x), from_none], self.top_level_false)
4653+ if self.false is not None:
4654+ result["False"] = from_union([to_float, lambda x: to_class(FalseClass, x), from_none], self.false)
4655+ if self.fileprivate is not None:
4656+ result["fileprivate"] = from_union([to_float, lambda x: to_class(Fileprivate, x), from_none], self.fileprivate)
4657+ if self.final is not None:
4658+ result["final"] = from_union([to_float, lambda x: to_class(Final, x), from_none], self.final)
4659+ if self.top_level_finally is not None:
4660+ result["finally"] = from_union([to_float, lambda x: to_class(Finally, x), from_none], self.top_level_finally)
4661+ if self.fixed is not None:
4662+ result["fixed"] = from_union([to_float, lambda x: to_class(Fixed, x), from_none], self.fixed)
4663+ if self.top_level_float is not None:
4664+ result["float"] = from_union([to_float, lambda x: to_class(Float, x), from_none], self.top_level_float)
4665+ if self.top_level_for is not None:
4666+ result["for"] = from_union([to_float, lambda x: to_class(For, x), from_none], self.top_level_for)
4667+ if self.foreach is not None:
4668+ result["foreach"] = from_union([to_float, lambda x: to_class(Foreach, x), from_none], self.foreach)
4669+ if self.friend is not None:
4670+ result["friend"] = from_union([to_float, lambda x: to_class(Friend, x), from_none], self.friend)
4671+ if self.top_level_from is not None:
4672+ result["from"] = from_union([to_float, lambda x: to_class(From, x), from_none], self.top_level_from)
4673+ if self.from_json is not None:
4674+ result["from_json"] = from_union([to_float, lambda x: to_class(FromJSON, x), from_none], self.from_json)
4675+ if self.func is not None:
4676+ result["func"] = from_union([to_float, lambda x: to_class(Func, x), from_none], self.func)
4677+ if self.function is not None:
4678+ result["function"] = from_union([to_float, lambda x: to_class(Function, x), from_none], self.function)
4679+ if self.get is not None:
4680+ result["get"] = from_union([to_float, lambda x: to_class(Get, x), from_none], self.get)
4681+ if self.top_level_global is not None:
4682+ result["global"] = from_union([to_float, lambda x: to_class(Global, x), from_none], self.top_level_global)
4683+ if self.go is not None:
4684+ result["go"] = from_union([to_float, lambda x: to_class(Go, x), from_none], self.go)
4685+ if self.goto is not None:
4686+ result["goto"] = from_union([to_float, lambda x: to_class(Goto, x), from_none], self.goto)
4687+ if self.guard is not None:
4688+ result["guard"] = from_union([to_float, lambda x: to_class(Guard, x), from_none], self.guard)
4689+ if self.has_own_property is not None:
4690+ result["hasOwnProperty"] = from_union([to_float, lambda x: to_class(HasOwnProperty, x), from_none], self.has_own_property)
4691+ if self.id is not None:
4692+ result["id"] = from_union([to_float, lambda x: to_class(ID, x), from_none], self.id)
4693+ if self.top_level_if is not None:
4694+ result["if"] = from_union([to_float, lambda x: to_class(If, x), from_none], self.top_level_if)
4695+ if self.imp is not None:
4696+ result["IMP"] = from_union([to_float, lambda x: to_class(Imp, x), from_none], self.imp)
4697+ if self.implements is not None:
4698+ result["implements"] = from_union([to_float, lambda x: to_class(Implements, x), from_none], self.implements)
4699+ if self.implicit is not None:
4700+ result["implicit"] = from_union([to_float, lambda x: to_class(Implicit, x), from_none], self.implicit)
4701+ if self.top_level_import is not None:
4702+ result["import"] = from_union([to_float, lambda x: to_class(Import, x), from_none], self.top_level_import)
4703+ if self.top_level_in is not None:
4704+ result["in"] = from_union([to_float, lambda x: to_class(In, x), from_none], self.top_level_in)
4705+ if self.indirect is not None:
4706+ result["indirect"] = from_union([to_float, lambda x: to_class(Indirect, x), from_none], self.indirect)
4707+ if self.infix is not None:
4708+ result["infix"] = from_union([to_float, lambda x: to_class(Infix, x), from_none], self.infix)
4709+ if self.init is not None:
4710+ result["init"] = from_union([to_float, lambda x: to_class(Init, x), from_none], self.init)
4711+ if self.inline is not None:
4712+ result["inline"] = from_union([to_float, lambda x: to_class(Inline, x), from_none], self.inline)
4713+ if self.inout is not None:
4714+ result["inout"] = from_union([to_float, lambda x: to_class(Inout, x), from_none], self.inout)
4715+ if self.instanceof is not None:
4716+ result["instanceof"] = from_union([to_float, lambda x: to_class(Instanceof, x), from_none], self.instanceof)
4717+ if self.top_level_int is not None:
4718+ result["int"] = from_union([to_float, lambda x: to_class(Int, x), from_none], self.top_level_int)
4719+ if self.interface is not None:
4720+ result["interface"] = from_union([to_float, lambda x: to_class(Interface, x), from_none], self.interface)
4721+ if self.internal is not None:
4722+ result["internal"] = from_union([to_float, lambda x: to_class(Internal, x), from_none], self.internal)
4723+ if self.top_level_is is not None:
4724+ result["is"] = from_union([to_float, lambda x: to_class(Is, x), from_none], self.top_level_is)
4725+ if self.iterable is not None:
4726+ result["iterable"] = from_union([to_float, lambda x: to_class(IterableClass, x), from_none], self.iterable)
4727+ if self.jdec is not None:
4728+ result["jdec"] = from_union([to_float, lambda x: to_class(Jdec, x), from_none], self.jdec)
4729+ if self.jenc is not None:
4730+ result["jenc"] = from_union([to_float, lambda x: to_class(Jenc, x), from_none], self.jenc)
4731+ if self.jpipe is not None:
4732+ result["jpipe"] = from_union([to_float, lambda x: to_class(Jpipe, x), from_none], self.jpipe)
4733+ if self.json is not None:
4734+ result["json"] = from_union([to_float, lambda x: to_class(JSON, x), from_none], self.json)
4735+ if self.json_converter is not None:
4736+ result["json_converter"] = from_union([to_float, lambda x: to_class(JSONConverter, x), from_none], self.json_converter)
4737+ if self.json_serializer is not None:
4738+ result["json_serializer"] = from_union([to_float, lambda x: to_class(JSONSerializer, x), from_none], self.json_serializer)
4739+ if self.json_token is not None:
4740+ result["json_token"] = from_union([to_float, lambda x: to_class(JSONToken, x), from_none], self.json_token)
4741+ if self.json_writer is not None:
4742+ result["json_writer"] = from_union([to_float, lambda x: to_class(JSONWriter, x), from_none], self.json_writer)
4743+ if self.top_level_lambda is not None:
4744+ result["lambda"] = from_union([to_float, lambda x: to_class(Lambda, x), from_none], self.top_level_lambda)
4745+ if self.lazy is not None:
4746+ result["lazy"] = from_union([to_float, lambda x: to_class(Lazy, x), from_none], self.lazy)
4747+ if self.left is not None:
4748+ result["left"] = from_union([to_float, lambda x: to_class(Left, x), from_none], self.left)
4749+ if self.let is not None:
4750+ result["let"] = from_union([to_float, lambda x: to_class(Let, x), from_none], self.let)
4751+ if self.list is not None:
4752+ result["list"] = from_union([to_float, lambda x: to_class(ListClass, x), from_none], self.list)
4753+ if self.lock is not None:
4754+ result["lock"] = from_union([to_float, lambda x: to_class(Lock, x), from_none], self.lock)
4755+ if self.long is not None:
4756+ result["long"] = from_union([to_float, lambda x: to_class(Long, x), from_none], self.long)
4757+ if self.map is not None:
4758+ result["map"] = from_union([to_float, lambda x: to_class(Map, x), from_none], self.map)
4759+ if self.metadata_property_handling is not None:
4760+ result["metadata_property_handling"] = from_union([to_float, lambda x: to_class(MetadataPropertyHandling, x), from_none], self.metadata_property_handling)
4761+ if self.module is not None:
4762+ result["module"] = from_union([to_float, lambda x: to_class(Module, x), from_none], self.module)
4763+ if self.mutable is not None:
4764+ result["mutable"] = from_union([to_float, lambda x: to_class(Mutable, x), from_none], self.mutable)
4765+ if self.mutating is not None:
4766+ result["mutating"] = from_union([to_float, lambda x: to_class(Mutating, x), from_none], self.mutating)
4767+ if self.namespace is not None:
4768+ result["namespace"] = from_union([to_float, lambda x: to_class(Namespace, x), from_none], self.namespace)
4769+ if self.native is not None:
4770+ result["native"] = from_union([to_float, lambda x: to_class(Native, x), from_none], self.native)
4771+ if self.new is not None:
4772+ result["new"] = from_union([to_float, lambda x: to_class(New, x), from_none], self.new)
4773+ if self.newtonsoft is not None:
4774+ result["newtonsoft"] = from_union([to_float, lambda x: to_class(Newtonsoft, x), from_none], self.newtonsoft)
4775+ if self.nil is not None:
4776+ result["nil"] = from_union([to_float, lambda x: to_class(Nil, x), from_none], self.nil)
4777+ if self.no is not None:
4778+ result["NO"] = from_union([to_float, lambda x: to_class(No, x), from_none], self.no)
4779+ if self.noexcept is not None:
4780+ result["noexcept"] = from_union([to_float, lambda x: to_class(Noexcept, x), from_none], self.noexcept)
4781+ if self.nonatomic is not None:
4782+ result["nonatomic"] = from_union([to_float, lambda x: to_class(Nonatomic, x), from_none], self.nonatomic)
4783+ if self.top_level_none is not None:
4784+ result["none"] = from_union([to_float, lambda x: to_class(UnionNoneNone, x), from_none], self.top_level_none)
4785+ if self.none is not None:
4786+ result["None"] = from_union([to_float, lambda x: to_class(NoneClass, x), from_none], self.none)
4787+ if self.top_level_nonlocal is not None:
4788+ result["nonlocal"] = from_union([to_float, lambda x: to_class(Nonlocal, x), from_none], self.top_level_nonlocal)
4789+ if self.nonmutating is not None:
4790+ result["nonmutating"] = from_union([to_float, lambda x: to_class(Nonmutating, x), from_none], self.nonmutating)
4791+ if self.top_level_not is not None:
4792+ result["not"] = from_union([to_float, lambda x: to_class(Not, x), from_none], self.top_level_not)
4793+ if self.not_eq is not None:
4794+ result["not_eq"] = from_union([to_float, lambda x: to_class(NotEq, x), from_none], self.not_eq)
4795+ if self.ns_string is not None:
4796+ result["NSString"] = from_union([to_float, lambda x: to_class(NSString, x), from_none], self.ns_string)
4797+ if self.null is not None:
4798+ result["NULL"] = from_union([to_float, lambda x: to_class(Null, x), from_none], self.null)
4799+ if self.top_level_null is not None:
4800+ result["null"] = from_union([to_float, lambda x: to_class(NullClass, x), from_none], self.top_level_null)
4801+ if self.nullptr is not None:
4802+ result["nullptr"] = from_union([to_float, lambda x: to_class(Nullptr, x), from_none], self.nullptr)
4803+ if self.number is not None:
4804+ result["number"] = from_union([to_float, lambda x: to_class(Number, x), from_none], self.number)
4805+ if self.object is not None:
4806+ result["object"] = from_union([to_float, lambda x: to_class(Object, x), from_none], self.object)
4807+ if self.of is not None:
4808+ result["of"] = from_union([to_float, lambda x: to_class(Of, x), from_none], self.of)
4809+ if self.oneway is not None:
4810+ result["oneway"] = from_union([to_float, lambda x: to_class(Oneway, x), from_none], self.oneway)
4811+ if self.open is not None:
4812+ result["open"] = from_union([to_float, lambda x: to_class(Open, x), from_none], self.open)
4813+ if self.operator is not None:
4814+ result["operator"] = from_union([to_float, lambda x: to_class(Operator, x), from_none], self.operator)
4815+ if self.optional is not None:
4816+ result["optional"] = from_union([to_float, lambda x: to_class(OptionalClass, x), from_none], self.optional)
4817+ if self.top_level_or is not None:
4818+ result["or"] = from_union([to_float, lambda x: to_class(Or, x), from_none], self.top_level_or)
4819+ if self.or_eq is not None:
4820+ result["or_eq"] = from_union([to_float, lambda x: to_class(OrEq, x), from_none], self.or_eq)
4821+ if self.out is not None:
4822+ result["out"] = from_union([to_float, lambda x: to_class(Out, x), from_none], self.out)
4823+ if self.override is not None:
4824+ result["override"] = from_union([to_float, lambda x: to_class(Override, x), from_none], self.override)
4825+ if self.package is not None:
4826+ result["package"] = from_union([to_float, lambda x: to_class(Package, x), from_none], self.package)
4827+ if self.params is not None:
4828+ result["params"] = from_union([to_float, lambda x: to_class(Params, x), from_none], self.params)
4829+ if self.top_level_pass is not None:
4830+ result["pass"] = from_union([to_float, lambda x: to_class(Pass, x), from_none], self.top_level_pass)
4831+ if self.port is not None:
4832+ result["port"] = from_union([to_float, lambda x: to_class(Port, x), from_none], self.port)
4833+ if self.postfix is not None:
4834+ result["postfix"] = from_union([to_float, lambda x: to_class(Postfix, x), from_none], self.postfix)
4835+ if self.precedence is not None:
4836+ result["precedence"] = from_union([to_float, lambda x: to_class(Precedence, x), from_none], self.precedence)
4837+ if self.prefix is not None:
4838+ result["prefix"] = from_union([to_float, lambda x: to_class(Prefix, x), from_none], self.prefix)
4839+ if self.top_level_print is not None:
4840+ result["print"] = from_union([to_float, lambda x: to_class(Print, x), from_none], self.top_level_print)
4841+ if self.printf is not None:
4842+ result["printf"] = from_union([to_float, lambda x: to_class(Printf, x), from_none], self.printf)
4843+ if self.private is not None:
4844+ result["private"] = from_union([to_float, lambda x: to_class(Private, x), from_none], self.private)
4845+ if self.protected is not None:
4846+ result["protected"] = from_union([to_float, lambda x: to_class(Protected, x), from_none], self.protected)
4847+ if self.protocol is not None:
4848+ result["Protocol"] = from_union([to_float, lambda x: to_class(Protocol, x), from_none], self.protocol)
4849+ if self.top_level_protocol is not None:
4850+ result["protocol"] = from_union([to_float, lambda x: to_class(ProtocolClass, x), from_none], self.top_level_protocol)
4851+ if self.public is not None:
4852+ result["public"] = from_union([to_float, lambda x: to_class(Public, x), from_none], self.public)
4853+ if self.quicktype is not None:
4854+ result["quicktype"] = from_union([to_float, lambda x: to_class(Quicktype, x), from_none], self.quicktype)
4855+ if self.top_level_raise is not None:
4856+ result["raise"] = from_union([to_float, lambda x: to_class(Raise, x), from_none], self.top_level_raise)
4857+ if self.range is not None:
4858+ result["range"] = from_union([to_float, lambda x: to_class(Range, x), from_none], self.range)
4859+ if self.readonly is not None:
4860+ result["readonly"] = from_union([to_float, lambda x: to_class(Readonly, x), from_none], self.readonly)
4861+ if self.ref is not None:
4862+ result["ref"] = from_union([to_float, lambda x: to_class(Ref, x), from_none], self.ref)
4863+ if self.register is not None:
4864+ result["register"] = from_union([to_float, lambda x: to_class(Register, x), from_none], self.register)
4865+ if self.reinterpret_cast is not None:
4866+ result["reinterpret_cast"] = from_union([to_float, lambda x: to_class(ReinterpretCast, x), from_none], self.reinterpret_cast)
4867+ if self.repeat is not None:
4868+ result["repeat"] = from_union([to_float, lambda x: to_class(Repeat, x), from_none], self.repeat)
4869+ if self.require is not None:
4870+ result["require"] = from_union([to_float, lambda x: to_class(Require, x), from_none], self.require)
4871+ if self.required is not None:
4872+ result["required"] = from_union([to_float, lambda x: to_class(Required, x), from_none], self.required)
4873+ if self.requires is not None:
4874+ result["requires"] = from_union([to_float, lambda x: to_class(Requires, x), from_none], self.requires)
4875+ if self.restrict is not None:
4876+ result["restrict"] = from_union([to_float, lambda x: to_class(Restrict, x), from_none], self.restrict)
4877+ if self.retain is not None:
4878+ result["retain"] = from_union([to_float, lambda x: to_class(Retain, x), from_none], self.retain)
4879+ if self.rethrows is not None:
4880+ result["rethrows"] = from_union([to_float, lambda x: to_class(Rethrows, x), from_none], self.rethrows)
4881+ if self.top_level_return is not None:
4882+ result["return"] = from_union([to_float, lambda x: to_class(Return, x), from_none], self.top_level_return)
4883+ if self.right is not None:
4884+ result["right"] = from_union([to_float, lambda x: to_class(Right, x), from_none], self.right)
4885+ if self.sbyte is not None:
4886+ result["sbyte"] = from_union([to_float, lambda x: to_class(Sbyte, x), from_none], self.sbyte)
4887+ if self.sealed is not None:
4888+ result["sealed"] = from_union([to_float, lambda x: to_class(Sealed, x), from_none], self.sealed)
4889+ if self.sel is not None:
4890+ result["SEL"] = from_union([to_float, lambda x: to_class(Sel, x), from_none], self.sel)
4891+ if self.select is not None:
4892+ result["select"] = from_union([to_float, lambda x: to_class(Select, x), from_none], self.select)
4893+ if self.top_level_self is not None:
4894+ result["Self"] = from_union([to_float, lambda x: to_class(Self, x), from_none], self.top_level_self)
4895+ if self.purple_self is not None:
4896+ result["self"] = from_union([to_float, lambda x: to_class(SelfClass, x), from_none], self.purple_self)
4897+ if self.serialize is not None:
4898+ result["serialize"] = from_union([to_float, lambda x: to_class(Serialize, x), from_none], self.serialize)
4899+ if self.set is not None:
4900+ result["set"] = from_union([to_float, lambda x: to_class(Set, x), from_none], self.set)
4901+ if self.short is not None:
4902+ result["short"] = from_union([to_float, lambda x: to_class(Short, x), from_none], self.short)
4903+ if self.signed is not None:
4904+ result["signed"] = from_union([to_float, lambda x: to_class(Signed, x), from_none], self.signed)
4905+ if self.sizeof is not None:
4906+ result["sizeof"] = from_union([to_float, lambda x: to_class(Sizeof, x), from_none], self.sizeof)
4907+ if self.stackalloc is not None:
4908+ result["stackalloc"] = from_union([to_float, lambda x: to_class(Stackalloc, x), from_none], self.stackalloc)
4909+ if self.static is not None:
4910+ result["static"] = from_union([to_float, lambda x: to_class(Static, x), from_none], self.static)
4911+ if self.static_assert is not None:
4912+ result["static_assert"] = from_union([to_float, lambda x: to_class(StaticAssert, x), from_none], self.static_assert)
4913+ if self.static_cast is not None:
4914+ result["static_cast"] = from_union([to_float, lambda x: to_class(StaticCast, x), from_none], self.static_cast)
4915+ if self.strictfp is not None:
4916+ result["strictfp"] = from_union([to_float, lambda x: to_class(Strictfp, x), from_none], self.strictfp)
4917+ if self.string is not None:
4918+ result["string"] = from_union([to_float, lambda x: to_class(String, x), from_none], self.string)
4919+ if self.struct is not None:
4920+ result["struct"] = from_union([to_float, lambda x: to_class(Struct, x), from_none], self.struct)
4921+ if self.subscript is not None:
4922+ result["subscript"] = from_union([to_float, lambda x: to_class(Subscript, x), from_none], self.subscript)
4923+ if self.super is not None:
4924+ result["super"] = from_union([to_float, lambda x: to_class(Super, x), from_none], self.super)
4925+ if self.switch is not None:
4926+ result["switch"] = from_union([to_float, lambda x: to_class(Switch, x), from_none], self.switch)
4927+ if self.symbol is not None:
4928+ result["symbol"] = from_union([to_float, lambda x: to_class(Symbol, x), from_none], self.symbol)
4929+ if self.synchronized is not None:
4930+ result["synchronized"] = from_union([to_float, lambda x: to_class(Synchronized, x), from_none], self.synchronized)
4931+ if self.system is not None:
4932+ result["system"] = from_union([to_float, lambda x: to_class(System, x), from_none], self.system)
4933+ if self.template is not None:
4934+ result["template"] = from_union([to_float, lambda x: to_class(Template, x), from_none], self.template)
4935+ if self.then is not None:
4936+ result["then"] = from_union([to_float, lambda x: to_class(Then, x), from_none], self.then)
4937+ if self.this is not None:
4938+ result["this"] = from_union([to_float, lambda x: to_class(This, x), from_none], self.this)
4939+ if self.thread_local is not None:
4940+ result["thread_local"] = from_union([to_float, lambda x: to_class(ThreadLocal, x), from_none], self.thread_local)
4941+ if self.throw is not None:
4942+ result["throw"] = from_union([to_float, lambda x: to_class(Throw, x), from_none], self.throw)
4943+ if self.throws is not None:
4944+ result["throws"] = from_union([to_float, lambda x: to_class(Throws, x), from_none], self.throws)
4945+ if self.to_json is not None:
4946+ result["to_json"] = from_union([to_float, lambda x: to_class(ToJSON, x), from_none], self.to_json)
4947+ if self.top_level is not None:
4948+ result["top_level"] = from_union([to_float, lambda x: to_class(TopLevelClass, x), from_none], self.top_level)
4949+ if self.transient is not None:
4950+ result["transient"] = from_union([to_float, lambda x: to_class(Transient, x), from_none], self.transient)
4951+ if self.true is not None:
4952+ result["True"] = from_union([to_float, lambda x: to_class(TrueClass, x), from_none], self.true)
4953+ if self.top_level_true is not None:
4954+ result["true"] = from_union([to_float, lambda x: to_class(UnionTrueTrue, x), from_none], self.top_level_true)
4955+ if self.top_level_try is not None:
4956+ result["try"] = from_union([to_float, lambda x: to_class(Try, x), from_none], self.top_level_try)
4957+ if self.type is not None:
4958+ result["Type"] = from_union([to_float, lambda x: to_class(TypeClass, x), from_none], self.type)
4959+ if self.top_level_type is not None:
4960+ result["type"] = from_union([to_float, lambda x: to_class(UnionTypeType, x), from_none], self.top_level_type)
4961+ if self.typealias is not None:
4962+ result["typealias"] = from_union([to_float, lambda x: to_class(Typealias, x), from_none], self.typealias)
4963+ if self.typedef is not None:
4964+ result["typedef"] = from_union([to_float, lambda x: to_class(Typedef, x), from_none], self.typedef)
4965+ if self.typeid is not None:
4966+ result["typeid"] = from_union([to_float, lambda x: to_class(Typeid, x), from_none], self.typeid)
4967+ if self.typename is not None:
4968+ result["typename"] = from_union([to_float, lambda x: to_class(Typename, x), from_none], self.typename)
4969+ if self.typeof is not None:
4970+ result["typeof"] = from_union([to_float, lambda x: to_class(Typeof, x), from_none], self.typeof)
4971+ if self.uint is not None:
4972+ result["uint"] = from_union([to_float, lambda x: to_class(Uint, x), from_none], self.uint)
4973+ if self.ulong is not None:
4974+ result["ulong"] = from_union([to_float, lambda x: to_class(Ulong, x), from_none], self.ulong)
4975+ if self.unchecked is not None:
4976+ result["unchecked"] = from_union([to_float, lambda x: to_class(Unchecked, x), from_none], self.unchecked)
4977+ if self.undefined is not None:
4978+ result["undefined"] = from_union([to_float, lambda x: to_class(Undefined, x), from_none], self.undefined)
4979+ if self.union is not None:
4980+ result["union"] = from_union([to_float, lambda x: to_class(UnionClass, x), from_none], self.union)
4981+ if self.unowned is not None:
4982+ result["unowned"] = from_union([to_float, lambda x: to_class(Unowned, x), from_none], self.unowned)
4983+ if self.unsafe is not None:
4984+ result["unsafe"] = from_union([to_float, lambda x: to_class(Unsafe, x), from_none], self.unsafe)
4985+ if self.unsigned is not None:
4986+ result["unsigned"] = from_union([to_float, lambda x: to_class(Unsigned, x), from_none], self.unsigned)
4987+ if self.ushort is not None:
4988+ result["ushort"] = from_union([to_float, lambda x: to_class(Ushort, x), from_none], self.ushort)
4989+ if self.using is not None:
4990+ result["using"] = from_union([to_float, lambda x: to_class(Using, x), from_none], self.using)
4991+ if self.var is not None:
4992+ result["var"] = from_union([to_float, lambda x: to_class(Var, x), from_none], self.var)
4993+ if self.virtual is not None:
4994+ result["virtual"] = from_union([to_float, lambda x: to_class(Virtual, x), from_none], self.virtual)
4995+ if self.void is not None:
4996+ result["void"] = from_union([to_float, lambda x: to_class(Void, x), from_none], self.void)
4997+ if self.volatile is not None:
4998+ result["volatile"] = from_union([to_float, lambda x: to_class(Volatile, x), from_none], self.volatile)
4999+ if self.wchar_t is not None:
5000+ result["wchar_t"] = from_union([to_float, lambda x: to_class(WcharT, x), from_none], self.wchar_t)
5001+ if self.weak is not None:
5002+ result["weak"] = from_union([to_float, lambda x: to_class(Weak, x), from_none], self.weak)
5003+ if self.where is not None:
5004+ result["where"] = from_union([to_float, lambda x: to_class(Where, x), from_none], self.where)
5005+ if self.top_level_while is not None:
5006+ result["while"] = from_union([to_float, lambda x: to_class(While, x), from_none], self.top_level_while)
5007+ if self.will_set is not None:
5008+ result["willSet"] = from_union([to_float, lambda x: to_class(WillSet, x), from_none], self.will_set)
5009+ if self.top_level_with is not None:
5010+ result["with"] = from_union([to_float, lambda x: to_class(With, x), from_none], self.top_level_with)
5011+ if self.xor is not None:
5012+ result["xor"] = from_union([to_float, lambda x: to_class(Xor, x), from_none], self.xor)
5013+ if self.xor_eq is not None:
5014+ result["xor_eq"] = from_union([to_float, lambda x: to_class(XorEq, x), from_none], self.xor_eq)
5015+ if self.yes is not None:
5016+ result["YES"] = from_union([to_float, lambda x: to_class(Yes, x), from_none], self.yes)
5017+ if self.top_level_yield is not None:
5018+ result["yield"] = from_union([to_float, lambda x: to_class(Yield, x), from_none], self.top_level_yield)
5019+ return result
5020+
5021+
5022+def top_level_from_dict(s: Any) -> TopLevel:
5023+ return TopLevel.from_dict(s)
5024+
5025+
5026+def top_level_to_dict(x: TopLevel) -> Any:
5027+ return to_class(TopLevel, x)
No generated files match these filters.