Generated-output differences

quicktype output changed between the PR base and tested PR merge revisions.
← Back to the pull request
2test cases
2files differ
0modified
2new
0deleted
9,594changed lines
+9,594 −0insertions / deletions
Base f17a105e145cb0ca4cabf8b239cd11f0515fe410 · PR merge 89c71b2b0b0daa04f3d899c6f74a0ce9c15e9759 · Head e2c0a8904e13b91e0da9cfd9dfed6c58d4f5c1e1 · raw patch
Test case

test/inputs/json/priority/keywords.json

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

test/inputs/schema/keyword-unions.schema

1 generated file · +3,889 −0
Aschema-dartdefault / TopLevel.dart+3,889 −0
@@ -0,0 +1,3889 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final dynamic empty;
13+ final dynamic purpleBool;
14+ final dynamic complex;
15+ final dynamic imaginery;
16+ final dynamic topLevelAbstract;
17+ final dynamic alignas;
18+ final dynamic alignof;
19+ final dynamic and;
20+ final dynamic andEq;
21+ final dynamic topLevelAny;
22+ final dynamic any;
23+ final dynamic array;
24+ final dynamic topLevelAs;
25+ final dynamic asm;
26+ final dynamic topLevelAssert;
27+ final dynamic associatedtype;
28+ final dynamic associativity;
29+ final dynamic topLevelAsync;
30+ final dynamic atomic;
31+ final dynamic atomicCancel;
32+ final dynamic atomicCommit;
33+ final dynamic atomicNoexcept;
34+ final dynamic auto;
35+ final dynamic topLevelAwait;
36+ final dynamic base;
37+ final dynamic bitand;
38+ final dynamic bitor;
39+ final dynamic topLevelBool;
40+ final dynamic fluffyBool;
41+ final dynamic boolean;
42+ final dynamic topLevelBreak;
43+ final dynamic bycopy;
44+ final dynamic byref;
45+ final dynamic byte;
46+ final dynamic topLevelCase;
47+ final dynamic topLevelCatch;
48+ final dynamic chan;
49+ final dynamic char;
50+ final dynamic char16T;
51+ final dynamic char32T;
52+ final dynamic checked;
53+ final dynamic purpleClass;
54+ final dynamic topLevelClass;
55+ final dynamic coAwait;
56+ final dynamic coReturn;
57+ final dynamic coYield;
58+ final dynamic compl;
59+ final dynamic concept;
60+ final dynamic console;
61+ final dynamic topLevelConst;
62+ final dynamic constCast;
63+ final dynamic constexpr;
64+ final dynamic constructor;
65+ final dynamic topLevelContinue;
66+ final dynamic convenience;
67+ final dynamic convert;
68+ final dynamic converter;
69+ final dynamic date;
70+ final dynamic dateParseHandling;
71+ final dynamic debugger;
72+ final dynamic decimal;
73+ final dynamic declare;
74+ final dynamic decltype;
75+ final dynamic decodeString;
76+ final dynamic def;
77+ final dynamic topLevelDefault;
78+ final dynamic defer;
79+ final dynamic deinit;
80+ final dynamic del;
81+ final dynamic delegate;
82+ final dynamic delete;
83+ final dynamic dict;
84+ final dynamic dictionary;
85+ final dynamic didSet;
86+ final dynamic topLevelDo;
87+ final dynamic topLevelDouble;
88+ final double? dummy;
89+ final dynamic topLevelDynamic;
90+ final dynamic dynamicCast;
91+ final dynamic elif;
92+ final dynamic topLevelElse;
93+ final dynamic encodeQuickType;
94+ final dynamic topLevelEnum;
95+ final dynamic event;
96+ final dynamic except;
97+ final dynamic exception;
98+ final dynamic explicit;
99+ final dynamic topLevelExport;
100+ final dynamic exposing;
101+ final dynamic topLevelExtends;
102+ final dynamic extension;
103+ final dynamic extern;
104+ final dynamic fallthrough;
105+ final dynamic purpleFalse;
106+ final dynamic topLevelFalse;
107+ final dynamic fileprivate;
108+ final dynamic topLevelFinal;
109+ final dynamic topLevelFinally;
110+ final dynamic fixed;
111+ final dynamic float;
112+ final dynamic topLevelFor;
113+ final dynamic foreach;
114+ final dynamic friend;
115+ final dynamic from;
116+ final dynamic topLevelFromJson;
117+ final dynamic func;
118+ final dynamic function;
119+ final dynamic topLevelGet;
120+ final dynamic global;
121+ final dynamic go;
122+ final dynamic goto;
123+ final dynamic guard;
124+ final dynamic hasOwnProperty;
125+ final dynamic id;
126+ final dynamic topLevelIf;
127+ final dynamic imp;
128+ final dynamic topLevelImplements;
129+ final dynamic implicit;
130+ final dynamic topLevelImport;
131+ final dynamic topLevelIn;
132+ final dynamic indirect;
133+ final dynamic infix;
134+ final dynamic init;
135+ final dynamic inline;
136+ final dynamic inout;
137+ final dynamic instanceof;
138+ final dynamic topLevelInt;
139+ final dynamic topLevelInterface;
140+ final dynamic internal;
141+ final dynamic topLevelIs;
142+ final dynamic iterable;
143+ final dynamic jdec;
144+ final dynamic jenc;
145+ final dynamic jpipe;
146+ final dynamic json;
147+ final dynamic jsonConverter;
148+ final dynamic jsonSerializer;
149+ final dynamic jsonToken;
150+ final dynamic jsonWriter;
151+ final dynamic lambda;
152+ final dynamic lazy;
153+ final dynamic left;
154+ final dynamic let;
155+ final dynamic list;
156+ final dynamic lock;
157+ final dynamic long;
158+ final dynamic map;
159+ final dynamic metadataPropertyHandling;
160+ final dynamic module;
161+ final dynamic mutable;
162+ final dynamic mutating;
163+ final dynamic namespace;
164+ final dynamic native;
165+ final dynamic topLevelNew;
166+ final dynamic newtonsoft;
167+ final dynamic nil;
168+ final dynamic no;
169+ final dynamic noexcept;
170+ final dynamic nonatomic;
171+ final dynamic topLevelNone;
172+ final dynamic none;
173+ final dynamic nonlocal;
174+ final dynamic nonmutating;
175+ final dynamic not;
176+ final dynamic notEq;
177+ final dynamic nsString;
178+ final dynamic topLevelNull;
179+ final dynamic purpleNull;
180+ final dynamic nullptr;
181+ final dynamic number;
182+ final dynamic object;
183+ final dynamic of;
184+ final dynamic oneway;
185+ final dynamic open;
186+ final dynamic topLevelOperator;
187+ final dynamic optional;
188+ final dynamic or;
189+ final dynamic orEq;
190+ final dynamic out;
191+ final dynamic override;
192+ final dynamic package;
193+ final dynamic params;
194+ final dynamic pass;
195+ final dynamic port;
196+ final dynamic postfix;
197+ final dynamic precedence;
198+ final dynamic prefix;
199+ final dynamic print;
200+ final dynamic printf;
201+ final dynamic private;
202+ final dynamic protected;
203+ final dynamic protocol;
204+ final dynamic topLevelProtocol;
205+ final dynamic public;
206+ final dynamic quicktype;
207+ final dynamic raise;
208+ final dynamic range;
209+ final dynamic readonly;
210+ final dynamic ref;
211+ final dynamic register;
212+ final dynamic reinterpretCast;
213+ final dynamic repeat;
214+ final dynamic require;
215+ final dynamic required;
216+ final dynamic requires;
217+ final dynamic restrict;
218+ final dynamic retain;
219+ final dynamic rethrows;
220+ final dynamic topLevelReturn;
221+ final dynamic right;
222+ final dynamic sbyte;
223+ final dynamic sealed;
224+ final dynamic sel;
225+ final dynamic select;
226+ final dynamic self;
227+ final dynamic topLevelSelf;
228+ final dynamic serialize;
229+ final dynamic topLevelSet;
230+ final dynamic short;
231+ final dynamic signed;
232+ final dynamic sizeof;
233+ final dynamic stackalloc;
234+ final dynamic topLevelStatic;
235+ final dynamic staticAssert;
236+ final dynamic staticCast;
237+ final dynamic strictfp;
238+ final dynamic string;
239+ final dynamic struct;
240+ final dynamic subscript;
241+ final dynamic topLevelSuper;
242+ final dynamic topLevelSwitch;
243+ final dynamic symbol;
244+ final dynamic synchronized;
245+ final dynamic system;
246+ final dynamic template;
247+ final dynamic then;
248+ final dynamic topLevelThis;
249+ final dynamic threadLocal;
250+ final dynamic topLevelThrow;
251+ final dynamic throws;
252+ final dynamic topLevelToJson;
253+ final dynamic topLevel;
254+ final dynamic transient;
255+ final dynamic topLevelTrue;
256+ final dynamic purpleTrue;
257+ final dynamic topLevelTry;
258+ final dynamic type;
259+ final dynamic topLevelType;
260+ final dynamic typealias;
261+ final dynamic topLevelTypedef;
262+ final dynamic typeid;
263+ final dynamic typename;
264+ final dynamic typeof;
265+ final dynamic uint;
266+ final dynamic ulong;
267+ final dynamic unchecked;
268+ final dynamic undefined;
269+ final dynamic union;
270+ final dynamic unowned;
271+ final dynamic unsafe;
272+ final dynamic unsigned;
273+ final dynamic ushort;
274+ final dynamic using;
275+ final dynamic topLevelVar;
276+ final dynamic virtual;
277+ final dynamic topLevelVoid;
278+ final dynamic volatile;
279+ final dynamic wcharT;
280+ final dynamic weak;
281+ final dynamic where;
282+ final dynamic topLevelWhile;
283+ final dynamic willSet;
284+ final dynamic topLevelWith;
285+ final dynamic xor;
286+ final dynamic xorEq;
287+ final dynamic yes;
288+ final dynamic topLevelYield;
289+
290+ TopLevel({
291+ this.empty,
292+ this.purpleBool,
293+ this.complex,
294+ this.imaginery,
295+ this.topLevelAbstract,
296+ this.alignas,
297+ this.alignof,
298+ this.and,
299+ this.andEq,
300+ this.topLevelAny,
301+ this.any,
302+ this.array,
303+ this.topLevelAs,
304+ this.asm,
305+ this.topLevelAssert,
306+ this.associatedtype,
307+ this.associativity,
308+ this.topLevelAsync,
309+ this.atomic,
310+ this.atomicCancel,
311+ this.atomicCommit,
312+ this.atomicNoexcept,
313+ this.auto,
314+ this.topLevelAwait,
315+ this.base,
316+ this.bitand,
317+ this.bitor,
318+ this.topLevelBool,
319+ this.fluffyBool,
320+ this.boolean,
321+ this.topLevelBreak,
322+ this.bycopy,
323+ this.byref,
324+ this.byte,
325+ this.topLevelCase,
326+ this.topLevelCatch,
327+ this.chan,
328+ this.char,
329+ this.char16T,
330+ this.char32T,
331+ this.checked,
332+ this.purpleClass,
333+ this.topLevelClass,
334+ this.coAwait,
335+ this.coReturn,
336+ this.coYield,
337+ this.compl,
338+ this.concept,
339+ this.console,
340+ this.topLevelConst,
341+ this.constCast,
342+ this.constexpr,
343+ this.constructor,
344+ this.topLevelContinue,
345+ this.convenience,
346+ this.convert,
347+ this.converter,
348+ this.date,
349+ this.dateParseHandling,
350+ this.debugger,
351+ this.decimal,
352+ this.declare,
353+ this.decltype,
354+ this.decodeString,
355+ this.def,
356+ this.topLevelDefault,
357+ this.defer,
358+ this.deinit,
359+ this.del,
360+ this.delegate,
361+ this.delete,
362+ this.dict,
363+ this.dictionary,
364+ this.didSet,
365+ this.topLevelDo,
366+ this.topLevelDouble,
367+ this.dummy,
368+ this.topLevelDynamic,
369+ this.dynamicCast,
370+ this.elif,
371+ this.topLevelElse,
372+ this.encodeQuickType,
373+ this.topLevelEnum,
374+ this.event,
375+ this.except,
376+ this.exception,
377+ this.explicit,
378+ this.topLevelExport,
379+ this.exposing,
380+ this.topLevelExtends,
381+ this.extension,
382+ this.extern,
383+ this.fallthrough,
384+ this.purpleFalse,
385+ this.topLevelFalse,
386+ this.fileprivate,
387+ this.topLevelFinal,
388+ this.topLevelFinally,
389+ this.fixed,
390+ this.float,
391+ this.topLevelFor,
392+ this.foreach,
393+ this.friend,
394+ this.from,
395+ this.topLevelFromJson,
396+ this.func,
397+ this.function,
398+ this.topLevelGet,
399+ this.global,
400+ this.go,
401+ this.goto,
402+ this.guard,
403+ this.hasOwnProperty,
404+ this.id,
405+ this.topLevelIf,
406+ this.imp,
407+ this.topLevelImplements,
408+ this.implicit,
409+ this.topLevelImport,
410+ this.topLevelIn,
411+ this.indirect,
412+ this.infix,
413+ this.init,
414+ this.inline,
415+ this.inout,
416+ this.instanceof,
417+ this.topLevelInt,
418+ this.topLevelInterface,
419+ this.internal,
420+ this.topLevelIs,
421+ this.iterable,
422+ this.jdec,
423+ this.jenc,
424+ this.jpipe,
425+ this.json,
426+ this.jsonConverter,
427+ this.jsonSerializer,
428+ this.jsonToken,
429+ this.jsonWriter,
430+ this.lambda,
431+ this.lazy,
432+ this.left,
433+ this.let,
434+ this.list,
435+ this.lock,
436+ this.long,
437+ this.map,
438+ this.metadataPropertyHandling,
439+ this.module,
440+ this.mutable,
441+ this.mutating,
442+ this.namespace,
443+ this.native,
444+ this.topLevelNew,
445+ this.newtonsoft,
446+ this.nil,
447+ this.no,
448+ this.noexcept,
449+ this.nonatomic,
450+ this.topLevelNone,
451+ this.none,
452+ this.nonlocal,
453+ this.nonmutating,
454+ this.not,
455+ this.notEq,
456+ this.nsString,
457+ this.topLevelNull,
458+ this.purpleNull,
459+ this.nullptr,
460+ this.number,
461+ this.object,
462+ this.of,
463+ this.oneway,
464+ this.open,
465+ this.topLevelOperator,
466+ this.optional,
467+ this.or,
468+ this.orEq,
469+ this.out,
470+ this.override,
471+ this.package,
472+ this.params,
473+ this.pass,
474+ this.port,
475+ this.postfix,
476+ this.precedence,
477+ this.prefix,
478+ this.print,
479+ this.printf,
480+ this.private,
481+ this.protected,
482+ this.protocol,
483+ this.topLevelProtocol,
484+ this.public,
485+ this.quicktype,
486+ this.raise,
487+ this.range,
488+ this.readonly,
489+ this.ref,
490+ this.register,
491+ this.reinterpretCast,
492+ this.repeat,
493+ this.require,
494+ this.required,
495+ this.requires,
496+ this.restrict,
497+ this.retain,
498+ this.rethrows,
499+ this.topLevelReturn,
500+ this.right,
501+ this.sbyte,
502+ this.sealed,
503+ this.sel,
504+ this.select,
505+ this.self,
506+ this.topLevelSelf,
507+ this.serialize,
508+ this.topLevelSet,
509+ this.short,
510+ this.signed,
511+ this.sizeof,
512+ this.stackalloc,
513+ this.topLevelStatic,
514+ this.staticAssert,
515+ this.staticCast,
516+ this.strictfp,
517+ this.string,
518+ this.struct,
519+ this.subscript,
520+ this.topLevelSuper,
521+ this.topLevelSwitch,
522+ this.symbol,
523+ this.synchronized,
524+ this.system,
525+ this.template,
526+ this.then,
527+ this.topLevelThis,
528+ this.threadLocal,
529+ this.topLevelThrow,
530+ this.throws,
531+ this.topLevelToJson,
532+ this.topLevel,
533+ this.transient,
534+ this.topLevelTrue,
535+ this.purpleTrue,
536+ this.topLevelTry,
537+ this.type,
538+ this.topLevelType,
539+ this.typealias,
540+ this.topLevelTypedef,
541+ this.typeid,
542+ this.typename,
543+ this.typeof,
544+ this.uint,
545+ this.ulong,
546+ this.unchecked,
547+ this.undefined,
548+ this.union,
549+ this.unowned,
550+ this.unsafe,
551+ this.unsigned,
552+ this.ushort,
553+ this.using,
554+ this.topLevelVar,
555+ this.virtual,
556+ this.topLevelVoid,
557+ this.volatile,
558+ this.wcharT,
559+ this.weak,
560+ this.where,
561+ this.topLevelWhile,
562+ this.willSet,
563+ this.topLevelWith,
564+ this.xor,
565+ this.xorEq,
566+ this.yes,
567+ this.topLevelYield,
568+ });
569+
570+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
571+ empty: json["_"],
572+ purpleBool: json["_Bool"],
573+ complex: json["_Complex"],
574+ imaginery: json["_Imaginery"],
575+ topLevelAbstract: json["abstract"],
576+ alignas: json["alignas"],
577+ alignof: json["alignof"],
578+ and: json["and"],
579+ andEq: json["and_eq"],
580+ topLevelAny: json["any"],
581+ any: json["Any"],
582+ array: json["array"],
583+ topLevelAs: json["as"],
584+ asm: json["asm"],
585+ topLevelAssert: json["assert"],
586+ associatedtype: json["associatedtype"],
587+ associativity: json["associativity"],
588+ topLevelAsync: json["async"],
589+ atomic: json["atomic"],
590+ atomicCancel: json["atomic_cancel"],
591+ atomicCommit: json["atomic_commit"],
592+ atomicNoexcept: json["atomic_noexcept"],
593+ auto: json["auto"],
594+ topLevelAwait: json["await"],
595+ base: json["base"],
596+ bitand: json["bitand"],
597+ bitor: json["bitor"],
598+ topLevelBool: json["BOOL"],
599+ fluffyBool: json["bool"],
600+ boolean: json["boolean"],
601+ topLevelBreak: json["break"],
602+ bycopy: json["bycopy"],
603+ byref: json["byref"],
604+ byte: json["byte"],
605+ topLevelCase: json["case"],
606+ topLevelCatch: json["catch"],
607+ chan: json["chan"],
608+ char: json["char"],
609+ char16T: json["char16_t"],
610+ char32T: json["char32_t"],
611+ checked: json["checked"],
612+ purpleClass: json["class"],
613+ topLevelClass: json["Class"],
614+ coAwait: json["co_await"],
615+ coReturn: json["co_return"],
616+ coYield: json["co_yield"],
617+ compl: json["compl"],
618+ concept: json["concept"],
619+ console: json["console"],
620+ topLevelConst: json["const"],
621+ constCast: json["const_cast"],
622+ constexpr: json["constexpr"],
623+ constructor: json["constructor"],
624+ topLevelContinue: json["continue"],
625+ convenience: json["convenience"],
626+ convert: json["convert"],
627+ converter: json["converter"],
628+ date: json["date"],
629+ dateParseHandling: json["date_parse_handling"],
630+ debugger: json["debugger"],
631+ decimal: json["decimal"],
632+ declare: json["declare"],
633+ decltype: json["decltype"],
634+ decodeString: json["decode_string"],
635+ def: json["def"],
636+ topLevelDefault: json["default"],
637+ defer: json["defer"],
638+ deinit: json["deinit"],
639+ del: json["del"],
640+ delegate: json["delegate"],
641+ delete: json["delete"],
642+ dict: json["dict"],
643+ dictionary: json["dictionary"],
644+ didSet: json["didSet"],
645+ topLevelDo: json["do"],
646+ topLevelDouble: json["double"],
647+ dummy: json["dummy"]?.toDouble(),
648+ topLevelDynamic: json["dynamic"],
649+ dynamicCast: json["dynamic_cast"],
650+ elif: json["elif"],
651+ topLevelElse: json["else"],
652+ encodeQuickType: json["encode_quick_type"],
653+ topLevelEnum: json["enum"],
654+ event: json["event"],
655+ except: json["except"],
656+ exception: json["exception"],
657+ explicit: json["explicit"],
658+ topLevelExport: json["export"],
659+ exposing: json["exposing"],
660+ topLevelExtends: json["extends"],
661+ extension: json["extension"],
662+ extern: json["extern"],
663+ fallthrough: json["fallthrough"],
664+ purpleFalse: json["false"],
665+ topLevelFalse: json["False"],
666+ fileprivate: json["fileprivate"],
667+ topLevelFinal: json["final"],
668+ topLevelFinally: json["finally"],
669+ fixed: json["fixed"],
670+ float: json["float"],
671+ topLevelFor: json["for"],
672+ foreach: json["foreach"],
673+ friend: json["friend"],
674+ from: json["from"],
675+ topLevelFromJson: json["from_json"],
676+ func: json["func"],
677+ function: json["function"],
678+ topLevelGet: json["get"],
679+ global: json["global"],
680+ go: json["go"],
681+ goto: json["goto"],
682+ guard: json["guard"],
683+ hasOwnProperty: json["hasOwnProperty"],
684+ id: json["id"],
685+ topLevelIf: json["if"],
686+ imp: json["IMP"],
687+ topLevelImplements: json["implements"],
688+ implicit: json["implicit"],
689+ topLevelImport: json["import"],
690+ topLevelIn: json["in"],
691+ indirect: json["indirect"],
692+ infix: json["infix"],
693+ init: json["init"],
694+ inline: json["inline"],
695+ inout: json["inout"],
696+ instanceof: json["instanceof"],
697+ topLevelInt: json["int"],
698+ topLevelInterface: json["interface"],
699+ internal: json["internal"],
700+ topLevelIs: json["is"],
701+ iterable: json["iterable"],
702+ jdec: json["jdec"],
703+ jenc: json["jenc"],
704+ jpipe: json["jpipe"],
705+ json: json["json"],
706+ jsonConverter: json["json_converter"],
707+ jsonSerializer: json["json_serializer"],
708+ jsonToken: json["json_token"],
709+ jsonWriter: json["json_writer"],
710+ lambda: json["lambda"],
711+ lazy: json["lazy"],
712+ left: json["left"],
713+ let: json["let"],
714+ list: json["list"],
715+ lock: json["lock"],
716+ long: json["long"],
717+ map: json["map"],
718+ metadataPropertyHandling: json["metadata_property_handling"],
719+ module: json["module"],
720+ mutable: json["mutable"],
721+ mutating: json["mutating"],
722+ namespace: json["namespace"],
723+ native: json["native"],
724+ topLevelNew: json["new"],
725+ newtonsoft: json["newtonsoft"],
726+ nil: json["nil"],
727+ no: json["NO"],
728+ noexcept: json["noexcept"],
729+ nonatomic: json["nonatomic"],
730+ topLevelNone: json["none"],
731+ none: json["None"],
732+ nonlocal: json["nonlocal"],
733+ nonmutating: json["nonmutating"],
734+ not: json["not"],
735+ notEq: json["not_eq"],
736+ nsString: json["NSString"],
737+ topLevelNull: json["NULL"],
738+ purpleNull: json["null"],
739+ nullptr: json["nullptr"],
740+ number: json["number"],
741+ object: json["object"],
742+ of: json["of"],
743+ oneway: json["oneway"],
744+ open: json["open"],
745+ topLevelOperator: json["operator"],
746+ optional: json["optional"],
747+ or: json["or"],
748+ orEq: json["or_eq"],
749+ out: json["out"],
750+ override: json["override"],
751+ package: json["package"],
752+ params: json["params"],
753+ pass: json["pass"],
754+ port: json["port"],
755+ postfix: json["postfix"],
756+ precedence: json["precedence"],
757+ prefix: json["prefix"],
758+ print: json["print"],
759+ printf: json["printf"],
760+ private: json["private"],
761+ protected: json["protected"],
762+ protocol: json["Protocol"],
763+ topLevelProtocol: json["protocol"],
764+ public: json["public"],
765+ quicktype: json["quicktype"],
766+ raise: json["raise"],
767+ range: json["range"],
768+ readonly: json["readonly"],
769+ ref: json["ref"],
770+ register: json["register"],
771+ reinterpretCast: json["reinterpret_cast"],
772+ repeat: json["repeat"],
773+ require: json["require"],
774+ required: json["required"],
775+ requires: json["requires"],
776+ restrict: json["restrict"],
777+ retain: json["retain"],
778+ rethrows: json["rethrows"],
779+ topLevelReturn: json["return"],
780+ right: json["right"],
781+ sbyte: json["sbyte"],
782+ sealed: json["sealed"],
783+ sel: json["SEL"],
784+ select: json["select"],
785+ self: json["Self"],
786+ topLevelSelf: json["self"],
787+ serialize: json["serialize"],
788+ topLevelSet: json["set"],
789+ short: json["short"],
790+ signed: json["signed"],
791+ sizeof: json["sizeof"],
792+ stackalloc: json["stackalloc"],
793+ topLevelStatic: json["static"],
794+ staticAssert: json["static_assert"],
795+ staticCast: json["static_cast"],
796+ strictfp: json["strictfp"],
797+ string: json["string"],
798+ struct: json["struct"],
799+ subscript: json["subscript"],
800+ topLevelSuper: json["super"],
801+ topLevelSwitch: json["switch"],
802+ symbol: json["symbol"],
803+ synchronized: json["synchronized"],
804+ system: json["system"],
805+ template: json["template"],
806+ then: json["then"],
807+ topLevelThis: json["this"],
808+ threadLocal: json["thread_local"],
809+ topLevelThrow: json["throw"],
810+ throws: json["throws"],
811+ topLevelToJson: json["to_json"],
812+ topLevel: json["top_level"],
813+ transient: json["transient"],
814+ topLevelTrue: json["True"],
815+ purpleTrue: json["true"],
816+ topLevelTry: json["try"],
817+ type: json["Type"],
818+ topLevelType: json["type"],
819+ typealias: json["typealias"],
820+ topLevelTypedef: json["typedef"],
821+ typeid: json["typeid"],
822+ typename: json["typename"],
823+ typeof: json["typeof"],
824+ uint: json["uint"],
825+ ulong: json["ulong"],
826+ unchecked: json["unchecked"],
827+ undefined: json["undefined"],
828+ union: json["union"],
829+ unowned: json["unowned"],
830+ unsafe: json["unsafe"],
831+ unsigned: json["unsigned"],
832+ ushort: json["ushort"],
833+ using: json["using"],
834+ topLevelVar: json["var"],
835+ virtual: json["virtual"],
836+ topLevelVoid: json["void"],
837+ volatile: json["volatile"],
838+ wcharT: json["wchar_t"],
839+ weak: json["weak"],
840+ where: json["where"],
841+ topLevelWhile: json["while"],
842+ willSet: json["willSet"],
843+ topLevelWith: json["with"],
844+ xor: json["xor"],
845+ xorEq: json["xor_eq"],
846+ yes: json["YES"],
847+ topLevelYield: json["yield"],
848+ );
849+
850+ Map<String, dynamic> toJson() => {
851+ "_": empty,
852+ "_Bool": purpleBool,
853+ "_Complex": complex,
854+ "_Imaginery": imaginery,
855+ "abstract": topLevelAbstract,
856+ "alignas": alignas,
857+ "alignof": alignof,
858+ "and": and,
859+ "and_eq": andEq,
860+ "any": topLevelAny,
861+ "Any": any,
862+ "array": array,
863+ "as": topLevelAs,
864+ "asm": asm,
865+ "assert": topLevelAssert,
866+ "associatedtype": associatedtype,
867+ "associativity": associativity,
868+ "async": topLevelAsync,
869+ "atomic": atomic,
870+ "atomic_cancel": atomicCancel,
871+ "atomic_commit": atomicCommit,
872+ "atomic_noexcept": atomicNoexcept,
873+ "auto": auto,
874+ "await": topLevelAwait,
875+ "base": base,
876+ "bitand": bitand,
877+ "bitor": bitor,
878+ "BOOL": topLevelBool,
879+ "bool": fluffyBool,
880+ "boolean": boolean,
881+ "break": topLevelBreak,
882+ "bycopy": bycopy,
883+ "byref": byref,
884+ "byte": byte,
885+ "case": topLevelCase,
886+ "catch": topLevelCatch,
887+ "chan": chan,
888+ "char": char,
889+ "char16_t": char16T,
890+ "char32_t": char32T,
891+ "checked": checked,
892+ "class": purpleClass,
893+ "Class": topLevelClass,
894+ "co_await": coAwait,
895+ "co_return": coReturn,
896+ "co_yield": coYield,
897+ "compl": compl,
898+ "concept": concept,
899+ "console": console,
900+ "const": topLevelConst,
901+ "const_cast": constCast,
902+ "constexpr": constexpr,
903+ "constructor": constructor,
904+ "continue": topLevelContinue,
905+ "convenience": convenience,
906+ "convert": convert,
907+ "converter": converter,
908+ "date": date,
909+ "date_parse_handling": dateParseHandling,
910+ "debugger": debugger,
911+ "decimal": decimal,
912+ "declare": declare,
913+ "decltype": decltype,
914+ "decode_string": decodeString,
915+ "def": def,
916+ "default": topLevelDefault,
917+ "defer": defer,
918+ "deinit": deinit,
919+ "del": del,
920+ "delegate": delegate,
921+ "delete": delete,
922+ "dict": dict,
923+ "dictionary": dictionary,
924+ "didSet": didSet,
925+ "do": topLevelDo,
926+ "double": topLevelDouble,
927+ "dummy": dummy,
928+ "dynamic": topLevelDynamic,
929+ "dynamic_cast": dynamicCast,
930+ "elif": elif,
931+ "else": topLevelElse,
932+ "encode_quick_type": encodeQuickType,
933+ "enum": topLevelEnum,
934+ "event": event,
935+ "except": except,
936+ "exception": exception,
937+ "explicit": explicit,
938+ "export": topLevelExport,
939+ "exposing": exposing,
940+ "extends": topLevelExtends,
941+ "extension": extension,
942+ "extern": extern,
943+ "fallthrough": fallthrough,
944+ "false": purpleFalse,
945+ "False": topLevelFalse,
946+ "fileprivate": fileprivate,
947+ "final": topLevelFinal,
948+ "finally": topLevelFinally,
949+ "fixed": fixed,
950+ "float": float,
951+ "for": topLevelFor,
952+ "foreach": foreach,
953+ "friend": friend,
954+ "from": from,
955+ "from_json": topLevelFromJson,
956+ "func": func,
957+ "function": function,
958+ "get": topLevelGet,
959+ "global": global,
960+ "go": go,
961+ "goto": goto,
962+ "guard": guard,
963+ "hasOwnProperty": hasOwnProperty,
964+ "id": id,
965+ "if": topLevelIf,
966+ "IMP": imp,
967+ "implements": topLevelImplements,
968+ "implicit": implicit,
969+ "import": topLevelImport,
970+ "in": topLevelIn,
971+ "indirect": indirect,
972+ "infix": infix,
973+ "init": init,
974+ "inline": inline,
975+ "inout": inout,
976+ "instanceof": instanceof,
977+ "int": topLevelInt,
978+ "interface": topLevelInterface,
979+ "internal": internal,
980+ "is": topLevelIs,
981+ "iterable": iterable,
982+ "jdec": jdec,
983+ "jenc": jenc,
984+ "jpipe": jpipe,
985+ "json": json,
986+ "json_converter": jsonConverter,
987+ "json_serializer": jsonSerializer,
988+ "json_token": jsonToken,
989+ "json_writer": jsonWriter,
990+ "lambda": lambda,
991+ "lazy": lazy,
992+ "left": left,
993+ "let": let,
994+ "list": list,
995+ "lock": lock,
996+ "long": long,
997+ "map": map,
998+ "metadata_property_handling": metadataPropertyHandling,
999+ "module": module,
1000+ "mutable": mutable,
1001+ "mutating": mutating,
1002+ "namespace": namespace,
1003+ "native": native,
1004+ "new": topLevelNew,
1005+ "newtonsoft": newtonsoft,
1006+ "nil": nil,
1007+ "NO": no,
1008+ "noexcept": noexcept,
1009+ "nonatomic": nonatomic,
1010+ "none": topLevelNone,
1011+ "None": none,
1012+ "nonlocal": nonlocal,
1013+ "nonmutating": nonmutating,
1014+ "not": not,
1015+ "not_eq": notEq,
1016+ "NSString": nsString,
1017+ "NULL": topLevelNull,
1018+ "null": purpleNull,
1019+ "nullptr": nullptr,
1020+ "number": number,
1021+ "object": object,
1022+ "of": of,
1023+ "oneway": oneway,
1024+ "open": open,
1025+ "operator": topLevelOperator,
1026+ "optional": optional,
1027+ "or": or,
1028+ "or_eq": orEq,
1029+ "out": out,
1030+ "override": override,
1031+ "package": package,
1032+ "params": params,
1033+ "pass": pass,
1034+ "port": port,
1035+ "postfix": postfix,
1036+ "precedence": precedence,
1037+ "prefix": prefix,
1038+ "print": print,
1039+ "printf": printf,
1040+ "private": private,
1041+ "protected": protected,
1042+ "Protocol": protocol,
1043+ "protocol": topLevelProtocol,
1044+ "public": public,
1045+ "quicktype": quicktype,
1046+ "raise": raise,
1047+ "range": range,
1048+ "readonly": readonly,
1049+ "ref": ref,
1050+ "register": register,
1051+ "reinterpret_cast": reinterpretCast,
1052+ "repeat": repeat,
1053+ "require": require,
1054+ "required": required,
1055+ "requires": requires,
1056+ "restrict": restrict,
1057+ "retain": retain,
1058+ "rethrows": rethrows,
1059+ "return": topLevelReturn,
1060+ "right": right,
1061+ "sbyte": sbyte,
1062+ "sealed": sealed,
1063+ "SEL": sel,
1064+ "select": select,
1065+ "Self": self,
1066+ "self": topLevelSelf,
1067+ "serialize": serialize,
1068+ "set": topLevelSet,
1069+ "short": short,
1070+ "signed": signed,
1071+ "sizeof": sizeof,
1072+ "stackalloc": stackalloc,
1073+ "static": topLevelStatic,
1074+ "static_assert": staticAssert,
1075+ "static_cast": staticCast,
1076+ "strictfp": strictfp,
1077+ "string": string,
1078+ "struct": struct,
1079+ "subscript": subscript,
1080+ "super": topLevelSuper,
1081+ "switch": topLevelSwitch,
1082+ "symbol": symbol,
1083+ "synchronized": synchronized,
1084+ "system": system,
1085+ "template": template,
1086+ "then": then,
1087+ "this": topLevelThis,
1088+ "thread_local": threadLocal,
1089+ "throw": topLevelThrow,
1090+ "throws": throws,
1091+ "to_json": topLevelToJson,
1092+ "top_level": topLevel,
1093+ "transient": transient,
1094+ "True": topLevelTrue,
1095+ "true": purpleTrue,
1096+ "try": topLevelTry,
1097+ "Type": type,
1098+ "type": topLevelType,
1099+ "typealias": typealias,
1100+ "typedef": topLevelTypedef,
1101+ "typeid": typeid,
1102+ "typename": typename,
1103+ "typeof": typeof,
1104+ "uint": uint,
1105+ "ulong": ulong,
1106+ "unchecked": unchecked,
1107+ "undefined": undefined,
1108+ "union": union,
1109+ "unowned": unowned,
1110+ "unsafe": unsafe,
1111+ "unsigned": unsigned,
1112+ "ushort": ushort,
1113+ "using": using,
1114+ "var": topLevelVar,
1115+ "virtual": virtual,
1116+ "void": topLevelVoid,
1117+ "volatile": volatile,
1118+ "wchar_t": wcharT,
1119+ "weak": weak,
1120+ "where": where,
1121+ "while": topLevelWhile,
1122+ "willSet": willSet,
1123+ "with": topLevelWith,
1124+ "xor": xor,
1125+ "xor_eq": xorEq,
1126+ "YES": yes,
1127+ "yield": topLevelYield,
1128+ };
1129+}
1130+
1131+class Alignas {
1132+ Alignas();
1133+
1134+ factory Alignas.fromJson(Map<String, dynamic> json) => Alignas(
1135+ );
1136+
1137+ Map<String, dynamic> toJson() => {
1138+ };
1139+}
1140+
1141+class Alignof {
1142+ Alignof();
1143+
1144+ factory Alignof.fromJson(Map<String, dynamic> json) => Alignof(
1145+ );
1146+
1147+ Map<String, dynamic> toJson() => {
1148+ };
1149+}
1150+
1151+class And {
1152+ And();
1153+
1154+ factory And.fromJson(Map<String, dynamic> json) => And(
1155+ );
1156+
1157+ Map<String, dynamic> toJson() => {
1158+ };
1159+}
1160+
1161+class AndEq {
1162+ AndEq();
1163+
1164+ factory AndEq.fromJson(Map<String, dynamic> json) => AndEq(
1165+ );
1166+
1167+ Map<String, dynamic> toJson() => {
1168+ };
1169+}
1170+
1171+class Any {
1172+ Any();
1173+
1174+ factory Any.fromJson(Map<String, dynamic> json) => Any(
1175+ );
1176+
1177+ Map<String, dynamic> toJson() => {
1178+ };
1179+}
1180+
1181+class Array {
1182+ Array();
1183+
1184+ factory Array.fromJson(Map<String, dynamic> json) => Array(
1185+ );
1186+
1187+ Map<String, dynamic> toJson() => {
1188+ };
1189+}
1190+
1191+class Asm {
1192+ Asm();
1193+
1194+ factory Asm.fromJson(Map<String, dynamic> json) => Asm(
1195+ );
1196+
1197+ Map<String, dynamic> toJson() => {
1198+ };
1199+}
1200+
1201+class Associatedtype {
1202+ Associatedtype();
1203+
1204+ factory Associatedtype.fromJson(Map<String, dynamic> json) => Associatedtype(
1205+ );
1206+
1207+ Map<String, dynamic> toJson() => {
1208+ };
1209+}
1210+
1211+class Associativity {
1212+ Associativity();
1213+
1214+ factory Associativity.fromJson(Map<String, dynamic> json) => Associativity(
1215+ );
1216+
1217+ Map<String, dynamic> toJson() => {
1218+ };
1219+}
1220+
1221+class Atomic {
1222+ Atomic();
1223+
1224+ factory Atomic.fromJson(Map<String, dynamic> json) => Atomic(
1225+ );
1226+
1227+ Map<String, dynamic> toJson() => {
1228+ };
1229+}
1230+
1231+class AtomicCancel {
1232+ AtomicCancel();
1233+
1234+ factory AtomicCancel.fromJson(Map<String, dynamic> json) => AtomicCancel(
1235+ );
1236+
1237+ Map<String, dynamic> toJson() => {
1238+ };
1239+}
1240+
1241+class AtomicCommit {
1242+ AtomicCommit();
1243+
1244+ factory AtomicCommit.fromJson(Map<String, dynamic> json) => AtomicCommit(
1245+ );
1246+
1247+ Map<String, dynamic> toJson() => {
1248+ };
1249+}
1250+
1251+class AtomicNoexcept {
1252+ AtomicNoexcept();
1253+
1254+ factory AtomicNoexcept.fromJson(Map<String, dynamic> json) => AtomicNoexcept(
1255+ );
1256+
1257+ Map<String, dynamic> toJson() => {
1258+ };
1259+}
1260+
1261+class Auto {
1262+ Auto();
1263+
1264+ factory Auto.fromJson(Map<String, dynamic> json) => Auto(
1265+ );
1266+
1267+ Map<String, dynamic> toJson() => {
1268+ };
1269+}
1270+
1271+class Base {
1272+ Base();
1273+
1274+ factory Base.fromJson(Map<String, dynamic> json) => Base(
1275+ );
1276+
1277+ Map<String, dynamic> toJson() => {
1278+ };
1279+}
1280+
1281+class Bitand {
1282+ Bitand();
1283+
1284+ factory Bitand.fromJson(Map<String, dynamic> json) => Bitand(
1285+ );
1286+
1287+ Map<String, dynamic> toJson() => {
1288+ };
1289+}
1290+
1291+class Bitor {
1292+ Bitor();
1293+
1294+ factory Bitor.fromJson(Map<String, dynamic> json) => Bitor(
1295+ );
1296+
1297+ Map<String, dynamic> toJson() => {
1298+ };
1299+}
1300+
1301+class Boolean {
1302+ Boolean();
1303+
1304+ factory Boolean.fromJson(Map<String, dynamic> json) => Boolean(
1305+ );
1306+
1307+ Map<String, dynamic> toJson() => {
1308+ };
1309+}
1310+
1311+class Bycopy {
1312+ Bycopy();
1313+
1314+ factory Bycopy.fromJson(Map<String, dynamic> json) => Bycopy(
1315+ );
1316+
1317+ Map<String, dynamic> toJson() => {
1318+ };
1319+}
1320+
1321+class Byref {
1322+ Byref();
1323+
1324+ factory Byref.fromJson(Map<String, dynamic> json) => Byref(
1325+ );
1326+
1327+ Map<String, dynamic> toJson() => {
1328+ };
1329+}
1330+
1331+class Byte {
1332+ Byte();
1333+
1334+ factory Byte.fromJson(Map<String, dynamic> json) => Byte(
1335+ );
1336+
1337+ Map<String, dynamic> toJson() => {
1338+ };
1339+}
1340+
1341+class Chan {
1342+ Chan();
1343+
1344+ factory Chan.fromJson(Map<String, dynamic> json) => Chan(
1345+ );
1346+
1347+ Map<String, dynamic> toJson() => {
1348+ };
1349+}
1350+
1351+class Char {
1352+ Char();
1353+
1354+ factory Char.fromJson(Map<String, dynamic> json) => Char(
1355+ );
1356+
1357+ Map<String, dynamic> toJson() => {
1358+ };
1359+}
1360+
1361+class Char16T {
1362+ Char16T();
1363+
1364+ factory Char16T.fromJson(Map<String, dynamic> json) => Char16T(
1365+ );
1366+
1367+ Map<String, dynamic> toJson() => {
1368+ };
1369+}
1370+
1371+class Char32T {
1372+ Char32T();
1373+
1374+ factory Char32T.fromJson(Map<String, dynamic> json) => Char32T(
1375+ );
1376+
1377+ Map<String, dynamic> toJson() => {
1378+ };
1379+}
1380+
1381+class Checked {
1382+ Checked();
1383+
1384+ factory Checked.fromJson(Map<String, dynamic> json) => Checked(
1385+ );
1386+
1387+ Map<String, dynamic> toJson() => {
1388+ };
1389+}
1390+
1391+class CoAwait {
1392+ CoAwait();
1393+
1394+ factory CoAwait.fromJson(Map<String, dynamic> json) => CoAwait(
1395+ );
1396+
1397+ Map<String, dynamic> toJson() => {
1398+ };
1399+}
1400+
1401+class CoReturn {
1402+ CoReturn();
1403+
1404+ factory CoReturn.fromJson(Map<String, dynamic> json) => CoReturn(
1405+ );
1406+
1407+ Map<String, dynamic> toJson() => {
1408+ };
1409+}
1410+
1411+class CoYield {
1412+ CoYield();
1413+
1414+ factory CoYield.fromJson(Map<String, dynamic> json) => CoYield(
1415+ );
1416+
1417+ Map<String, dynamic> toJson() => {
1418+ };
1419+}
1420+
1421+class Compl {
1422+ Compl();
1423+
1424+ factory Compl.fromJson(Map<String, dynamic> json) => Compl(
1425+ );
1426+
1427+ Map<String, dynamic> toJson() => {
1428+ };
1429+}
1430+
1431+class Complex {
1432+ Complex();
1433+
1434+ factory Complex.fromJson(Map<String, dynamic> json) => Complex(
1435+ );
1436+
1437+ Map<String, dynamic> toJson() => {
1438+ };
1439+}
1440+
1441+class Concept {
1442+ Concept();
1443+
1444+ factory Concept.fromJson(Map<String, dynamic> json) => Concept(
1445+ );
1446+
1447+ Map<String, dynamic> toJson() => {
1448+ };
1449+}
1450+
1451+class Console {
1452+ Console();
1453+
1454+ factory Console.fromJson(Map<String, dynamic> json) => Console(
1455+ );
1456+
1457+ Map<String, dynamic> toJson() => {
1458+ };
1459+}
1460+
1461+class ConstCast {
1462+ ConstCast();
1463+
1464+ factory ConstCast.fromJson(Map<String, dynamic> json) => ConstCast(
1465+ );
1466+
1467+ Map<String, dynamic> toJson() => {
1468+ };
1469+}
1470+
1471+class Constexpr {
1472+ Constexpr();
1473+
1474+ factory Constexpr.fromJson(Map<String, dynamic> json) => Constexpr(
1475+ );
1476+
1477+ Map<String, dynamic> toJson() => {
1478+ };
1479+}
1480+
1481+class Constructor {
1482+ Constructor();
1483+
1484+ factory Constructor.fromJson(Map<String, dynamic> json) => Constructor(
1485+ );
1486+
1487+ Map<String, dynamic> toJson() => {
1488+ };
1489+}
1490+
1491+class Convenience {
1492+ Convenience();
1493+
1494+ factory Convenience.fromJson(Map<String, dynamic> json) => Convenience(
1495+ );
1496+
1497+ Map<String, dynamic> toJson() => {
1498+ };
1499+}
1500+
1501+class Convert {
1502+ Convert();
1503+
1504+ factory Convert.fromJson(Map<String, dynamic> json) => Convert(
1505+ );
1506+
1507+ Map<String, dynamic> toJson() => {
1508+ };
1509+}
1510+
1511+class Converter {
1512+ Converter();
1513+
1514+ factory Converter.fromJson(Map<String, dynamic> json) => Converter(
1515+ );
1516+
1517+ Map<String, dynamic> toJson() => {
1518+ };
1519+}
1520+
1521+class Date {
1522+ Date();
1523+
1524+ factory Date.fromJson(Map<String, dynamic> json) => Date(
1525+ );
1526+
1527+ Map<String, dynamic> toJson() => {
1528+ };
1529+}
1530+
1531+class DateParseHandling {
1532+ DateParseHandling();
1533+
1534+ factory DateParseHandling.fromJson(Map<String, dynamic> json) => DateParseHandling(
1535+ );
1536+
1537+ Map<String, dynamic> toJson() => {
1538+ };
1539+}
1540+
1541+class Debugger {
1542+ Debugger();
1543+
1544+ factory Debugger.fromJson(Map<String, dynamic> json) => Debugger(
1545+ );
1546+
1547+ Map<String, dynamic> toJson() => {
1548+ };
1549+}
1550+
1551+class Decimal {
1552+ Decimal();
1553+
1554+ factory Decimal.fromJson(Map<String, dynamic> json) => Decimal(
1555+ );
1556+
1557+ Map<String, dynamic> toJson() => {
1558+ };
1559+}
1560+
1561+class Declare {
1562+ Declare();
1563+
1564+ factory Declare.fromJson(Map<String, dynamic> json) => Declare(
1565+ );
1566+
1567+ Map<String, dynamic> toJson() => {
1568+ };
1569+}
1570+
1571+class Decltype {
1572+ Decltype();
1573+
1574+ factory Decltype.fromJson(Map<String, dynamic> json) => Decltype(
1575+ );
1576+
1577+ Map<String, dynamic> toJson() => {
1578+ };
1579+}
1580+
1581+class DecodeString {
1582+ DecodeString();
1583+
1584+ factory DecodeString.fromJson(Map<String, dynamic> json) => DecodeString(
1585+ );
1586+
1587+ Map<String, dynamic> toJson() => {
1588+ };
1589+}
1590+
1591+class Def {
1592+ Def();
1593+
1594+ factory Def.fromJson(Map<String, dynamic> json) => Def(
1595+ );
1596+
1597+ Map<String, dynamic> toJson() => {
1598+ };
1599+}
1600+
1601+class Defer {
1602+ Defer();
1603+
1604+ factory Defer.fromJson(Map<String, dynamic> json) => Defer(
1605+ );
1606+
1607+ Map<String, dynamic> toJson() => {
1608+ };
1609+}
1610+
1611+class Deinit {
1612+ Deinit();
1613+
1614+ factory Deinit.fromJson(Map<String, dynamic> json) => Deinit(
1615+ );
1616+
1617+ Map<String, dynamic> toJson() => {
1618+ };
1619+}
1620+
1621+class Del {
1622+ Del();
1623+
1624+ factory Del.fromJson(Map<String, dynamic> json) => Del(
1625+ );
1626+
1627+ Map<String, dynamic> toJson() => {
1628+ };
1629+}
1630+
1631+class Delegate {
1632+ Delegate();
1633+
1634+ factory Delegate.fromJson(Map<String, dynamic> json) => Delegate(
1635+ );
1636+
1637+ Map<String, dynamic> toJson() => {
1638+ };
1639+}
1640+
1641+class Delete {
1642+ Delete();
1643+
1644+ factory Delete.fromJson(Map<String, dynamic> json) => Delete(
1645+ );
1646+
1647+ Map<String, dynamic> toJson() => {
1648+ };
1649+}
1650+
1651+class Dict {
1652+ Dict();
1653+
1654+ factory Dict.fromJson(Map<String, dynamic> json) => Dict(
1655+ );
1656+
1657+ Map<String, dynamic> toJson() => {
1658+ };
1659+}
1660+
1661+class Dictionary {
1662+ Dictionary();
1663+
1664+ factory Dictionary.fromJson(Map<String, dynamic> json) => Dictionary(
1665+ );
1666+
1667+ Map<String, dynamic> toJson() => {
1668+ };
1669+}
1670+
1671+class DidSet {
1672+ DidSet();
1673+
1674+ factory DidSet.fromJson(Map<String, dynamic> json) => DidSet(
1675+ );
1676+
1677+ Map<String, dynamic> toJson() => {
1678+ };
1679+}
1680+
1681+class DynamicCast {
1682+ DynamicCast();
1683+
1684+ factory DynamicCast.fromJson(Map<String, dynamic> json) => DynamicCast(
1685+ );
1686+
1687+ Map<String, dynamic> toJson() => {
1688+ };
1689+}
1690+
1691+class Elif {
1692+ Elif();
1693+
1694+ factory Elif.fromJson(Map<String, dynamic> json) => Elif(
1695+ );
1696+
1697+ Map<String, dynamic> toJson() => {
1698+ };
1699+}
1700+
1701+class Empty {
1702+ Empty();
1703+
1704+ factory Empty.fromJson(Map<String, dynamic> json) => Empty(
1705+ );
1706+
1707+ Map<String, dynamic> toJson() => {
1708+ };
1709+}
1710+
1711+class EncodeQuickType {
1712+ EncodeQuickType();
1713+
1714+ factory EncodeQuickType.fromJson(Map<String, dynamic> json) => EncodeQuickType(
1715+ );
1716+
1717+ Map<String, dynamic> toJson() => {
1718+ };
1719+}
1720+
1721+class Event {
1722+ Event();
1723+
1724+ factory Event.fromJson(Map<String, dynamic> json) => Event(
1725+ );
1726+
1727+ Map<String, dynamic> toJson() => {
1728+ };
1729+}
1730+
1731+class Except {
1732+ Except();
1733+
1734+ factory Except.fromJson(Map<String, dynamic> json) => Except(
1735+ );
1736+
1737+ Map<String, dynamic> toJson() => {
1738+ };
1739+}
1740+
1741+class Exception {
1742+ Exception();
1743+
1744+ factory Exception.fromJson(Map<String, dynamic> json) => Exception(
1745+ );
1746+
1747+ Map<String, dynamic> toJson() => {
1748+ };
1749+}
1750+
1751+class Explicit {
1752+ Explicit();
1753+
1754+ factory Explicit.fromJson(Map<String, dynamic> json) => Explicit(
1755+ );
1756+
1757+ Map<String, dynamic> toJson() => {
1758+ };
1759+}
1760+
1761+class Exposing {
1762+ Exposing();
1763+
1764+ factory Exposing.fromJson(Map<String, dynamic> json) => Exposing(
1765+ );
1766+
1767+ Map<String, dynamic> toJson() => {
1768+ };
1769+}
1770+
1771+class Extension {
1772+ Extension();
1773+
1774+ factory Extension.fromJson(Map<String, dynamic> json) => Extension(
1775+ );
1776+
1777+ Map<String, dynamic> toJson() => {
1778+ };
1779+}
1780+
1781+class Extern {
1782+ Extern();
1783+
1784+ factory Extern.fromJson(Map<String, dynamic> json) => Extern(
1785+ );
1786+
1787+ Map<String, dynamic> toJson() => {
1788+ };
1789+}
1790+
1791+class Fallthrough {
1792+ Fallthrough();
1793+
1794+ factory Fallthrough.fromJson(Map<String, dynamic> json) => Fallthrough(
1795+ );
1796+
1797+ Map<String, dynamic> toJson() => {
1798+ };
1799+}
1800+
1801+class Fileprivate {
1802+ Fileprivate();
1803+
1804+ factory Fileprivate.fromJson(Map<String, dynamic> json) => Fileprivate(
1805+ );
1806+
1807+ Map<String, dynamic> toJson() => {
1808+ };
1809+}
1810+
1811+class Fixed {
1812+ Fixed();
1813+
1814+ factory Fixed.fromJson(Map<String, dynamic> json) => Fixed(
1815+ );
1816+
1817+ Map<String, dynamic> toJson() => {
1818+ };
1819+}
1820+
1821+class Float {
1822+ Float();
1823+
1824+ factory Float.fromJson(Map<String, dynamic> json) => Float(
1825+ );
1826+
1827+ Map<String, dynamic> toJson() => {
1828+ };
1829+}
1830+
1831+class UnionBoolBool {
1832+ UnionBoolBool();
1833+
1834+ factory UnionBoolBool.fromJson(Map<String, dynamic> json) => UnionBoolBool(
1835+ );
1836+
1837+ Map<String, dynamic> toJson() => {
1838+ };
1839+}
1840+
1841+class Foreach {
1842+ Foreach();
1843+
1844+ factory Foreach.fromJson(Map<String, dynamic> json) => Foreach(
1845+ );
1846+
1847+ Map<String, dynamic> toJson() => {
1848+ };
1849+}
1850+
1851+class Friend {
1852+ Friend();
1853+
1854+ factory Friend.fromJson(Map<String, dynamic> json) => Friend(
1855+ );
1856+
1857+ Map<String, dynamic> toJson() => {
1858+ };
1859+}
1860+
1861+class From {
1862+ From();
1863+
1864+ factory From.fromJson(Map<String, dynamic> json) => From(
1865+ );
1866+
1867+ Map<String, dynamic> toJson() => {
1868+ };
1869+}
1870+
1871+class Func {
1872+ Func();
1873+
1874+ factory Func.fromJson(Map<String, dynamic> json) => Func(
1875+ );
1876+
1877+ Map<String, dynamic> toJson() => {
1878+ };
1879+}
1880+
1881+class FunctionClass {
1882+ FunctionClass();
1883+
1884+ factory FunctionClass.fromJson(Map<String, dynamic> json) => FunctionClass(
1885+ );
1886+
1887+ Map<String, dynamic> toJson() => {
1888+ };
1889+}
1890+
1891+class Global {
1892+ Global();
1893+
1894+ factory Global.fromJson(Map<String, dynamic> json) => Global(
1895+ );
1896+
1897+ Map<String, dynamic> toJson() => {
1898+ };
1899+}
1900+
1901+class Go {
1902+ Go();
1903+
1904+ factory Go.fromJson(Map<String, dynamic> json) => Go(
1905+ );
1906+
1907+ Map<String, dynamic> toJson() => {
1908+ };
1909+}
1910+
1911+class Goto {
1912+ Goto();
1913+
1914+ factory Goto.fromJson(Map<String, dynamic> json) => Goto(
1915+ );
1916+
1917+ Map<String, dynamic> toJson() => {
1918+ };
1919+}
1920+
1921+class Guard {
1922+ Guard();
1923+
1924+ factory Guard.fromJson(Map<String, dynamic> json) => Guard(
1925+ );
1926+
1927+ Map<String, dynamic> toJson() => {
1928+ };
1929+}
1930+
1931+class HasOwnProperty {
1932+ HasOwnProperty();
1933+
1934+ factory HasOwnProperty.fromJson(Map<String, dynamic> json) => HasOwnProperty(
1935+ );
1936+
1937+ Map<String, dynamic> toJson() => {
1938+ };
1939+}
1940+
1941+class Id {
1942+ Id();
1943+
1944+ factory Id.fromJson(Map<String, dynamic> json) => Id(
1945+ );
1946+
1947+ Map<String, dynamic> toJson() => {
1948+ };
1949+}
1950+
1951+class Imaginery {
1952+ Imaginery();
1953+
1954+ factory Imaginery.fromJson(Map<String, dynamic> json) => Imaginery(
1955+ );
1956+
1957+ Map<String, dynamic> toJson() => {
1958+ };
1959+}
1960+
1961+class Imp {
1962+ Imp();
1963+
1964+ factory Imp.fromJson(Map<String, dynamic> json) => Imp(
1965+ );
1966+
1967+ Map<String, dynamic> toJson() => {
1968+ };
1969+}
1970+
1971+class Implicit {
1972+ Implicit();
1973+
1974+ factory Implicit.fromJson(Map<String, dynamic> json) => Implicit(
1975+ );
1976+
1977+ Map<String, dynamic> toJson() => {
1978+ };
1979+}
1980+
1981+class Indirect {
1982+ Indirect();
1983+
1984+ factory Indirect.fromJson(Map<String, dynamic> json) => Indirect(
1985+ );
1986+
1987+ Map<String, dynamic> toJson() => {
1988+ };
1989+}
1990+
1991+class Infix {
1992+ Infix();
1993+
1994+ factory Infix.fromJson(Map<String, dynamic> json) => Infix(
1995+ );
1996+
1997+ Map<String, dynamic> toJson() => {
1998+ };
1999+}
2000+
2001+class Init {
2002+ Init();
2003+
2004+ factory Init.fromJson(Map<String, dynamic> json) => Init(
2005+ );
2006+
2007+ Map<String, dynamic> toJson() => {
2008+ };
2009+}
2010+
2011+class Inline {
2012+ Inline();
2013+
2014+ factory Inline.fromJson(Map<String, dynamic> json) => Inline(
2015+ );
2016+
2017+ Map<String, dynamic> toJson() => {
2018+ };
2019+}
2020+
2021+class Inout {
2022+ Inout();
2023+
2024+ factory Inout.fromJson(Map<String, dynamic> json) => Inout(
2025+ );
2026+
2027+ Map<String, dynamic> toJson() => {
2028+ };
2029+}
2030+
2031+class Instanceof {
2032+ Instanceof();
2033+
2034+ factory Instanceof.fromJson(Map<String, dynamic> json) => Instanceof(
2035+ );
2036+
2037+ Map<String, dynamic> toJson() => {
2038+ };
2039+}
2040+
2041+class Internal {
2042+ Internal();
2043+
2044+ factory Internal.fromJson(Map<String, dynamic> json) => Internal(
2045+ );
2046+
2047+ Map<String, dynamic> toJson() => {
2048+ };
2049+}
2050+
2051+class Iterable {
2052+ Iterable();
2053+
2054+ factory Iterable.fromJson(Map<String, dynamic> json) => Iterable(
2055+ );
2056+
2057+ Map<String, dynamic> toJson() => {
2058+ };
2059+}
2060+
2061+class Jdec {
2062+ Jdec();
2063+
2064+ factory Jdec.fromJson(Map<String, dynamic> json) => Jdec(
2065+ );
2066+
2067+ Map<String, dynamic> toJson() => {
2068+ };
2069+}
2070+
2071+class Jenc {
2072+ Jenc();
2073+
2074+ factory Jenc.fromJson(Map<String, dynamic> json) => Jenc(
2075+ );
2076+
2077+ Map<String, dynamic> toJson() => {
2078+ };
2079+}
2080+
2081+class Jpipe {
2082+ Jpipe();
2083+
2084+ factory Jpipe.fromJson(Map<String, dynamic> json) => Jpipe(
2085+ );
2086+
2087+ Map<String, dynamic> toJson() => {
2088+ };
2089+}
2090+
2091+class Json {
2092+ Json();
2093+
2094+ factory Json.fromJson(Map<String, dynamic> json) => Json(
2095+ );
2096+
2097+ Map<String, dynamic> toJson() => {
2098+ };
2099+}
2100+
2101+class JsonConverter {
2102+ JsonConverter();
2103+
2104+ factory JsonConverter.fromJson(Map<String, dynamic> json) => JsonConverter(
2105+ );
2106+
2107+ Map<String, dynamic> toJson() => {
2108+ };
2109+}
2110+
2111+class JsonSerializer {
2112+ JsonSerializer();
2113+
2114+ factory JsonSerializer.fromJson(Map<String, dynamic> json) => JsonSerializer(
2115+ );
2116+
2117+ Map<String, dynamic> toJson() => {
2118+ };
2119+}
2120+
2121+class JsonToken {
2122+ JsonToken();
2123+
2124+ factory JsonToken.fromJson(Map<String, dynamic> json) => JsonToken(
2125+ );
2126+
2127+ Map<String, dynamic> toJson() => {
2128+ };
2129+}
2130+
2131+class JsonWriter {
2132+ JsonWriter();
2133+
2134+ factory JsonWriter.fromJson(Map<String, dynamic> json) => JsonWriter(
2135+ );
2136+
2137+ Map<String, dynamic> toJson() => {
2138+ };
2139+}
2140+
2141+class Lambda {
2142+ Lambda();
2143+
2144+ factory Lambda.fromJson(Map<String, dynamic> json) => Lambda(
2145+ );
2146+
2147+ Map<String, dynamic> toJson() => {
2148+ };
2149+}
2150+
2151+class Lazy {
2152+ Lazy();
2153+
2154+ factory Lazy.fromJson(Map<String, dynamic> json) => Lazy(
2155+ );
2156+
2157+ Map<String, dynamic> toJson() => {
2158+ };
2159+}
2160+
2161+class Left {
2162+ Left();
2163+
2164+ factory Left.fromJson(Map<String, dynamic> json) => Left(
2165+ );
2166+
2167+ Map<String, dynamic> toJson() => {
2168+ };
2169+}
2170+
2171+class Let {
2172+ Let();
2173+
2174+ factory Let.fromJson(Map<String, dynamic> json) => Let(
2175+ );
2176+
2177+ Map<String, dynamic> toJson() => {
2178+ };
2179+}
2180+
2181+class ListClass {
2182+ ListClass();
2183+
2184+ factory ListClass.fromJson(Map<String, dynamic> json) => ListClass(
2185+ );
2186+
2187+ Map<String, dynamic> toJson() => {
2188+ };
2189+}
2190+
2191+class Lock {
2192+ Lock();
2193+
2194+ factory Lock.fromJson(Map<String, dynamic> json) => Lock(
2195+ );
2196+
2197+ Map<String, dynamic> toJson() => {
2198+ };
2199+}
2200+
2201+class Long {
2202+ Long();
2203+
2204+ factory Long.fromJson(Map<String, dynamic> json) => Long(
2205+ );
2206+
2207+ Map<String, dynamic> toJson() => {
2208+ };
2209+}
2210+
2211+class MapClass {
2212+ MapClass();
2213+
2214+ factory MapClass.fromJson(Map<String, dynamic> json) => MapClass(
2215+ );
2216+
2217+ Map<String, dynamic> toJson() => {
2218+ };
2219+}
2220+
2221+class MetadataPropertyHandling {
2222+ MetadataPropertyHandling();
2223+
2224+ factory MetadataPropertyHandling.fromJson(Map<String, dynamic> json) => MetadataPropertyHandling(
2225+ );
2226+
2227+ Map<String, dynamic> toJson() => {
2228+ };
2229+}
2230+
2231+class Module {
2232+ Module();
2233+
2234+ factory Module.fromJson(Map<String, dynamic> json) => Module(
2235+ );
2236+
2237+ Map<String, dynamic> toJson() => {
2238+ };
2239+}
2240+
2241+class Mutable {
2242+ Mutable();
2243+
2244+ factory Mutable.fromJson(Map<String, dynamic> json) => Mutable(
2245+ );
2246+
2247+ Map<String, dynamic> toJson() => {
2248+ };
2249+}
2250+
2251+class Mutating {
2252+ Mutating();
2253+
2254+ factory Mutating.fromJson(Map<String, dynamic> json) => Mutating(
2255+ );
2256+
2257+ Map<String, dynamic> toJson() => {
2258+ };
2259+}
2260+
2261+class Namespace {
2262+ Namespace();
2263+
2264+ factory Namespace.fromJson(Map<String, dynamic> json) => Namespace(
2265+ );
2266+
2267+ Map<String, dynamic> toJson() => {
2268+ };
2269+}
2270+
2271+class Native {
2272+ Native();
2273+
2274+ factory Native.fromJson(Map<String, dynamic> json) => Native(
2275+ );
2276+
2277+ Map<String, dynamic> toJson() => {
2278+ };
2279+}
2280+
2281+class Newtonsoft {
2282+ Newtonsoft();
2283+
2284+ factory Newtonsoft.fromJson(Map<String, dynamic> json) => Newtonsoft(
2285+ );
2286+
2287+ Map<String, dynamic> toJson() => {
2288+ };
2289+}
2290+
2291+class Nil {
2292+ Nil();
2293+
2294+ factory Nil.fromJson(Map<String, dynamic> json) => Nil(
2295+ );
2296+
2297+ Map<String, dynamic> toJson() => {
2298+ };
2299+}
2300+
2301+class No {
2302+ No();
2303+
2304+ factory No.fromJson(Map<String, dynamic> json) => No(
2305+ );
2306+
2307+ Map<String, dynamic> toJson() => {
2308+ };
2309+}
2310+
2311+class Noexcept {
2312+ Noexcept();
2313+
2314+ factory Noexcept.fromJson(Map<String, dynamic> json) => Noexcept(
2315+ );
2316+
2317+ Map<String, dynamic> toJson() => {
2318+ };
2319+}
2320+
2321+class Nonatomic {
2322+ Nonatomic();
2323+
2324+ factory Nonatomic.fromJson(Map<String, dynamic> json) => Nonatomic(
2325+ );
2326+
2327+ Map<String, dynamic> toJson() => {
2328+ };
2329+}
2330+
2331+class None {
2332+ None();
2333+
2334+ factory None.fromJson(Map<String, dynamic> json) => None(
2335+ );
2336+
2337+ Map<String, dynamic> toJson() => {
2338+ };
2339+}
2340+
2341+class Nonlocal {
2342+ Nonlocal();
2343+
2344+ factory Nonlocal.fromJson(Map<String, dynamic> json) => Nonlocal(
2345+ );
2346+
2347+ Map<String, dynamic> toJson() => {
2348+ };
2349+}
2350+
2351+class Nonmutating {
2352+ Nonmutating();
2353+
2354+ factory Nonmutating.fromJson(Map<String, dynamic> json) => Nonmutating(
2355+ );
2356+
2357+ Map<String, dynamic> toJson() => {
2358+ };
2359+}
2360+
2361+class Not {
2362+ Not();
2363+
2364+ factory Not.fromJson(Map<String, dynamic> json) => Not(
2365+ );
2366+
2367+ Map<String, dynamic> toJson() => {
2368+ };
2369+}
2370+
2371+class NotEq {
2372+ NotEq();
2373+
2374+ factory NotEq.fromJson(Map<String, dynamic> json) => NotEq(
2375+ );
2376+
2377+ Map<String, dynamic> toJson() => {
2378+ };
2379+}
2380+
2381+class NsString {
2382+ NsString();
2383+
2384+ factory NsString.fromJson(Map<String, dynamic> json) => NsString(
2385+ );
2386+
2387+ Map<String, dynamic> toJson() => {
2388+ };
2389+}
2390+
2391+class Nullptr {
2392+ Nullptr();
2393+
2394+ factory Nullptr.fromJson(Map<String, dynamic> json) => Nullptr(
2395+ );
2396+
2397+ Map<String, dynamic> toJson() => {
2398+ };
2399+}
2400+
2401+class Number {
2402+ Number();
2403+
2404+ factory Number.fromJson(Map<String, dynamic> json) => Number(
2405+ );
2406+
2407+ Map<String, dynamic> toJson() => {
2408+ };
2409+}
2410+
2411+class Object {
2412+ Object();
2413+
2414+ factory Object.fromJson(Map<String, dynamic> json) => Object(
2415+ );
2416+
2417+ Map<String, dynamic> toJson() => {
2418+ };
2419+}
2420+
2421+class Of {
2422+ Of();
2423+
2424+ factory Of.fromJson(Map<String, dynamic> json) => Of(
2425+ );
2426+
2427+ Map<String, dynamic> toJson() => {
2428+ };
2429+}
2430+
2431+class Oneway {
2432+ Oneway();
2433+
2434+ factory Oneway.fromJson(Map<String, dynamic> json) => Oneway(
2435+ );
2436+
2437+ Map<String, dynamic> toJson() => {
2438+ };
2439+}
2440+
2441+class Open {
2442+ Open();
2443+
2444+ factory Open.fromJson(Map<String, dynamic> json) => Open(
2445+ );
2446+
2447+ Map<String, dynamic> toJson() => {
2448+ };
2449+}
2450+
2451+class Optional {
2452+ Optional();
2453+
2454+ factory Optional.fromJson(Map<String, dynamic> json) => Optional(
2455+ );
2456+
2457+ Map<String, dynamic> toJson() => {
2458+ };
2459+}
2460+
2461+class Or {
2462+ Or();
2463+
2464+ factory Or.fromJson(Map<String, dynamic> json) => Or(
2465+ );
2466+
2467+ Map<String, dynamic> toJson() => {
2468+ };
2469+}
2470+
2471+class OrEq {
2472+ OrEq();
2473+
2474+ factory OrEq.fromJson(Map<String, dynamic> json) => OrEq(
2475+ );
2476+
2477+ Map<String, dynamic> toJson() => {
2478+ };
2479+}
2480+
2481+class Out {
2482+ Out();
2483+
2484+ factory Out.fromJson(Map<String, dynamic> json) => Out(
2485+ );
2486+
2487+ Map<String, dynamic> toJson() => {
2488+ };
2489+}
2490+
2491+class Override {
2492+ Override();
2493+
2494+ factory Override.fromJson(Map<String, dynamic> json) => Override(
2495+ );
2496+
2497+ Map<String, dynamic> toJson() => {
2498+ };
2499+}
2500+
2501+class Package {
2502+ Package();
2503+
2504+ factory Package.fromJson(Map<String, dynamic> json) => Package(
2505+ );
2506+
2507+ Map<String, dynamic> toJson() => {
2508+ };
2509+}
2510+
2511+class Params {
2512+ Params();
2513+
2514+ factory Params.fromJson(Map<String, dynamic> json) => Params(
2515+ );
2516+
2517+ Map<String, dynamic> toJson() => {
2518+ };
2519+}
2520+
2521+class Pass {
2522+ Pass();
2523+
2524+ factory Pass.fromJson(Map<String, dynamic> json) => Pass(
2525+ );
2526+
2527+ Map<String, dynamic> toJson() => {
2528+ };
2529+}
2530+
2531+class Port {
2532+ Port();
2533+
2534+ factory Port.fromJson(Map<String, dynamic> json) => Port(
2535+ );
2536+
2537+ Map<String, dynamic> toJson() => {
2538+ };
2539+}
2540+
2541+class Postfix {
2542+ Postfix();
2543+
2544+ factory Postfix.fromJson(Map<String, dynamic> json) => Postfix(
2545+ );
2546+
2547+ Map<String, dynamic> toJson() => {
2548+ };
2549+}
2550+
2551+class Precedence {
2552+ Precedence();
2553+
2554+ factory Precedence.fromJson(Map<String, dynamic> json) => Precedence(
2555+ );
2556+
2557+ Map<String, dynamic> toJson() => {
2558+ };
2559+}
2560+
2561+class Prefix {
2562+ Prefix();
2563+
2564+ factory Prefix.fromJson(Map<String, dynamic> json) => Prefix(
2565+ );
2566+
2567+ Map<String, dynamic> toJson() => {
2568+ };
2569+}
2570+
2571+class Print {
2572+ Print();
2573+
2574+ factory Print.fromJson(Map<String, dynamic> json) => Print(
2575+ );
2576+
2577+ Map<String, dynamic> toJson() => {
2578+ };
2579+}
2580+
2581+class Printf {
2582+ Printf();
2583+
2584+ factory Printf.fromJson(Map<String, dynamic> json) => Printf(
2585+ );
2586+
2587+ Map<String, dynamic> toJson() => {
2588+ };
2589+}
2590+
2591+class Private {
2592+ Private();
2593+
2594+ factory Private.fromJson(Map<String, dynamic> json) => Private(
2595+ );
2596+
2597+ Map<String, dynamic> toJson() => {
2598+ };
2599+}
2600+
2601+class Protected {
2602+ Protected();
2603+
2604+ factory Protected.fromJson(Map<String, dynamic> json) => Protected(
2605+ );
2606+
2607+ Map<String, dynamic> toJson() => {
2608+ };
2609+}
2610+
2611+class Protocol {
2612+ Protocol();
2613+
2614+ factory Protocol.fromJson(Map<String, dynamic> json) => Protocol(
2615+ );
2616+
2617+ Map<String, dynamic> toJson() => {
2618+ };
2619+}
2620+
2621+class Public {
2622+ Public();
2623+
2624+ factory Public.fromJson(Map<String, dynamic> json) => Public(
2625+ );
2626+
2627+ Map<String, dynamic> toJson() => {
2628+ };
2629+}
2630+
2631+class BoolClass {
2632+ BoolClass();
2633+
2634+ factory BoolClass.fromJson(Map<String, dynamic> json) => BoolClass(
2635+ );
2636+
2637+ Map<String, dynamic> toJson() => {
2638+ };
2639+}
2640+
2641+class ClassClass {
2642+ ClassClass();
2643+
2644+ factory ClassClass.fromJson(Map<String, dynamic> json) => ClassClass(
2645+ );
2646+
2647+ Map<String, dynamic> toJson() => {
2648+ };
2649+}
2650+
2651+class FalseClass {
2652+ FalseClass();
2653+
2654+ factory FalseClass.fromJson(Map<String, dynamic> json) => FalseClass(
2655+ );
2656+
2657+ Map<String, dynamic> toJson() => {
2658+ };
2659+}
2660+
2661+class NullClass {
2662+ NullClass();
2663+
2664+ factory NullClass.fromJson(Map<String, dynamic> json) => NullClass(
2665+ );
2666+
2667+ Map<String, dynamic> toJson() => {
2668+ };
2669+}
2670+
2671+class TrueClass {
2672+ TrueClass();
2673+
2674+ factory TrueClass.fromJson(Map<String, dynamic> json) => TrueClass(
2675+ );
2676+
2677+ Map<String, dynamic> toJson() => {
2678+ };
2679+}
2680+
2681+class Quicktype {
2682+ Quicktype();
2683+
2684+ factory Quicktype.fromJson(Map<String, dynamic> json) => Quicktype(
2685+ );
2686+
2687+ Map<String, dynamic> toJson() => {
2688+ };
2689+}
2690+
2691+class Raise {
2692+ Raise();
2693+
2694+ factory Raise.fromJson(Map<String, dynamic> json) => Raise(
2695+ );
2696+
2697+ Map<String, dynamic> toJson() => {
2698+ };
2699+}
2700+
2701+class Range {
2702+ Range();
2703+
2704+ factory Range.fromJson(Map<String, dynamic> json) => Range(
2705+ );
2706+
2707+ Map<String, dynamic> toJson() => {
2708+ };
2709+}
2710+
2711+class Readonly {
2712+ Readonly();
2713+
2714+ factory Readonly.fromJson(Map<String, dynamic> json) => Readonly(
2715+ );
2716+
2717+ Map<String, dynamic> toJson() => {
2718+ };
2719+}
2720+
2721+class Ref {
2722+ Ref();
2723+
2724+ factory Ref.fromJson(Map<String, dynamic> json) => Ref(
2725+ );
2726+
2727+ Map<String, dynamic> toJson() => {
2728+ };
2729+}
2730+
2731+class Register {
2732+ Register();
2733+
2734+ factory Register.fromJson(Map<String, dynamic> json) => Register(
2735+ );
2736+
2737+ Map<String, dynamic> toJson() => {
2738+ };
2739+}
2740+
2741+class ReinterpretCast {
2742+ ReinterpretCast();
2743+
2744+ factory ReinterpretCast.fromJson(Map<String, dynamic> json) => ReinterpretCast(
2745+ );
2746+
2747+ Map<String, dynamic> toJson() => {
2748+ };
2749+}
2750+
2751+class Repeat {
2752+ Repeat();
2753+
2754+ factory Repeat.fromJson(Map<String, dynamic> json) => Repeat(
2755+ );
2756+
2757+ Map<String, dynamic> toJson() => {
2758+ };
2759+}
2760+
2761+class Require {
2762+ Require();
2763+
2764+ factory Require.fromJson(Map<String, dynamic> json) => Require(
2765+ );
2766+
2767+ Map<String, dynamic> toJson() => {
2768+ };
2769+}
2770+
2771+class Required {
2772+ Required();
2773+
2774+ factory Required.fromJson(Map<String, dynamic> json) => Required(
2775+ );
2776+
2777+ Map<String, dynamic> toJson() => {
2778+ };
2779+}
2780+
2781+class Requires {
2782+ Requires();
2783+
2784+ factory Requires.fromJson(Map<String, dynamic> json) => Requires(
2785+ );
2786+
2787+ Map<String, dynamic> toJson() => {
2788+ };
2789+}
2790+
2791+class Restrict {
2792+ Restrict();
2793+
2794+ factory Restrict.fromJson(Map<String, dynamic> json) => Restrict(
2795+ );
2796+
2797+ Map<String, dynamic> toJson() => {
2798+ };
2799+}
2800+
2801+class Retain {
2802+ Retain();
2803+
2804+ factory Retain.fromJson(Map<String, dynamic> json) => Retain(
2805+ );
2806+
2807+ Map<String, dynamic> toJson() => {
2808+ };
2809+}
2810+
2811+class Rethrows {
2812+ Rethrows();
2813+
2814+ factory Rethrows.fromJson(Map<String, dynamic> json) => Rethrows(
2815+ );
2816+
2817+ Map<String, dynamic> toJson() => {
2818+ };
2819+}
2820+
2821+class Right {
2822+ Right();
2823+
2824+ factory Right.fromJson(Map<String, dynamic> json) => Right(
2825+ );
2826+
2827+ Map<String, dynamic> toJson() => {
2828+ };
2829+}
2830+
2831+class Sbyte {
2832+ Sbyte();
2833+
2834+ factory Sbyte.fromJson(Map<String, dynamic> json) => Sbyte(
2835+ );
2836+
2837+ Map<String, dynamic> toJson() => {
2838+ };
2839+}
2840+
2841+class Sealed {
2842+ Sealed();
2843+
2844+ factory Sealed.fromJson(Map<String, dynamic> json) => Sealed(
2845+ );
2846+
2847+ Map<String, dynamic> toJson() => {
2848+ };
2849+}
2850+
2851+class Sel {
2852+ Sel();
2853+
2854+ factory Sel.fromJson(Map<String, dynamic> json) => Sel(
2855+ );
2856+
2857+ Map<String, dynamic> toJson() => {
2858+ };
2859+}
2860+
2861+class Select {
2862+ Select();
2863+
2864+ factory Select.fromJson(Map<String, dynamic> json) => Select(
2865+ );
2866+
2867+ Map<String, dynamic> toJson() => {
2868+ };
2869+}
2870+
2871+class Self {
2872+ Self();
2873+
2874+ factory Self.fromJson(Map<String, dynamic> json) => Self(
2875+ );
2876+
2877+ Map<String, dynamic> toJson() => {
2878+ };
2879+}
2880+
2881+class Serialize {
2882+ Serialize();
2883+
2884+ factory Serialize.fromJson(Map<String, dynamic> json) => Serialize(
2885+ );
2886+
2887+ Map<String, dynamic> toJson() => {
2888+ };
2889+}
2890+
2891+class Short {
2892+ Short();
2893+
2894+ factory Short.fromJson(Map<String, dynamic> json) => Short(
2895+ );
2896+
2897+ Map<String, dynamic> toJson() => {
2898+ };
2899+}
2900+
2901+class Signed {
2902+ Signed();
2903+
2904+ factory Signed.fromJson(Map<String, dynamic> json) => Signed(
2905+ );
2906+
2907+ Map<String, dynamic> toJson() => {
2908+ };
2909+}
2910+
2911+class Sizeof {
2912+ Sizeof();
2913+
2914+ factory Sizeof.fromJson(Map<String, dynamic> json) => Sizeof(
2915+ );
2916+
2917+ Map<String, dynamic> toJson() => {
2918+ };
2919+}
2920+
2921+class Stackalloc {
2922+ Stackalloc();
2923+
2924+ factory Stackalloc.fromJson(Map<String, dynamic> json) => Stackalloc(
2925+ );
2926+
2927+ Map<String, dynamic> toJson() => {
2928+ };
2929+}
2930+
2931+class StaticAssert {
2932+ StaticAssert();
2933+
2934+ factory StaticAssert.fromJson(Map<String, dynamic> json) => StaticAssert(
2935+ );
2936+
2937+ Map<String, dynamic> toJson() => {
2938+ };
2939+}
2940+
2941+class StaticCast {
2942+ StaticCast();
2943+
2944+ factory StaticCast.fromJson(Map<String, dynamic> json) => StaticCast(
2945+ );
2946+
2947+ Map<String, dynamic> toJson() => {
2948+ };
2949+}
2950+
2951+class Strictfp {
2952+ Strictfp();
2953+
2954+ factory Strictfp.fromJson(Map<String, dynamic> json) => Strictfp(
2955+ );
2956+
2957+ Map<String, dynamic> toJson() => {
2958+ };
2959+}
2960+
2961+class StringClass {
2962+ StringClass();
2963+
2964+ factory StringClass.fromJson(Map<String, dynamic> json) => StringClass(
2965+ );
2966+
2967+ Map<String, dynamic> toJson() => {
2968+ };
2969+}
2970+
2971+class Struct {
2972+ Struct();
2973+
2974+ factory Struct.fromJson(Map<String, dynamic> json) => Struct(
2975+ );
2976+
2977+ Map<String, dynamic> toJson() => {
2978+ };
2979+}
2980+
2981+class Subscript {
2982+ Subscript();
2983+
2984+ factory Subscript.fromJson(Map<String, dynamic> json) => Subscript(
2985+ );
2986+
2987+ Map<String, dynamic> toJson() => {
2988+ };
2989+}
2990+
2991+class Symbol {
2992+ Symbol();
2993+
2994+ factory Symbol.fromJson(Map<String, dynamic> json) => Symbol(
2995+ );
2996+
2997+ Map<String, dynamic> toJson() => {
2998+ };
2999+}
3000+
3001+class Synchronized {
3002+ Synchronized();
3003+
3004+ factory Synchronized.fromJson(Map<String, dynamic> json) => Synchronized(
3005+ );
3006+
3007+ Map<String, dynamic> toJson() => {
3008+ };
3009+}
3010+
3011+class System {
3012+ System();
3013+
3014+ factory System.fromJson(Map<String, dynamic> json) => System(
3015+ );
3016+
3017+ Map<String, dynamic> toJson() => {
3018+ };
3019+}
3020+
3021+class Template {
3022+ Template();
3023+
3024+ factory Template.fromJson(Map<String, dynamic> json) => Template(
3025+ );
3026+
3027+ Map<String, dynamic> toJson() => {
3028+ };
3029+}
3030+
3031+class Then {
3032+ Then();
3033+
3034+ factory Then.fromJson(Map<String, dynamic> json) => Then(
3035+ );
3036+
3037+ Map<String, dynamic> toJson() => {
3038+ };
3039+}
3040+
3041+class ThreadLocal {
3042+ ThreadLocal();
3043+
3044+ factory ThreadLocal.fromJson(Map<String, dynamic> json) => ThreadLocal(
3045+ );
3046+
3047+ Map<String, dynamic> toJson() => {
3048+ };
3049+}
3050+
3051+class Throws {
3052+ Throws();
3053+
3054+ factory Throws.fromJson(Map<String, dynamic> json) => Throws(
3055+ );
3056+
3057+ Map<String, dynamic> toJson() => {
3058+ };
3059+}
3060+
3061+class TopLevelClass {
3062+ TopLevelClass();
3063+
3064+ factory TopLevelClass.fromJson(Map<String, dynamic> json) => TopLevelClass(
3065+ );
3066+
3067+ Map<String, dynamic> toJson() => {
3068+ };
3069+}
3070+
3071+class Abstract {
3072+ Abstract();
3073+
3074+ factory Abstract.fromJson(Map<String, dynamic> json) => Abstract(
3075+ );
3076+
3077+ Map<String, dynamic> toJson() => {
3078+ };
3079+}
3080+
3081+class AnyClass {
3082+ AnyClass();
3083+
3084+ factory AnyClass.fromJson(Map<String, dynamic> json) => AnyClass(
3085+ );
3086+
3087+ Map<String, dynamic> toJson() => {
3088+ };
3089+}
3090+
3091+class As {
3092+ As();
3093+
3094+ factory As.fromJson(Map<String, dynamic> json) => As(
3095+ );
3096+
3097+ Map<String, dynamic> toJson() => {
3098+ };
3099+}
3100+
3101+class Assert {
3102+ Assert();
3103+
3104+ factory Assert.fromJson(Map<String, dynamic> json) => Assert(
3105+ );
3106+
3107+ Map<String, dynamic> toJson() => {
3108+ };
3109+}
3110+
3111+class Async {
3112+ Async();
3113+
3114+ factory Async.fromJson(Map<String, dynamic> json) => Async(
3115+ );
3116+
3117+ Map<String, dynamic> toJson() => {
3118+ };
3119+}
3120+
3121+class Await {
3122+ Await();
3123+
3124+ factory Await.fromJson(Map<String, dynamic> json) => Await(
3125+ );
3126+
3127+ Map<String, dynamic> toJson() => {
3128+ };
3129+}
3130+
3131+class Bool {
3132+ Bool();
3133+
3134+ factory Bool.fromJson(Map<String, dynamic> json) => Bool(
3135+ );
3136+
3137+ Map<String, dynamic> toJson() => {
3138+ };
3139+}
3140+
3141+class Break {
3142+ Break();
3143+
3144+ factory Break.fromJson(Map<String, dynamic> json) => Break(
3145+ );
3146+
3147+ Map<String, dynamic> toJson() => {
3148+ };
3149+}
3150+
3151+class Case {
3152+ Case();
3153+
3154+ factory Case.fromJson(Map<String, dynamic> json) => Case(
3155+ );
3156+
3157+ Map<String, dynamic> toJson() => {
3158+ };
3159+}
3160+
3161+class Catch {
3162+ Catch();
3163+
3164+ factory Catch.fromJson(Map<String, dynamic> json) => Catch(
3165+ );
3166+
3167+ Map<String, dynamic> toJson() => {
3168+ };
3169+}
3170+
3171+class Class {
3172+ Class();
3173+
3174+ factory Class.fromJson(Map<String, dynamic> json) => Class(
3175+ );
3176+
3177+ Map<String, dynamic> toJson() => {
3178+ };
3179+}
3180+
3181+class Const {
3182+ Const();
3183+
3184+ factory Const.fromJson(Map<String, dynamic> json) => Const(
3185+ );
3186+
3187+ Map<String, dynamic> toJson() => {
3188+ };
3189+}
3190+
3191+class Continue {
3192+ Continue();
3193+
3194+ factory Continue.fromJson(Map<String, dynamic> json) => Continue(
3195+ );
3196+
3197+ Map<String, dynamic> toJson() => {
3198+ };
3199+}
3200+
3201+class Default {
3202+ Default();
3203+
3204+ factory Default.fromJson(Map<String, dynamic> json) => Default(
3205+ );
3206+
3207+ Map<String, dynamic> toJson() => {
3208+ };
3209+}
3210+
3211+class Do {
3212+ Do();
3213+
3214+ factory Do.fromJson(Map<String, dynamic> json) => Do(
3215+ );
3216+
3217+ Map<String, dynamic> toJson() => {
3218+ };
3219+}
3220+
3221+class Double {
3222+ Double();
3223+
3224+ factory Double.fromJson(Map<String, dynamic> json) => Double(
3225+ );
3226+
3227+ Map<String, dynamic> toJson() => {
3228+ };
3229+}
3230+
3231+class Dynamic {
3232+ Dynamic();
3233+
3234+ factory Dynamic.fromJson(Map<String, dynamic> json) => Dynamic(
3235+ );
3236+
3237+ Map<String, dynamic> toJson() => {
3238+ };
3239+}
3240+
3241+class Else {
3242+ Else();
3243+
3244+ factory Else.fromJson(Map<String, dynamic> json) => Else(
3245+ );
3246+
3247+ Map<String, dynamic> toJson() => {
3248+ };
3249+}
3250+
3251+class Enum {
3252+ Enum();
3253+
3254+ factory Enum.fromJson(Map<String, dynamic> json) => Enum(
3255+ );
3256+
3257+ Map<String, dynamic> toJson() => {
3258+ };
3259+}
3260+
3261+class Export {
3262+ Export();
3263+
3264+ factory Export.fromJson(Map<String, dynamic> json) => Export(
3265+ );
3266+
3267+ Map<String, dynamic> toJson() => {
3268+ };
3269+}
3270+
3271+class Extends {
3272+ Extends();
3273+
3274+ factory Extends.fromJson(Map<String, dynamic> json) => Extends(
3275+ );
3276+
3277+ Map<String, dynamic> toJson() => {
3278+ };
3279+}
3280+
3281+class False {
3282+ False();
3283+
3284+ factory False.fromJson(Map<String, dynamic> json) => False(
3285+ );
3286+
3287+ Map<String, dynamic> toJson() => {
3288+ };
3289+}
3290+
3291+class Final {
3292+ Final();
3293+
3294+ factory Final.fromJson(Map<String, dynamic> json) => Final(
3295+ );
3296+
3297+ Map<String, dynamic> toJson() => {
3298+ };
3299+}
3300+
3301+class Finally {
3302+ Finally();
3303+
3304+ factory Finally.fromJson(Map<String, dynamic> json) => Finally(
3305+ );
3306+
3307+ Map<String, dynamic> toJson() => {
3308+ };
3309+}
3310+
3311+class For {
3312+ For();
3313+
3314+ factory For.fromJson(Map<String, dynamic> json) => For(
3315+ );
3316+
3317+ Map<String, dynamic> toJson() => {
3318+ };
3319+}
3320+
3321+class FromJson {
3322+ FromJson();
3323+
3324+ factory FromJson.fromJson(Map<String, dynamic> json) => FromJson(
3325+ );
3326+
3327+ Map<String, dynamic> toJson() => {
3328+ };
3329+}
3330+
3331+class Get {
3332+ Get();
3333+
3334+ factory Get.fromJson(Map<String, dynamic> json) => Get(
3335+ );
3336+
3337+ Map<String, dynamic> toJson() => {
3338+ };
3339+}
3340+
3341+class If {
3342+ If();
3343+
3344+ factory If.fromJson(Map<String, dynamic> json) => If(
3345+ );
3346+
3347+ Map<String, dynamic> toJson() => {
3348+ };
3349+}
3350+
3351+class Implements {
3352+ Implements();
3353+
3354+ factory Implements.fromJson(Map<String, dynamic> json) => Implements(
3355+ );
3356+
3357+ Map<String, dynamic> toJson() => {
3358+ };
3359+}
3360+
3361+class Import {
3362+ Import();
3363+
3364+ factory Import.fromJson(Map<String, dynamic> json) => Import(
3365+ );
3366+
3367+ Map<String, dynamic> toJson() => {
3368+ };
3369+}
3370+
3371+class In {
3372+ In();
3373+
3374+ factory In.fromJson(Map<String, dynamic> json) => In(
3375+ );
3376+
3377+ Map<String, dynamic> toJson() => {
3378+ };
3379+}
3380+
3381+class Int {
3382+ Int();
3383+
3384+ factory Int.fromJson(Map<String, dynamic> json) => Int(
3385+ );
3386+
3387+ Map<String, dynamic> toJson() => {
3388+ };
3389+}
3390+
3391+class Interface {
3392+ Interface();
3393+
3394+ factory Interface.fromJson(Map<String, dynamic> json) => Interface(
3395+ );
3396+
3397+ Map<String, dynamic> toJson() => {
3398+ };
3399+}
3400+
3401+class Is {
3402+ Is();
3403+
3404+ factory Is.fromJson(Map<String, dynamic> json) => Is(
3405+ );
3406+
3407+ Map<String, dynamic> toJson() => {
3408+ };
3409+}
3410+
3411+class New {
3412+ New();
3413+
3414+ factory New.fromJson(Map<String, dynamic> json) => New(
3415+ );
3416+
3417+ Map<String, dynamic> toJson() => {
3418+ };
3419+}
3420+
3421+class NoneClass {
3422+ NoneClass();
3423+
3424+ factory NoneClass.fromJson(Map<String, dynamic> json) => NoneClass(
3425+ );
3426+
3427+ Map<String, dynamic> toJson() => {
3428+ };
3429+}
3430+
3431+class Null {
3432+ Null();
3433+
3434+ factory Null.fromJson(Map<String, dynamic> json) => Null(
3435+ );
3436+
3437+ Map<String, dynamic> toJson() => {
3438+ };
3439+}
3440+
3441+class Operator {
3442+ Operator();
3443+
3444+ factory Operator.fromJson(Map<String, dynamic> json) => Operator(
3445+ );
3446+
3447+ Map<String, dynamic> toJson() => {
3448+ };
3449+}
3450+
3451+class ProtocolClass {
3452+ ProtocolClass();
3453+
3454+ factory ProtocolClass.fromJson(Map<String, dynamic> json) => ProtocolClass(
3455+ );
3456+
3457+ Map<String, dynamic> toJson() => {
3458+ };
3459+}
3460+
3461+class Return {
3462+ Return();
3463+
3464+ factory Return.fromJson(Map<String, dynamic> json) => Return(
3465+ );
3466+
3467+ Map<String, dynamic> toJson() => {
3468+ };
3469+}
3470+
3471+class SelfClass {
3472+ SelfClass();
3473+
3474+ factory SelfClass.fromJson(Map<String, dynamic> json) => SelfClass(
3475+ );
3476+
3477+ Map<String, dynamic> toJson() => {
3478+ };
3479+}
3480+
3481+class Set {
3482+ Set();
3483+
3484+ factory Set.fromJson(Map<String, dynamic> json) => Set(
3485+ );
3486+
3487+ Map<String, dynamic> toJson() => {
3488+ };
3489+}
3490+
3491+class Static {
3492+ Static();
3493+
3494+ factory Static.fromJson(Map<String, dynamic> json) => Static(
3495+ );
3496+
3497+ Map<String, dynamic> toJson() => {
3498+ };
3499+}
3500+
3501+class Super {
3502+ Super();
3503+
3504+ factory Super.fromJson(Map<String, dynamic> json) => Super(
3505+ );
3506+
3507+ Map<String, dynamic> toJson() => {
3508+ };
3509+}
3510+
3511+class Switch {
3512+ Switch();
3513+
3514+ factory Switch.fromJson(Map<String, dynamic> json) => Switch(
3515+ );
3516+
3517+ Map<String, dynamic> toJson() => {
3518+ };
3519+}
3520+
3521+class This {
3522+ This();
3523+
3524+ factory This.fromJson(Map<String, dynamic> json) => This(
3525+ );
3526+
3527+ Map<String, dynamic> toJson() => {
3528+ };
3529+}
3530+
3531+class Throw {
3532+ Throw();
3533+
3534+ factory Throw.fromJson(Map<String, dynamic> json) => Throw(
3535+ );
3536+
3537+ Map<String, dynamic> toJson() => {
3538+ };
3539+}
3540+
3541+class ToJson {
3542+ ToJson();
3543+
3544+ factory ToJson.fromJson(Map<String, dynamic> json) => ToJson(
3545+ );
3546+
3547+ Map<String, dynamic> toJson() => {
3548+ };
3549+}
3550+
3551+class True {
3552+ True();
3553+
3554+ factory True.fromJson(Map<String, dynamic> json) => True(
3555+ );
3556+
3557+ Map<String, dynamic> toJson() => {
3558+ };
3559+}
3560+
3561+class Try {
3562+ Try();
3563+
3564+ factory Try.fromJson(Map<String, dynamic> json) => Try(
3565+ );
3566+
3567+ Map<String, dynamic> toJson() => {
3568+ };
3569+}
3570+
3571+class TypeClass {
3572+ TypeClass();
3573+
3574+ factory TypeClass.fromJson(Map<String, dynamic> json) => TypeClass(
3575+ );
3576+
3577+ Map<String, dynamic> toJson() => {
3578+ };
3579+}
3580+
3581+class Typedef {
3582+ Typedef();
3583+
3584+ factory Typedef.fromJson(Map<String, dynamic> json) => Typedef(
3585+ );
3586+
3587+ Map<String, dynamic> toJson() => {
3588+ };
3589+}
3590+
3591+class Var {
3592+ Var();
3593+
3594+ factory Var.fromJson(Map<String, dynamic> json) => Var(
3595+ );
3596+
3597+ Map<String, dynamic> toJson() => {
3598+ };
3599+}
3600+
3601+class Void {
3602+ Void();
3603+
3604+ factory Void.fromJson(Map<String, dynamic> json) => Void(
3605+ );
3606+
3607+ Map<String, dynamic> toJson() => {
3608+ };
3609+}
3610+
3611+class While {
3612+ While();
3613+
3614+ factory While.fromJson(Map<String, dynamic> json) => While(
3615+ );
3616+
3617+ Map<String, dynamic> toJson() => {
3618+ };
3619+}
3620+
3621+class With {
3622+ With();
3623+
3624+ factory With.fromJson(Map<String, dynamic> json) => With(
3625+ );
3626+
3627+ Map<String, dynamic> toJson() => {
3628+ };
3629+}
3630+
3631+class Yield {
3632+ Yield();
3633+
3634+ factory Yield.fromJson(Map<String, dynamic> json) => Yield(
3635+ );
3636+
3637+ Map<String, dynamic> toJson() => {
3638+ };
3639+}
3640+
3641+class Transient {
3642+ Transient();
3643+
3644+ factory Transient.fromJson(Map<String, dynamic> json) => Transient(
3645+ );
3646+
3647+ Map<String, dynamic> toJson() => {
3648+ };
3649+}
3650+
3651+class Type {
3652+ Type();
3653+
3654+ factory Type.fromJson(Map<String, dynamic> json) => Type(
3655+ );
3656+
3657+ Map<String, dynamic> toJson() => {
3658+ };
3659+}
3660+
3661+class Typealias {
3662+ Typealias();
3663+
3664+ factory Typealias.fromJson(Map<String, dynamic> json) => Typealias(
3665+ );
3666+
3667+ Map<String, dynamic> toJson() => {
3668+ };
3669+}
3670+
3671+class Typeid {
3672+ Typeid();
3673+
3674+ factory Typeid.fromJson(Map<String, dynamic> json) => Typeid(
3675+ );
3676+
3677+ Map<String, dynamic> toJson() => {
3678+ };
3679+}
3680+
3681+class Typename {
3682+ Typename();
3683+
3684+ factory Typename.fromJson(Map<String, dynamic> json) => Typename(
3685+ );
3686+
3687+ Map<String, dynamic> toJson() => {
3688+ };
3689+}
3690+
3691+class Typeof {
3692+ Typeof();
3693+
3694+ factory Typeof.fromJson(Map<String, dynamic> json) => Typeof(
3695+ );
3696+
3697+ Map<String, dynamic> toJson() => {
3698+ };
3699+}
3700+
3701+class Uint {
3702+ Uint();
3703+
3704+ factory Uint.fromJson(Map<String, dynamic> json) => Uint(
3705+ );
3706+
3707+ Map<String, dynamic> toJson() => {
3708+ };
3709+}
3710+
3711+class Ulong {
3712+ Ulong();
3713+
3714+ factory Ulong.fromJson(Map<String, dynamic> json) => Ulong(
3715+ );
3716+
3717+ Map<String, dynamic> toJson() => {
3718+ };
3719+}
3720+
3721+class Unchecked {
3722+ Unchecked();
3723+
3724+ factory Unchecked.fromJson(Map<String, dynamic> json) => Unchecked(
3725+ );
3726+
3727+ Map<String, dynamic> toJson() => {
3728+ };
3729+}
3730+
3731+class Undefined {
3732+ Undefined();
3733+
3734+ factory Undefined.fromJson(Map<String, dynamic> json) => Undefined(
3735+ );
3736+
3737+ Map<String, dynamic> toJson() => {
3738+ };
3739+}
3740+
3741+class Union {
3742+ Union();
3743+
3744+ factory Union.fromJson(Map<String, dynamic> json) => Union(
3745+ );
3746+
3747+ Map<String, dynamic> toJson() => {
3748+ };
3749+}
3750+
3751+class Unowned {
3752+ Unowned();
3753+
3754+ factory Unowned.fromJson(Map<String, dynamic> json) => Unowned(
3755+ );
3756+
3757+ Map<String, dynamic> toJson() => {
3758+ };
3759+}
3760+
3761+class Unsafe {
3762+ Unsafe();
3763+
3764+ factory Unsafe.fromJson(Map<String, dynamic> json) => Unsafe(
3765+ );
3766+
3767+ Map<String, dynamic> toJson() => {
3768+ };
3769+}
3770+
3771+class Unsigned {
3772+ Unsigned();
3773+
3774+ factory Unsigned.fromJson(Map<String, dynamic> json) => Unsigned(
3775+ );
3776+
3777+ Map<String, dynamic> toJson() => {
3778+ };
3779+}
3780+
3781+class Ushort {
3782+ Ushort();
3783+
3784+ factory Ushort.fromJson(Map<String, dynamic> json) => Ushort(
3785+ );
3786+
3787+ Map<String, dynamic> toJson() => {
3788+ };
3789+}
3790+
3791+class Using {
3792+ Using();
3793+
3794+ factory Using.fromJson(Map<String, dynamic> json) => Using(
3795+ );
3796+
3797+ Map<String, dynamic> toJson() => {
3798+ };
3799+}
3800+
3801+class Virtual {
3802+ Virtual();
3803+
3804+ factory Virtual.fromJson(Map<String, dynamic> json) => Virtual(
3805+ );
3806+
3807+ Map<String, dynamic> toJson() => {
3808+ };
3809+}
3810+
3811+class Volatile {
3812+ Volatile();
3813+
3814+ factory Volatile.fromJson(Map<String, dynamic> json) => Volatile(
3815+ );
3816+
3817+ Map<String, dynamic> toJson() => {
3818+ };
3819+}
3820+
3821+class WcharT {
3822+ WcharT();
3823+
3824+ factory WcharT.fromJson(Map<String, dynamic> json) => WcharT(
3825+ );
3826+
3827+ Map<String, dynamic> toJson() => {
3828+ };
3829+}
3830+
3831+class Weak {
3832+ Weak();
3833+
3834+ factory Weak.fromJson(Map<String, dynamic> json) => Weak(
3835+ );
3836+
3837+ Map<String, dynamic> toJson() => {
3838+ };
3839+}
3840+
3841+class Where {
3842+ Where();
3843+
3844+ factory Where.fromJson(Map<String, dynamic> json) => Where(
3845+ );
3846+
3847+ Map<String, dynamic> toJson() => {
3848+ };
3849+}
3850+
3851+class WillSet {
3852+ WillSet();
3853+
3854+ factory WillSet.fromJson(Map<String, dynamic> json) => WillSet(
3855+ );
3856+
3857+ Map<String, dynamic> toJson() => {
3858+ };
3859+}
3860+
3861+class Xor {
3862+ Xor();
3863+
3864+ factory Xor.fromJson(Map<String, dynamic> json) => Xor(
3865+ );
3866+
3867+ Map<String, dynamic> toJson() => {
3868+ };
3869+}
3870+
3871+class XorEq {
3872+ XorEq();
3873+
3874+ factory XorEq.fromJson(Map<String, dynamic> json) => XorEq(
3875+ );
3876+
3877+ Map<String, dynamic> toJson() => {
3878+ };
3879+}
3880+
3881+class Yes {
3882+ Yes();
3883+
3884+ factory Yes.fromJson(Map<String, dynamic> json) => Yes(
3885+ );
3886+
3887+ Map<String, dynamic> toJson() => {
3888+ };
3889+}
No generated files match these filters.