diff --git a/head/dart/test/inputs/json/priority/keywords.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/keywords.json/default/TopLevel.dart new file mode 100644 index 0000000..e011b3d --- /dev/null +++ b/head/dart/test/inputs/json/priority/keywords.json/default/TopLevel.dart @@ -0,0 +1,5705 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + final int dummy; + final Obj1 obj1; + final Obj2 obj2; + final Obj3 obj3; + final Obj4 obj4; + final Obj5 obj5; + + TopLevel({ + required this.dummy, + required this.obj1, + required this.obj2, + required this.obj3, + required this.obj4, + required this.obj5, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + dummy: json["dummy"], + obj1: Obj1.fromJson(json["obj1"]), + obj2: Obj2.fromJson(json["obj2"]), + obj3: Obj3.fromJson(json["obj3"]), + obj4: Obj4.fromJson(json["obj4"]), + obj5: Obj5.fromJson(json["obj5"]), + ); + + Map toJson() => { + "dummy": dummy, + "obj1": obj1.toJson(), + "obj2": obj2.toJson(), + "obj3": obj3.toJson(), + "obj4": obj4.toJson(), + "obj5": obj5.toJson(), + }; +} + +class Obj1 { + final Alignas alignas; + final Alignof alignof; + final And and; + final AndEq andEq; + final Any any; + final Array array; + final Asm asm; + final Associatedtype associatedtype; + final Associativity associativity; + final Atomic atomic; + final AtomicCancel atomicCancel; + final AtomicCommit atomicCommit; + final AtomicNoexcept atomicNoexcept; + final Auto auto; + final Base base; + final Bitand bitand; + final Bitor bitor; + final Boolean boolean; + final Bycopy bycopy; + final Byref byref; + final Byte byte; + final Chan chan; + final Char char; + final Char16T char16T; + final Char32T char32T; + final Checked checked; + final Clone clone; + final CoAwait coAwait; + final CoReturn coReturn; + final CoYield coYield; + final Compl compl; + final Complex complex; + final Concept concept; + final Console console; + final ConstCast constCast; + final Constexpr constexpr; + final Constructor constructor; + final Convenience convenience; + final Convert convert; + final Converter converter; + final Date date; + final DateParseHandling dateParseHandling; + final Debugger debugger; + final Decimal decimal; + final Declare declare; + final Decltype decltype; + final DecodeString decodeString; + final int dummy; + final Empty empty; + final Obj1Bool fluffyBool; + final Imaginery imaginery; + final Abstract obj1Abstract; + final AnyClass obj1Any; + final As obj1As; + final Assert obj1Assert; + final Async obj1Async; + final Await obj1Await; + final Bool obj1Bool; + final Break obj1Break; + final Case obj1Case; + final Catch obj1Catch; + final Class obj1Class; + final Const obj1Const; + final Continue obj1Continue; + final BoolClass purpleBool; + final ClassClass purpleClass; + + Obj1({ + required this.alignas, + required this.alignof, + required this.and, + required this.andEq, + required this.any, + required this.array, + required this.asm, + required this.associatedtype, + required this.associativity, + required this.atomic, + required this.atomicCancel, + required this.atomicCommit, + required this.atomicNoexcept, + required this.auto, + required this.base, + required this.bitand, + required this.bitor, + required this.boolean, + required this.bycopy, + required this.byref, + required this.byte, + required this.chan, + required this.char, + required this.char16T, + required this.char32T, + required this.checked, + required this.clone, + required this.coAwait, + required this.coReturn, + required this.coYield, + required this.compl, + required this.complex, + required this.concept, + required this.console, + required this.constCast, + required this.constexpr, + required this.constructor, + required this.convenience, + required this.convert, + required this.converter, + required this.date, + required this.dateParseHandling, + required this.debugger, + required this.decimal, + required this.declare, + required this.decltype, + required this.decodeString, + required this.dummy, + required this.empty, + required this.fluffyBool, + required this.imaginery, + required this.obj1Abstract, + required this.obj1Any, + required this.obj1As, + required this.obj1Assert, + required this.obj1Async, + required this.obj1Await, + required this.obj1Bool, + required this.obj1Break, + required this.obj1Case, + required this.obj1Catch, + required this.obj1Class, + required this.obj1Const, + required this.obj1Continue, + required this.purpleBool, + required this.purpleClass, + }); + + factory Obj1.fromJson(Map json) => Obj1( + alignas: Alignas.fromJson(json["alignas"]), + alignof: Alignof.fromJson(json["alignof"]), + and: And.fromJson(json["and"]), + andEq: AndEq.fromJson(json["and_eq"]), + any: Any.fromJson(json["Any"]), + array: Array.fromJson(json["array"]), + asm: Asm.fromJson(json["asm"]), + associatedtype: Associatedtype.fromJson(json["associatedtype"]), + associativity: Associativity.fromJson(json["associativity"]), + atomic: Atomic.fromJson(json["atomic"]), + atomicCancel: AtomicCancel.fromJson(json["atomic_cancel"]), + atomicCommit: AtomicCommit.fromJson(json["atomic_commit"]), + atomicNoexcept: AtomicNoexcept.fromJson(json["atomic_noexcept"]), + auto: Auto.fromJson(json["auto"]), + base: Base.fromJson(json["base"]), + bitand: Bitand.fromJson(json["bitand"]), + bitor: Bitor.fromJson(json["bitor"]), + boolean: Boolean.fromJson(json["boolean"]), + bycopy: Bycopy.fromJson(json["bycopy"]), + byref: Byref.fromJson(json["byref"]), + byte: Byte.fromJson(json["byte"]), + chan: Chan.fromJson(json["chan"]), + char: Char.fromJson(json["char"]), + char16T: Char16T.fromJson(json["char16_t"]), + char32T: Char32T.fromJson(json["char32_t"]), + checked: Checked.fromJson(json["checked"]), + clone: Clone.fromJson(json["clone"]), + coAwait: CoAwait.fromJson(json["co_await"]), + coReturn: CoReturn.fromJson(json["co_return"]), + coYield: CoYield.fromJson(json["co_yield"]), + compl: Compl.fromJson(json["compl"]), + complex: Complex.fromJson(json["_Complex"]), + concept: Concept.fromJson(json["concept"]), + console: Console.fromJson(json["console"]), + constCast: ConstCast.fromJson(json["const_cast"]), + constexpr: Constexpr.fromJson(json["constexpr"]), + constructor: Constructor.fromJson(json["constructor"]), + convenience: Convenience.fromJson(json["convenience"]), + convert: Convert.fromJson(json["convert"]), + converter: Converter.fromJson(json["converter"]), + date: Date.fromJson(json["date"]), + dateParseHandling: DateParseHandling.fromJson(json["date_parse_handling"]), + debugger: Debugger.fromJson(json["debugger"]), + decimal: Decimal.fromJson(json["decimal"]), + declare: Declare.fromJson(json["declare"]), + decltype: Decltype.fromJson(json["decltype"]), + decodeString: DecodeString.fromJson(json["decode_string"]), + dummy: json["dummy"], + empty: Empty.fromJson(json["_"]), + fluffyBool: Obj1Bool.fromJson(json["bool"]), + imaginery: Imaginery.fromJson(json["_Imaginery"]), + obj1Abstract: Abstract.fromJson(json["abstract"]), + obj1Any: AnyClass.fromJson(json["any"]), + obj1As: As.fromJson(json["as"]), + obj1Assert: Assert.fromJson(json["assert"]), + obj1Async: Async.fromJson(json["async"]), + obj1Await: Await.fromJson(json["await"]), + obj1Bool: Bool.fromJson(json["BOOL"]), + obj1Break: Break.fromJson(json["break"]), + obj1Case: Case.fromJson(json["case"]), + obj1Catch: Catch.fromJson(json["catch"]), + obj1Class: Class.fromJson(json["Class"]), + obj1Const: Const.fromJson(json["const"]), + obj1Continue: Continue.fromJson(json["continue"]), + purpleBool: BoolClass.fromJson(json["_Bool"]), + purpleClass: ClassClass.fromJson(json["class"]), + ); + + Map toJson() => { + "alignas": alignas.toJson(), + "alignof": alignof.toJson(), + "and": and.toJson(), + "and_eq": andEq.toJson(), + "Any": any.toJson(), + "array": array.toJson(), + "asm": asm.toJson(), + "associatedtype": associatedtype.toJson(), + "associativity": associativity.toJson(), + "atomic": atomic.toJson(), + "atomic_cancel": atomicCancel.toJson(), + "atomic_commit": atomicCommit.toJson(), + "atomic_noexcept": atomicNoexcept.toJson(), + "auto": auto.toJson(), + "base": base.toJson(), + "bitand": bitand.toJson(), + "bitor": bitor.toJson(), + "boolean": boolean.toJson(), + "bycopy": bycopy.toJson(), + "byref": byref.toJson(), + "byte": byte.toJson(), + "chan": chan.toJson(), + "char": char.toJson(), + "char16_t": char16T.toJson(), + "char32_t": char32T.toJson(), + "checked": checked.toJson(), + "clone": clone.toJson(), + "co_await": coAwait.toJson(), + "co_return": coReturn.toJson(), + "co_yield": coYield.toJson(), + "compl": compl.toJson(), + "_Complex": complex.toJson(), + "concept": concept.toJson(), + "console": console.toJson(), + "const_cast": constCast.toJson(), + "constexpr": constexpr.toJson(), + "constructor": constructor.toJson(), + "convenience": convenience.toJson(), + "convert": convert.toJson(), + "converter": converter.toJson(), + "date": date.toJson(), + "date_parse_handling": dateParseHandling.toJson(), + "debugger": debugger.toJson(), + "decimal": decimal.toJson(), + "declare": declare.toJson(), + "decltype": decltype.toJson(), + "decode_string": decodeString.toJson(), + "dummy": dummy, + "_": empty.toJson(), + "bool": fluffyBool.toJson(), + "_Imaginery": imaginery.toJson(), + "abstract": obj1Abstract.toJson(), + "any": obj1Any.toJson(), + "as": obj1As.toJson(), + "assert": obj1Assert.toJson(), + "async": obj1Async.toJson(), + "await": obj1Await.toJson(), + "BOOL": obj1Bool.toJson(), + "break": obj1Break.toJson(), + "case": obj1Case.toJson(), + "catch": obj1Catch.toJson(), + "Class": obj1Class.toJson(), + "const": obj1Const.toJson(), + "continue": obj1Continue.toJson(), + "_Bool": purpleBool.toJson(), + "class": purpleClass.toJson(), + }; +} + +class Alignas { + final int alignas; + + Alignas({ + required this.alignas, + }); + + factory Alignas.fromJson(Map json) => Alignas( + alignas: json["alignas"], + ); + + Map toJson() => { + "alignas": alignas, + }; +} + +class Alignof { + final int alignof; + + Alignof({ + required this.alignof, + }); + + factory Alignof.fromJson(Map json) => Alignof( + alignof: json["alignof"], + ); + + Map toJson() => { + "alignof": alignof, + }; +} + +class And { + final int and; + + And({ + required this.and, + }); + + factory And.fromJson(Map json) => And( + and: json["and"], + ); + + Map toJson() => { + "and": and, + }; +} + +class AndEq { + final int andEq; + + AndEq({ + required this.andEq, + }); + + factory AndEq.fromJson(Map json) => AndEq( + andEq: json["and_eq"], + ); + + Map toJson() => { + "and_eq": andEq, + }; +} + +class Any { + final int any; + + Any({ + required this.any, + }); + + factory Any.fromJson(Map json) => Any( + any: json["Any"], + ); + + Map toJson() => { + "Any": any, + }; +} + +class Array { + final int array; + + Array({ + required this.array, + }); + + factory Array.fromJson(Map json) => Array( + array: json["array"], + ); + + Map toJson() => { + "array": array, + }; +} + +class Asm { + final int asm; + + Asm({ + required this.asm, + }); + + factory Asm.fromJson(Map json) => Asm( + asm: json["asm"], + ); + + Map toJson() => { + "asm": asm, + }; +} + +class Associatedtype { + final int associatedtype; + + Associatedtype({ + required this.associatedtype, + }); + + factory Associatedtype.fromJson(Map json) => Associatedtype( + associatedtype: json["associatedtype"], + ); + + Map toJson() => { + "associatedtype": associatedtype, + }; +} + +class Associativity { + final int associativity; + + Associativity({ + required this.associativity, + }); + + factory Associativity.fromJson(Map json) => Associativity( + associativity: json["associativity"], + ); + + Map toJson() => { + "associativity": associativity, + }; +} + +class Atomic { + final int atomic; + + Atomic({ + required this.atomic, + }); + + factory Atomic.fromJson(Map json) => Atomic( + atomic: json["atomic"], + ); + + Map toJson() => { + "atomic": atomic, + }; +} + +class AtomicCancel { + final int atomicCancel; + + AtomicCancel({ + required this.atomicCancel, + }); + + factory AtomicCancel.fromJson(Map json) => AtomicCancel( + atomicCancel: json["atomic_cancel"], + ); + + Map toJson() => { + "atomic_cancel": atomicCancel, + }; +} + +class AtomicCommit { + final int atomicCommit; + + AtomicCommit({ + required this.atomicCommit, + }); + + factory AtomicCommit.fromJson(Map json) => AtomicCommit( + atomicCommit: json["atomic_commit"], + ); + + Map toJson() => { + "atomic_commit": atomicCommit, + }; +} + +class AtomicNoexcept { + final int atomicNoexcept; + + AtomicNoexcept({ + required this.atomicNoexcept, + }); + + factory AtomicNoexcept.fromJson(Map json) => AtomicNoexcept( + atomicNoexcept: json["atomic_noexcept"], + ); + + Map toJson() => { + "atomic_noexcept": atomicNoexcept, + }; +} + +class Auto { + final int auto; + + Auto({ + required this.auto, + }); + + factory Auto.fromJson(Map json) => Auto( + auto: json["auto"], + ); + + Map toJson() => { + "auto": auto, + }; +} + +class Base { + final int base; + + Base({ + required this.base, + }); + + factory Base.fromJson(Map json) => Base( + base: json["base"], + ); + + Map toJson() => { + "base": base, + }; +} + +class Bitand { + final int bitand; + + Bitand({ + required this.bitand, + }); + + factory Bitand.fromJson(Map json) => Bitand( + bitand: json["bitand"], + ); + + Map toJson() => { + "bitand": bitand, + }; +} + +class Bitor { + final int bitor; + + Bitor({ + required this.bitor, + }); + + factory Bitor.fromJson(Map json) => Bitor( + bitor: json["bitor"], + ); + + Map toJson() => { + "bitor": bitor, + }; +} + +class Boolean { + final int boolean; + + Boolean({ + required this.boolean, + }); + + factory Boolean.fromJson(Map json) => Boolean( + boolean: json["boolean"], + ); + + Map toJson() => { + "boolean": boolean, + }; +} + +class Bycopy { + final int bycopy; + + Bycopy({ + required this.bycopy, + }); + + factory Bycopy.fromJson(Map json) => Bycopy( + bycopy: json["bycopy"], + ); + + Map toJson() => { + "bycopy": bycopy, + }; +} + +class Byref { + final int byref; + + Byref({ + required this.byref, + }); + + factory Byref.fromJson(Map json) => Byref( + byref: json["byref"], + ); + + Map toJson() => { + "byref": byref, + }; +} + +class Byte { + final int byte; + + Byte({ + required this.byte, + }); + + factory Byte.fromJson(Map json) => Byte( + byte: json["byte"], + ); + + Map toJson() => { + "byte": byte, + }; +} + +class Chan { + final int chan; + + Chan({ + required this.chan, + }); + + factory Chan.fromJson(Map json) => Chan( + chan: json["chan"], + ); + + Map toJson() => { + "chan": chan, + }; +} + +class Char { + final int char; + + Char({ + required this.char, + }); + + factory Char.fromJson(Map json) => Char( + char: json["char"], + ); + + Map toJson() => { + "char": char, + }; +} + +class Char16T { + final int char16T; + + Char16T({ + required this.char16T, + }); + + factory Char16T.fromJson(Map json) => Char16T( + char16T: json["char16_t"], + ); + + Map toJson() => { + "char16_t": char16T, + }; +} + +class Char32T { + final int char32T; + + Char32T({ + required this.char32T, + }); + + factory Char32T.fromJson(Map json) => Char32T( + char32T: json["char32_t"], + ); + + Map toJson() => { + "char32_t": char32T, + }; +} + +class Checked { + final int checked; + + Checked({ + required this.checked, + }); + + factory Checked.fromJson(Map json) => Checked( + checked: json["checked"], + ); + + Map toJson() => { + "checked": checked, + }; +} + +class Clone { + final int clone; + + Clone({ + required this.clone, + }); + + factory Clone.fromJson(Map json) => Clone( + clone: json["clone"], + ); + + Map toJson() => { + "clone": clone, + }; +} + +class CoAwait { + final int coAwait; + + CoAwait({ + required this.coAwait, + }); + + factory CoAwait.fromJson(Map json) => CoAwait( + coAwait: json["co_await"], + ); + + Map toJson() => { + "co_await": coAwait, + }; +} + +class CoReturn { + final int coReturn; + + CoReturn({ + required this.coReturn, + }); + + factory CoReturn.fromJson(Map json) => CoReturn( + coReturn: json["co_return"], + ); + + Map toJson() => { + "co_return": coReturn, + }; +} + +class CoYield { + final int coYield; + + CoYield({ + required this.coYield, + }); + + factory CoYield.fromJson(Map json) => CoYield( + coYield: json["co_yield"], + ); + + Map toJson() => { + "co_yield": coYield, + }; +} + +class Compl { + final int compl; + + Compl({ + required this.compl, + }); + + factory Compl.fromJson(Map json) => Compl( + compl: json["compl"], + ); + + Map toJson() => { + "compl": compl, + }; +} + +class Complex { + final int complex; + + Complex({ + required this.complex, + }); + + factory Complex.fromJson(Map json) => Complex( + complex: json["_Complex"], + ); + + Map toJson() => { + "_Complex": complex, + }; +} + +class Concept { + final int concept; + + Concept({ + required this.concept, + }); + + factory Concept.fromJson(Map json) => Concept( + concept: json["concept"], + ); + + Map toJson() => { + "concept": concept, + }; +} + +class Console { + final int console; + + Console({ + required this.console, + }); + + factory Console.fromJson(Map json) => Console( + console: json["console"], + ); + + Map toJson() => { + "console": console, + }; +} + +class ConstCast { + final int constCast; + + ConstCast({ + required this.constCast, + }); + + factory ConstCast.fromJson(Map json) => ConstCast( + constCast: json["const_cast"], + ); + + Map toJson() => { + "const_cast": constCast, + }; +} + +class Constexpr { + final int constexpr; + + Constexpr({ + required this.constexpr, + }); + + factory Constexpr.fromJson(Map json) => Constexpr( + constexpr: json["constexpr"], + ); + + Map toJson() => { + "constexpr": constexpr, + }; +} + +class Constructor { + final int constructor; + + Constructor({ + required this.constructor, + }); + + factory Constructor.fromJson(Map json) => Constructor( + constructor: json["constructor"], + ); + + Map toJson() => { + "constructor": constructor, + }; +} + +class Convenience { + final int convenience; + + Convenience({ + required this.convenience, + }); + + factory Convenience.fromJson(Map json) => Convenience( + convenience: json["convenience"], + ); + + Map toJson() => { + "convenience": convenience, + }; +} + +class Convert { + final int convert; + + Convert({ + required this.convert, + }); + + factory Convert.fromJson(Map json) => Convert( + convert: json["convert"], + ); + + Map toJson() => { + "convert": convert, + }; +} + +class Converter { + final int converter; + + Converter({ + required this.converter, + }); + + factory Converter.fromJson(Map json) => Converter( + converter: json["converter"], + ); + + Map toJson() => { + "converter": converter, + }; +} + +class Date { + final int date; + + Date({ + required this.date, + }); + + factory Date.fromJson(Map json) => Date( + date: json["date"], + ); + + Map toJson() => { + "date": date, + }; +} + +class DateParseHandling { + final int dateParseHandling; + + DateParseHandling({ + required this.dateParseHandling, + }); + + factory DateParseHandling.fromJson(Map json) => DateParseHandling( + dateParseHandling: json["date_parse_handling"], + ); + + Map toJson() => { + "date_parse_handling": dateParseHandling, + }; +} + +class Debugger { + final int debugger; + + Debugger({ + required this.debugger, + }); + + factory Debugger.fromJson(Map json) => Debugger( + debugger: json["debugger"], + ); + + Map toJson() => { + "debugger": debugger, + }; +} + +class Decimal { + final int decimal; + + Decimal({ + required this.decimal, + }); + + factory Decimal.fromJson(Map json) => Decimal( + decimal: json["decimal"], + ); + + Map toJson() => { + "decimal": decimal, + }; +} + +class Declare { + final int declare; + + Declare({ + required this.declare, + }); + + factory Declare.fromJson(Map json) => Declare( + declare: json["declare"], + ); + + Map toJson() => { + "declare": declare, + }; +} + +class Decltype { + final int decltype; + + Decltype({ + required this.decltype, + }); + + factory Decltype.fromJson(Map json) => Decltype( + decltype: json["decltype"], + ); + + Map toJson() => { + "decltype": decltype, + }; +} + +class DecodeString { + final int decodeString; + + DecodeString({ + required this.decodeString, + }); + + factory DecodeString.fromJson(Map json) => DecodeString( + decodeString: json["decode_string"], + ); + + Map toJson() => { + "decode_string": decodeString, + }; +} + +class Empty { + final int empty; + + Empty({ + required this.empty, + }); + + factory Empty.fromJson(Map json) => Empty( + empty: json["_"], + ); + + Map toJson() => { + "_": empty, + }; +} + +class Obj1Bool { + final int boolBool; + + Obj1Bool({ + required this.boolBool, + }); + + factory Obj1Bool.fromJson(Map json) => Obj1Bool( + boolBool: json["bool"], + ); + + Map toJson() => { + "bool": boolBool, + }; +} + +class Imaginery { + final int imaginery; + + Imaginery({ + required this.imaginery, + }); + + factory Imaginery.fromJson(Map json) => Imaginery( + imaginery: json["_Imaginery"], + ); + + Map toJson() => { + "_Imaginery": imaginery, + }; +} + +class Abstract { + final int abstractAbstract; + + Abstract({ + required this.abstractAbstract, + }); + + factory Abstract.fromJson(Map json) => Abstract( + abstractAbstract: json["abstract"], + ); + + Map toJson() => { + "abstract": abstractAbstract, + }; +} + +class AnyClass { + final int any; + + AnyClass({ + required this.any, + }); + + factory AnyClass.fromJson(Map json) => AnyClass( + any: json["any"], + ); + + Map toJson() => { + "any": any, + }; +} + +class As { + final int asAs; + + As({ + required this.asAs, + }); + + factory As.fromJson(Map json) => As( + asAs: json["as"], + ); + + Map toJson() => { + "as": asAs, + }; +} + +class Assert { + final int assertAssert; + + Assert({ + required this.assertAssert, + }); + + factory Assert.fromJson(Map json) => Assert( + assertAssert: json["assert"], + ); + + Map toJson() => { + "assert": assertAssert, + }; +} + +class Async { + final int asyncAsync; + + Async({ + required this.asyncAsync, + }); + + factory Async.fromJson(Map json) => Async( + asyncAsync: json["async"], + ); + + Map toJson() => { + "async": asyncAsync, + }; +} + +class Await { + final int awaitAwait; + + Await({ + required this.awaitAwait, + }); + + factory Await.fromJson(Map json) => Await( + awaitAwait: json["await"], + ); + + Map toJson() => { + "await": awaitAwait, + }; +} + +class Bool { + final int boolBool; + + Bool({ + required this.boolBool, + }); + + factory Bool.fromJson(Map json) => Bool( + boolBool: json["BOOL"], + ); + + Map toJson() => { + "BOOL": boolBool, + }; +} + +class Break { + final int breakBreak; + + Break({ + required this.breakBreak, + }); + + factory Break.fromJson(Map json) => Break( + breakBreak: json["break"], + ); + + Map toJson() => { + "break": breakBreak, + }; +} + +class Case { + final int caseCase; + + Case({ + required this.caseCase, + }); + + factory Case.fromJson(Map json) => Case( + caseCase: json["case"], + ); + + Map toJson() => { + "case": caseCase, + }; +} + +class Catch { + final int catchCatch; + + Catch({ + required this.catchCatch, + }); + + factory Catch.fromJson(Map json) => Catch( + catchCatch: json["catch"], + ); + + Map toJson() => { + "catch": catchCatch, + }; +} + +class Class { + final int classClass; + + Class({ + required this.classClass, + }); + + factory Class.fromJson(Map json) => Class( + classClass: json["Class"], + ); + + Map toJson() => { + "Class": classClass, + }; +} + +class Const { + final int constConst; + + Const({ + required this.constConst, + }); + + factory Const.fromJson(Map json) => Const( + constConst: json["const"], + ); + + Map toJson() => { + "const": constConst, + }; +} + +class Continue { + final int continueContinue; + + Continue({ + required this.continueContinue, + }); + + factory Continue.fromJson(Map json) => Continue( + continueContinue: json["continue"], + ); + + Map toJson() => { + "continue": continueContinue, + }; +} + +class BoolClass { + final int boolBool; + + BoolClass({ + required this.boolBool, + }); + + factory BoolClass.fromJson(Map json) => BoolClass( + boolBool: json["_Bool"], + ); + + Map toJson() => { + "_Bool": boolBool, + }; +} + +class ClassClass { + final int classClass; + + ClassClass({ + required this.classClass, + }); + + factory ClassClass.fromJson(Map json) => ClassClass( + classClass: json["class"], + ); + + Map toJson() => { + "class": classClass, + }; +} + +class Obj2 { + final Def def; + final Defer defer; + final Deinit deinit; + final Del del; + final Delegate delegate; + final Delete delete; + final Dict dict; + final Dictionary dictionary; + final DidSet didSet; + final int dummy; + final DynamicCast dynamicCast; + final Elif elif; + final EncodeQuickType encodeQuickType; + final EqualityContract equalityContract; + final Event event; + final Except except; + final Exception exception; + final Explicit explicit; + final Exposing exposing; + final Extension extension; + final Extern extern; + final Fallthrough fallthrough; + final Fileprivate fileprivate; + final Fixed fixed; + final Float float; + final Foreach foreach; + final Friend friend; + final From from; + final Func func; + final FunctionClass function; + final Global global; + final Go go; + final Goto goto; + final Guard guard; + final HasOwnProperty hasOwnProperty; + final Id id; + final Imp imp; + final Implicit implicit; + final Indirect indirect; + final Infix infix; + final Init init; + final Inline inline; + final Inout inout; + final Instanceof instanceof; + final Internal internal; + final Default obj2Default; + final Do obj2Do; + final Double obj2Double; + final Dynamic obj2Dynamic; + final Else obj2Else; + final Enum obj2Enum; + final Export obj2Export; + final Extends obj2Extends; + final False obj2False; + final Final obj2Final; + final Finally obj2Finally; + final For obj2For; + final FromJson obj2FromJson; + final Get obj2Get; + final If obj2If; + final Implements obj2Implements; + final Import obj2Import; + final In obj2In; + final Int obj2Int; + final Interface obj2Interface; + final FalseClass purpleFalse; + + Obj2({ + required this.def, + required this.defer, + required this.deinit, + required this.del, + required this.delegate, + required this.delete, + required this.dict, + required this.dictionary, + required this.didSet, + required this.dummy, + required this.dynamicCast, + required this.elif, + required this.encodeQuickType, + required this.equalityContract, + required this.event, + required this.except, + required this.exception, + required this.explicit, + required this.exposing, + required this.extension, + required this.extern, + required this.fallthrough, + required this.fileprivate, + required this.fixed, + required this.float, + required this.foreach, + required this.friend, + required this.from, + required this.func, + required this.function, + required this.global, + required this.go, + required this.goto, + required this.guard, + required this.hasOwnProperty, + required this.id, + required this.imp, + required this.implicit, + required this.indirect, + required this.infix, + required this.init, + required this.inline, + required this.inout, + required this.instanceof, + required this.internal, + required this.obj2Default, + required this.obj2Do, + required this.obj2Double, + required this.obj2Dynamic, + required this.obj2Else, + required this.obj2Enum, + required this.obj2Export, + required this.obj2Extends, + required this.obj2False, + required this.obj2Final, + required this.obj2Finally, + required this.obj2For, + required this.obj2FromJson, + required this.obj2Get, + required this.obj2If, + required this.obj2Implements, + required this.obj2Import, + required this.obj2In, + required this.obj2Int, + required this.obj2Interface, + required this.purpleFalse, + }); + + factory Obj2.fromJson(Map json) => Obj2( + def: Def.fromJson(json["def"]), + defer: Defer.fromJson(json["defer"]), + deinit: Deinit.fromJson(json["deinit"]), + del: Del.fromJson(json["del"]), + delegate: Delegate.fromJson(json["delegate"]), + delete: Delete.fromJson(json["delete"]), + dict: Dict.fromJson(json["dict"]), + dictionary: Dictionary.fromJson(json["dictionary"]), + didSet: DidSet.fromJson(json["didSet"]), + dummy: json["dummy"], + dynamicCast: DynamicCast.fromJson(json["dynamic_cast"]), + elif: Elif.fromJson(json["elif"]), + encodeQuickType: EncodeQuickType.fromJson(json["encode_quick_type"]), + equalityContract: EqualityContract.fromJson(json["equalityContract"]), + event: Event.fromJson(json["event"]), + except: Except.fromJson(json["except"]), + exception: Exception.fromJson(json["exception"]), + explicit: Explicit.fromJson(json["explicit"]), + exposing: Exposing.fromJson(json["exposing"]), + extension: Extension.fromJson(json["extension"]), + extern: Extern.fromJson(json["extern"]), + fallthrough: Fallthrough.fromJson(json["fallthrough"]), + fileprivate: Fileprivate.fromJson(json["fileprivate"]), + fixed: Fixed.fromJson(json["fixed"]), + float: Float.fromJson(json["float"]), + foreach: Foreach.fromJson(json["foreach"]), + friend: Friend.fromJson(json["friend"]), + from: From.fromJson(json["from"]), + func: Func.fromJson(json["func"]), + function: FunctionClass.fromJson(json["function"]), + global: Global.fromJson(json["global"]), + go: Go.fromJson(json["go"]), + goto: Goto.fromJson(json["goto"]), + guard: Guard.fromJson(json["guard"]), + hasOwnProperty: HasOwnProperty.fromJson(json["hasOwnProperty"]), + id: Id.fromJson(json["id"]), + imp: Imp.fromJson(json["IMP"]), + implicit: Implicit.fromJson(json["implicit"]), + indirect: Indirect.fromJson(json["indirect"]), + infix: Infix.fromJson(json["infix"]), + init: Init.fromJson(json["init"]), + inline: Inline.fromJson(json["inline"]), + inout: Inout.fromJson(json["inout"]), + instanceof: Instanceof.fromJson(json["instanceof"]), + internal: Internal.fromJson(json["internal"]), + obj2Default: Default.fromJson(json["default"]), + obj2Do: Do.fromJson(json["do"]), + obj2Double: Double.fromJson(json["double"]), + obj2Dynamic: Dynamic.fromJson(json["dynamic"]), + obj2Else: Else.fromJson(json["else"]), + obj2Enum: Enum.fromJson(json["enum"]), + obj2Export: Export.fromJson(json["export"]), + obj2Extends: Extends.fromJson(json["extends"]), + obj2False: False.fromJson(json["False"]), + obj2Final: Final.fromJson(json["final"]), + obj2Finally: Finally.fromJson(json["finally"]), + obj2For: For.fromJson(json["for"]), + obj2FromJson: FromJson.fromJson(json["from_json"]), + obj2Get: Get.fromJson(json["get"]), + obj2If: If.fromJson(json["if"]), + obj2Implements: Implements.fromJson(json["implements"]), + obj2Import: Import.fromJson(json["import"]), + obj2In: In.fromJson(json["in"]), + obj2Int: Int.fromJson(json["int"]), + obj2Interface: Interface.fromJson(json["interface"]), + purpleFalse: FalseClass.fromJson(json["false"]), + ); + + Map toJson() => { + "def": def.toJson(), + "defer": defer.toJson(), + "deinit": deinit.toJson(), + "del": del.toJson(), + "delegate": delegate.toJson(), + "delete": delete.toJson(), + "dict": dict.toJson(), + "dictionary": dictionary.toJson(), + "didSet": didSet.toJson(), + "dummy": dummy, + "dynamic_cast": dynamicCast.toJson(), + "elif": elif.toJson(), + "encode_quick_type": encodeQuickType.toJson(), + "equalityContract": equalityContract.toJson(), + "event": event.toJson(), + "except": except.toJson(), + "exception": exception.toJson(), + "explicit": explicit.toJson(), + "exposing": exposing.toJson(), + "extension": extension.toJson(), + "extern": extern.toJson(), + "fallthrough": fallthrough.toJson(), + "fileprivate": fileprivate.toJson(), + "fixed": fixed.toJson(), + "float": float.toJson(), + "foreach": foreach.toJson(), + "friend": friend.toJson(), + "from": from.toJson(), + "func": func.toJson(), + "function": function.toJson(), + "global": global.toJson(), + "go": go.toJson(), + "goto": goto.toJson(), + "guard": guard.toJson(), + "hasOwnProperty": hasOwnProperty.toJson(), + "id": id.toJson(), + "IMP": imp.toJson(), + "implicit": implicit.toJson(), + "indirect": indirect.toJson(), + "infix": infix.toJson(), + "init": init.toJson(), + "inline": inline.toJson(), + "inout": inout.toJson(), + "instanceof": instanceof.toJson(), + "internal": internal.toJson(), + "default": obj2Default.toJson(), + "do": obj2Do.toJson(), + "double": obj2Double.toJson(), + "dynamic": obj2Dynamic.toJson(), + "else": obj2Else.toJson(), + "enum": obj2Enum.toJson(), + "export": obj2Export.toJson(), + "extends": obj2Extends.toJson(), + "False": obj2False.toJson(), + "final": obj2Final.toJson(), + "finally": obj2Finally.toJson(), + "for": obj2For.toJson(), + "from_json": obj2FromJson.toJson(), + "get": obj2Get.toJson(), + "if": obj2If.toJson(), + "implements": obj2Implements.toJson(), + "import": obj2Import.toJson(), + "in": obj2In.toJson(), + "int": obj2Int.toJson(), + "interface": obj2Interface.toJson(), + "false": purpleFalse.toJson(), + }; +} + +class Def { + final int def; + + Def({ + required this.def, + }); + + factory Def.fromJson(Map json) => Def( + def: json["def"], + ); + + Map toJson() => { + "def": def, + }; +} + +class Defer { + final int defer; + + Defer({ + required this.defer, + }); + + factory Defer.fromJson(Map json) => Defer( + defer: json["defer"], + ); + + Map toJson() => { + "defer": defer, + }; +} + +class Deinit { + final int deinit; + + Deinit({ + required this.deinit, + }); + + factory Deinit.fromJson(Map json) => Deinit( + deinit: json["deinit"], + ); + + Map toJson() => { + "deinit": deinit, + }; +} + +class Del { + final int del; + + Del({ + required this.del, + }); + + factory Del.fromJson(Map json) => Del( + del: json["del"], + ); + + Map toJson() => { + "del": del, + }; +} + +class Delegate { + final int delegate; + + Delegate({ + required this.delegate, + }); + + factory Delegate.fromJson(Map json) => Delegate( + delegate: json["delegate"], + ); + + Map toJson() => { + "delegate": delegate, + }; +} + +class Delete { + final int delete; + + Delete({ + required this.delete, + }); + + factory Delete.fromJson(Map json) => Delete( + delete: json["delete"], + ); + + Map toJson() => { + "delete": delete, + }; +} + +class Dict { + final int dict; + + Dict({ + required this.dict, + }); + + factory Dict.fromJson(Map json) => Dict( + dict: json["dict"], + ); + + Map toJson() => { + "dict": dict, + }; +} + +class Dictionary { + final int dictionary; + + Dictionary({ + required this.dictionary, + }); + + factory Dictionary.fromJson(Map json) => Dictionary( + dictionary: json["dictionary"], + ); + + Map toJson() => { + "dictionary": dictionary, + }; +} + +class DidSet { + final int didSet; + + DidSet({ + required this.didSet, + }); + + factory DidSet.fromJson(Map json) => DidSet( + didSet: json["didSet"], + ); + + Map toJson() => { + "didSet": didSet, + }; +} + +class DynamicCast { + final int dynamicCast; + + DynamicCast({ + required this.dynamicCast, + }); + + factory DynamicCast.fromJson(Map json) => DynamicCast( + dynamicCast: json["dynamic_cast"], + ); + + Map toJson() => { + "dynamic_cast": dynamicCast, + }; +} + +class Elif { + final int elif; + + Elif({ + required this.elif, + }); + + factory Elif.fromJson(Map json) => Elif( + elif: json["elif"], + ); + + Map toJson() => { + "elif": elif, + }; +} + +class EncodeQuickType { + final int encodeQuickType; + + EncodeQuickType({ + required this.encodeQuickType, + }); + + factory EncodeQuickType.fromJson(Map json) => EncodeQuickType( + encodeQuickType: json["encode_quick_type"], + ); + + Map toJson() => { + "encode_quick_type": encodeQuickType, + }; +} + +class EqualityContract { + final int equalityContract; + + EqualityContract({ + required this.equalityContract, + }); + + factory EqualityContract.fromJson(Map json) => EqualityContract( + equalityContract: json["equalityContract"], + ); + + Map toJson() => { + "equalityContract": equalityContract, + }; +} + +class Event { + final int event; + + Event({ + required this.event, + }); + + factory Event.fromJson(Map json) => Event( + event: json["event"], + ); + + Map toJson() => { + "event": event, + }; +} + +class Except { + final int except; + + Except({ + required this.except, + }); + + factory Except.fromJson(Map json) => Except( + except: json["except"], + ); + + Map toJson() => { + "except": except, + }; +} + +class Exception { + final int exception; + + Exception({ + required this.exception, + }); + + factory Exception.fromJson(Map json) => Exception( + exception: json["exception"], + ); + + Map toJson() => { + "exception": exception, + }; +} + +class Explicit { + final int explicit; + + Explicit({ + required this.explicit, + }); + + factory Explicit.fromJson(Map json) => Explicit( + explicit: json["explicit"], + ); + + Map toJson() => { + "explicit": explicit, + }; +} + +class Exposing { + final int exposing; + + Exposing({ + required this.exposing, + }); + + factory Exposing.fromJson(Map json) => Exposing( + exposing: json["exposing"], + ); + + Map toJson() => { + "exposing": exposing, + }; +} + +class Extension { + final int extension; + + Extension({ + required this.extension, + }); + + factory Extension.fromJson(Map json) => Extension( + extension: json["extension"], + ); + + Map toJson() => { + "extension": extension, + }; +} + +class Extern { + final int extern; + + Extern({ + required this.extern, + }); + + factory Extern.fromJson(Map json) => Extern( + extern: json["extern"], + ); + + Map toJson() => { + "extern": extern, + }; +} + +class Fallthrough { + final int fallthrough; + + Fallthrough({ + required this.fallthrough, + }); + + factory Fallthrough.fromJson(Map json) => Fallthrough( + fallthrough: json["fallthrough"], + ); + + Map toJson() => { + "fallthrough": fallthrough, + }; +} + +class Fileprivate { + final int fileprivate; + + Fileprivate({ + required this.fileprivate, + }); + + factory Fileprivate.fromJson(Map json) => Fileprivate( + fileprivate: json["fileprivate"], + ); + + Map toJson() => { + "fileprivate": fileprivate, + }; +} + +class Fixed { + final int fixed; + + Fixed({ + required this.fixed, + }); + + factory Fixed.fromJson(Map json) => Fixed( + fixed: json["fixed"], + ); + + Map toJson() => { + "fixed": fixed, + }; +} + +class Float { + final int float; + + Float({ + required this.float, + }); + + factory Float.fromJson(Map json) => Float( + float: json["float"], + ); + + Map toJson() => { + "float": float, + }; +} + +class Foreach { + final int foreach; + + Foreach({ + required this.foreach, + }); + + factory Foreach.fromJson(Map json) => Foreach( + foreach: json["foreach"], + ); + + Map toJson() => { + "foreach": foreach, + }; +} + +class Friend { + final int friend; + + Friend({ + required this.friend, + }); + + factory Friend.fromJson(Map json) => Friend( + friend: json["friend"], + ); + + Map toJson() => { + "friend": friend, + }; +} + +class From { + final int from; + + From({ + required this.from, + }); + + factory From.fromJson(Map json) => From( + from: json["from"], + ); + + Map toJson() => { + "from": from, + }; +} + +class Func { + final int func; + + Func({ + required this.func, + }); + + factory Func.fromJson(Map json) => Func( + func: json["func"], + ); + + Map toJson() => { + "func": func, + }; +} + +class FunctionClass { + final int function; + + FunctionClass({ + required this.function, + }); + + factory FunctionClass.fromJson(Map json) => FunctionClass( + function: json["function"], + ); + + Map toJson() => { + "function": function, + }; +} + +class Global { + final int global; + + Global({ + required this.global, + }); + + factory Global.fromJson(Map json) => Global( + global: json["global"], + ); + + Map toJson() => { + "global": global, + }; +} + +class Go { + final int go; + + Go({ + required this.go, + }); + + factory Go.fromJson(Map json) => Go( + go: json["go"], + ); + + Map toJson() => { + "go": go, + }; +} + +class Goto { + final int goto; + + Goto({ + required this.goto, + }); + + factory Goto.fromJson(Map json) => Goto( + goto: json["goto"], + ); + + Map toJson() => { + "goto": goto, + }; +} + +class Guard { + final int guard; + + Guard({ + required this.guard, + }); + + factory Guard.fromJson(Map json) => Guard( + guard: json["guard"], + ); + + Map toJson() => { + "guard": guard, + }; +} + +class HasOwnProperty { + final int hasOwnProperty; + + HasOwnProperty({ + required this.hasOwnProperty, + }); + + factory HasOwnProperty.fromJson(Map json) => HasOwnProperty( + hasOwnProperty: json["hasOwnProperty"], + ); + + Map toJson() => { + "hasOwnProperty": hasOwnProperty, + }; +} + +class Id { + final int id; + + Id({ + required this.id, + }); + + factory Id.fromJson(Map json) => Id( + id: json["id"], + ); + + Map toJson() => { + "id": id, + }; +} + +class Imp { + final int imp; + + Imp({ + required this.imp, + }); + + factory Imp.fromJson(Map json) => Imp( + imp: json["IMP"], + ); + + Map toJson() => { + "IMP": imp, + }; +} + +class Implicit { + final int implicit; + + Implicit({ + required this.implicit, + }); + + factory Implicit.fromJson(Map json) => Implicit( + implicit: json["implicit"], + ); + + Map toJson() => { + "implicit": implicit, + }; +} + +class Indirect { + final int indirect; + + Indirect({ + required this.indirect, + }); + + factory Indirect.fromJson(Map json) => Indirect( + indirect: json["indirect"], + ); + + Map toJson() => { + "indirect": indirect, + }; +} + +class Infix { + final int infix; + + Infix({ + required this.infix, + }); + + factory Infix.fromJson(Map json) => Infix( + infix: json["infix"], + ); + + Map toJson() => { + "infix": infix, + }; +} + +class Init { + final int init; + + Init({ + required this.init, + }); + + factory Init.fromJson(Map json) => Init( + init: json["init"], + ); + + Map toJson() => { + "init": init, + }; +} + +class Inline { + final int inline; + + Inline({ + required this.inline, + }); + + factory Inline.fromJson(Map json) => Inline( + inline: json["inline"], + ); + + Map toJson() => { + "inline": inline, + }; +} + +class Inout { + final int inout; + + Inout({ + required this.inout, + }); + + factory Inout.fromJson(Map json) => Inout( + inout: json["inout"], + ); + + Map toJson() => { + "inout": inout, + }; +} + +class Instanceof { + final int instanceof; + + Instanceof({ + required this.instanceof, + }); + + factory Instanceof.fromJson(Map json) => Instanceof( + instanceof: json["instanceof"], + ); + + Map toJson() => { + "instanceof": instanceof, + }; +} + +class Internal { + final int internal; + + Internal({ + required this.internal, + }); + + factory Internal.fromJson(Map json) => Internal( + internal: json["internal"], + ); + + Map toJson() => { + "internal": internal, + }; +} + +class Default { + final int defaultDefault; + + Default({ + required this.defaultDefault, + }); + + factory Default.fromJson(Map json) => Default( + defaultDefault: json["default"], + ); + + Map toJson() => { + "default": defaultDefault, + }; +} + +class Do { + final int doDo; + + Do({ + required this.doDo, + }); + + factory Do.fromJson(Map json) => Do( + doDo: json["do"], + ); + + Map toJson() => { + "do": doDo, + }; +} + +class Double { + final int doubleDouble; + + Double({ + required this.doubleDouble, + }); + + factory Double.fromJson(Map json) => Double( + doubleDouble: json["double"], + ); + + Map toJson() => { + "double": doubleDouble, + }; +} + +class Dynamic { + final int dynamicDynamic; + + Dynamic({ + required this.dynamicDynamic, + }); + + factory Dynamic.fromJson(Map json) => Dynamic( + dynamicDynamic: json["dynamic"], + ); + + Map toJson() => { + "dynamic": dynamicDynamic, + }; +} + +class Else { + final int elseElse; + + Else({ + required this.elseElse, + }); + + factory Else.fromJson(Map json) => Else( + elseElse: json["else"], + ); + + Map toJson() => { + "else": elseElse, + }; +} + +class Enum { + final int enumEnum; + + Enum({ + required this.enumEnum, + }); + + factory Enum.fromJson(Map json) => Enum( + enumEnum: json["enum"], + ); + + Map toJson() => { + "enum": enumEnum, + }; +} + +class Export { + final int exportExport; + + Export({ + required this.exportExport, + }); + + factory Export.fromJson(Map json) => Export( + exportExport: json["export"], + ); + + Map toJson() => { + "export": exportExport, + }; +} + +class Extends { + final int extendsExtends; + + Extends({ + required this.extendsExtends, + }); + + factory Extends.fromJson(Map json) => Extends( + extendsExtends: json["extends"], + ); + + Map toJson() => { + "extends": extendsExtends, + }; +} + +class False { + final int falseFalse; + + False({ + required this.falseFalse, + }); + + factory False.fromJson(Map json) => False( + falseFalse: json["False"], + ); + + Map toJson() => { + "False": falseFalse, + }; +} + +class Final { + final int finalFinal; + + Final({ + required this.finalFinal, + }); + + factory Final.fromJson(Map json) => Final( + finalFinal: json["final"], + ); + + Map toJson() => { + "final": finalFinal, + }; +} + +class Finally { + final int finallyFinally; + + Finally({ + required this.finallyFinally, + }); + + factory Finally.fromJson(Map json) => Finally( + finallyFinally: json["finally"], + ); + + Map toJson() => { + "finally": finallyFinally, + }; +} + +class For { + final int forFor; + + For({ + required this.forFor, + }); + + factory For.fromJson(Map json) => For( + forFor: json["for"], + ); + + Map toJson() => { + "for": forFor, + }; +} + +class FromJson { + final int fromJsonFromJson; + + FromJson({ + required this.fromJsonFromJson, + }); + + factory FromJson.fromJson(Map json) => FromJson( + fromJsonFromJson: json["from_json"], + ); + + Map toJson() => { + "from_json": fromJsonFromJson, + }; +} + +class Get { + final int getGet; + + Get({ + required this.getGet, + }); + + factory Get.fromJson(Map json) => Get( + getGet: json["get"], + ); + + Map toJson() => { + "get": getGet, + }; +} + +class If { + final int ifIf; + + If({ + required this.ifIf, + }); + + factory If.fromJson(Map json) => If( + ifIf: json["if"], + ); + + Map toJson() => { + "if": ifIf, + }; +} + +class Implements { + final int implementsImplements; + + Implements({ + required this.implementsImplements, + }); + + factory Implements.fromJson(Map json) => Implements( + implementsImplements: json["implements"], + ); + + Map toJson() => { + "implements": implementsImplements, + }; +} + +class Import { + final int importImport; + + Import({ + required this.importImport, + }); + + factory Import.fromJson(Map json) => Import( + importImport: json["import"], + ); + + Map toJson() => { + "import": importImport, + }; +} + +class In { + final int inIn; + + In({ + required this.inIn, + }); + + factory In.fromJson(Map json) => In( + inIn: json["in"], + ); + + Map toJson() => { + "in": inIn, + }; +} + +class Int { + final int intInt; + + Int({ + required this.intInt, + }); + + factory Int.fromJson(Map json) => Int( + intInt: json["int"], + ); + + Map toJson() => { + "int": intInt, + }; +} + +class Interface { + final int interfaceInterface; + + Interface({ + required this.interfaceInterface, + }); + + factory Interface.fromJson(Map json) => Interface( + interfaceInterface: json["interface"], + ); + + Map toJson() => { + "interface": interfaceInterface, + }; +} + +class FalseClass { + final int falseFalse; + + FalseClass({ + required this.falseFalse, + }); + + factory FalseClass.fromJson(Map json) => FalseClass( + falseFalse: json["false"], + ); + + Map toJson() => { + "false": falseFalse, + }; +} + +class Obj3 { + final int dummy; + final Iterable iterable; + final Jdec jdec; + final Jenc jenc; + final Jpipe jpipe; + final Json json; + final JsonConverter jsonConverter; + final JsonSerializer jsonSerializer; + final JsonToken jsonToken; + final JsonWriter jsonWriter; + final Lambda lambda; + final Lazy lazy; + final Left left; + final Let let; + final ListClass list; + final Lock lock; + final Long long; + final MapClass map; + final MetadataPropertyHandling metadataPropertyHandling; + final Module module; + final Mutable mutable; + final Mutating mutating; + final Namespace namespace; + final Native native; + final Newtonsoft newtonsoft; + final Nil nil; + final No no; + final Noexcept noexcept; + final Nonatomic nonatomic; + final None none; + final Nonlocal nonlocal; + final Nonmutating nonmutating; + final Not not; + final NotEq notEq; + final NsString nsString; + final Nullptr nullptr; + final Number number; + final Is obj3Is; + final New obj3New; + final NoneClass obj3None; + final Null obj3Null; + final Operator obj3Operator; + final ProtocolClass obj3Protocol; + final Object object; + final Of of; + final Oneway oneway; + final Open open; + final Optional optional; + final Or or; + final OrEq orEq; + final Out out; + final Override override; + final Package package; + final Params params; + final Pass pass; + final Port port; + final Postfix postfix; + final Precedence precedence; + final Prefix prefix; + final Print print; + final PrintMembers printMembers; + final Printf printf; + final Private private; + final Protected protected; + final Protocol protocol; + final NullClass purpleNull; + + Obj3({ + required this.dummy, + required this.iterable, + required this.jdec, + required this.jenc, + required this.jpipe, + required this.json, + required this.jsonConverter, + required this.jsonSerializer, + required this.jsonToken, + required this.jsonWriter, + required this.lambda, + required this.lazy, + required this.left, + required this.let, + required this.list, + required this.lock, + required this.long, + required this.map, + required this.metadataPropertyHandling, + required this.module, + required this.mutable, + required this.mutating, + required this.namespace, + required this.native, + required this.newtonsoft, + required this.nil, + required this.no, + required this.noexcept, + required this.nonatomic, + required this.none, + required this.nonlocal, + required this.nonmutating, + required this.not, + required this.notEq, + required this.nsString, + required this.nullptr, + required this.number, + required this.obj3Is, + required this.obj3New, + required this.obj3None, + required this.obj3Null, + required this.obj3Operator, + required this.obj3Protocol, + required this.object, + required this.of, + required this.oneway, + required this.open, + required this.optional, + required this.or, + required this.orEq, + required this.out, + required this.override, + required this.package, + required this.params, + required this.pass, + required this.port, + required this.postfix, + required this.precedence, + required this.prefix, + required this.print, + required this.printMembers, + required this.printf, + required this.private, + required this.protected, + required this.protocol, + required this.purpleNull, + }); + + factory Obj3.fromJson(Map json) => Obj3( + dummy: json["dummy"], + iterable: Iterable.fromJson(json["iterable"]), + jdec: Jdec.fromJson(json["jdec"]), + jenc: Jenc.fromJson(json["jenc"]), + jpipe: Jpipe.fromJson(json["jpipe"]), + json: Json.fromJson(json["json"]), + jsonConverter: JsonConverter.fromJson(json["json_converter"]), + jsonSerializer: JsonSerializer.fromJson(json["json_serializer"]), + jsonToken: JsonToken.fromJson(json["json_token"]), + jsonWriter: JsonWriter.fromJson(json["json_writer"]), + lambda: Lambda.fromJson(json["lambda"]), + lazy: Lazy.fromJson(json["lazy"]), + left: Left.fromJson(json["left"]), + let: Let.fromJson(json["let"]), + list: ListClass.fromJson(json["list"]), + lock: Lock.fromJson(json["lock"]), + long: Long.fromJson(json["long"]), + map: MapClass.fromJson(json["map"]), + metadataPropertyHandling: MetadataPropertyHandling.fromJson(json["metadata_property_handling"]), + module: Module.fromJson(json["module"]), + mutable: Mutable.fromJson(json["mutable"]), + mutating: Mutating.fromJson(json["mutating"]), + namespace: Namespace.fromJson(json["namespace"]), + native: Native.fromJson(json["native"]), + newtonsoft: Newtonsoft.fromJson(json["newtonsoft"]), + nil: Nil.fromJson(json["nil"]), + no: No.fromJson(json["NO"]), + noexcept: Noexcept.fromJson(json["noexcept"]), + nonatomic: Nonatomic.fromJson(json["nonatomic"]), + none: None.fromJson(json["None"]), + nonlocal: Nonlocal.fromJson(json["nonlocal"]), + nonmutating: Nonmutating.fromJson(json["nonmutating"]), + not: Not.fromJson(json["not"]), + notEq: NotEq.fromJson(json["not_eq"]), + nsString: NsString.fromJson(json["NSString"]), + nullptr: Nullptr.fromJson(json["nullptr"]), + number: Number.fromJson(json["number"]), + obj3Is: Is.fromJson(json["is"]), + obj3New: New.fromJson(json["new"]), + obj3None: NoneClass.fromJson(json["none"]), + obj3Null: Null.fromJson(json["NULL"]), + obj3Operator: Operator.fromJson(json["operator"]), + obj3Protocol: ProtocolClass.fromJson(json["protocol"]), + object: Object.fromJson(json["object"]), + of: Of.fromJson(json["of"]), + oneway: Oneway.fromJson(json["oneway"]), + open: Open.fromJson(json["open"]), + optional: Optional.fromJson(json["optional"]), + or: Or.fromJson(json["or"]), + orEq: OrEq.fromJson(json["or_eq"]), + out: Out.fromJson(json["out"]), + override: Override.fromJson(json["override"]), + package: Package.fromJson(json["package"]), + params: Params.fromJson(json["params"]), + pass: Pass.fromJson(json["pass"]), + port: Port.fromJson(json["port"]), + postfix: Postfix.fromJson(json["postfix"]), + precedence: Precedence.fromJson(json["precedence"]), + prefix: Prefix.fromJson(json["prefix"]), + print: Print.fromJson(json["print"]), + printMembers: PrintMembers.fromJson(json["printMembers"]), + printf: Printf.fromJson(json["printf"]), + private: Private.fromJson(json["private"]), + protected: Protected.fromJson(json["protected"]), + protocol: Protocol.fromJson(json["Protocol"]), + purpleNull: NullClass.fromJson(json["null"]), + ); + + Map toJson() => { + "dummy": dummy, + "iterable": iterable.toJson(), + "jdec": jdec.toJson(), + "jenc": jenc.toJson(), + "jpipe": jpipe.toJson(), + "json": json.toJson(), + "json_converter": jsonConverter.toJson(), + "json_serializer": jsonSerializer.toJson(), + "json_token": jsonToken.toJson(), + "json_writer": jsonWriter.toJson(), + "lambda": lambda.toJson(), + "lazy": lazy.toJson(), + "left": left.toJson(), + "let": let.toJson(), + "list": list.toJson(), + "lock": lock.toJson(), + "long": long.toJson(), + "map": map.toJson(), + "metadata_property_handling": metadataPropertyHandling.toJson(), + "module": module.toJson(), + "mutable": mutable.toJson(), + "mutating": mutating.toJson(), + "namespace": namespace.toJson(), + "native": native.toJson(), + "newtonsoft": newtonsoft.toJson(), + "nil": nil.toJson(), + "NO": no.toJson(), + "noexcept": noexcept.toJson(), + "nonatomic": nonatomic.toJson(), + "None": none.toJson(), + "nonlocal": nonlocal.toJson(), + "nonmutating": nonmutating.toJson(), + "not": not.toJson(), + "not_eq": notEq.toJson(), + "NSString": nsString.toJson(), + "nullptr": nullptr.toJson(), + "number": number.toJson(), + "is": obj3Is.toJson(), + "new": obj3New.toJson(), + "none": obj3None.toJson(), + "NULL": obj3Null.toJson(), + "operator": obj3Operator.toJson(), + "protocol": obj3Protocol.toJson(), + "object": object.toJson(), + "of": of.toJson(), + "oneway": oneway.toJson(), + "open": open.toJson(), + "optional": optional.toJson(), + "or": or.toJson(), + "or_eq": orEq.toJson(), + "out": out.toJson(), + "override": override.toJson(), + "package": package.toJson(), + "params": params.toJson(), + "pass": pass.toJson(), + "port": port.toJson(), + "postfix": postfix.toJson(), + "precedence": precedence.toJson(), + "prefix": prefix.toJson(), + "print": print.toJson(), + "printMembers": printMembers.toJson(), + "printf": printf.toJson(), + "private": private.toJson(), + "protected": protected.toJson(), + "Protocol": protocol.toJson(), + "null": purpleNull.toJson(), + }; +} + +class Iterable { + final int iterable; + + Iterable({ + required this.iterable, + }); + + factory Iterable.fromJson(Map json) => Iterable( + iterable: json["iterable"], + ); + + Map toJson() => { + "iterable": iterable, + }; +} + +class Jdec { + final int jdec; + + Jdec({ + required this.jdec, + }); + + factory Jdec.fromJson(Map json) => Jdec( + jdec: json["jdec"], + ); + + Map toJson() => { + "jdec": jdec, + }; +} + +class Jenc { + final int jenc; + + Jenc({ + required this.jenc, + }); + + factory Jenc.fromJson(Map json) => Jenc( + jenc: json["jenc"], + ); + + Map toJson() => { + "jenc": jenc, + }; +} + +class Jpipe { + final int jpipe; + + Jpipe({ + required this.jpipe, + }); + + factory Jpipe.fromJson(Map json) => Jpipe( + jpipe: json["jpipe"], + ); + + Map toJson() => { + "jpipe": jpipe, + }; +} + +class Json { + final int json; + + Json({ + required this.json, + }); + + factory Json.fromJson(Map json) => Json( + json: json["json"], + ); + + Map toJson() => { + "json": json, + }; +} + +class JsonConverter { + final int jsonConverter; + + JsonConverter({ + required this.jsonConverter, + }); + + factory JsonConverter.fromJson(Map json) => JsonConverter( + jsonConverter: json["json_converter"], + ); + + Map toJson() => { + "json_converter": jsonConverter, + }; +} + +class JsonSerializer { + final int jsonSerializer; + + JsonSerializer({ + required this.jsonSerializer, + }); + + factory JsonSerializer.fromJson(Map json) => JsonSerializer( + jsonSerializer: json["json_serializer"], + ); + + Map toJson() => { + "json_serializer": jsonSerializer, + }; +} + +class JsonToken { + final int jsonToken; + + JsonToken({ + required this.jsonToken, + }); + + factory JsonToken.fromJson(Map json) => JsonToken( + jsonToken: json["json_token"], + ); + + Map toJson() => { + "json_token": jsonToken, + }; +} + +class JsonWriter { + final int jsonWriter; + + JsonWriter({ + required this.jsonWriter, + }); + + factory JsonWriter.fromJson(Map json) => JsonWriter( + jsonWriter: json["json_writer"], + ); + + Map toJson() => { + "json_writer": jsonWriter, + }; +} + +class Lambda { + final int lambda; + + Lambda({ + required this.lambda, + }); + + factory Lambda.fromJson(Map json) => Lambda( + lambda: json["lambda"], + ); + + Map toJson() => { + "lambda": lambda, + }; +} + +class Lazy { + final int lazy; + + Lazy({ + required this.lazy, + }); + + factory Lazy.fromJson(Map json) => Lazy( + lazy: json["lazy"], + ); + + Map toJson() => { + "lazy": lazy, + }; +} + +class Left { + final int left; + + Left({ + required this.left, + }); + + factory Left.fromJson(Map json) => Left( + left: json["left"], + ); + + Map toJson() => { + "left": left, + }; +} + +class Let { + final int let; + + Let({ + required this.let, + }); + + factory Let.fromJson(Map json) => Let( + let: json["let"], + ); + + Map toJson() => { + "let": let, + }; +} + +class ListClass { + final int list; + + ListClass({ + required this.list, + }); + + factory ListClass.fromJson(Map json) => ListClass( + list: json["list"], + ); + + Map toJson() => { + "list": list, + }; +} + +class Lock { + final int lock; + + Lock({ + required this.lock, + }); + + factory Lock.fromJson(Map json) => Lock( + lock: json["lock"], + ); + + Map toJson() => { + "lock": lock, + }; +} + +class Long { + final int long; + + Long({ + required this.long, + }); + + factory Long.fromJson(Map json) => Long( + long: json["long"], + ); + + Map toJson() => { + "long": long, + }; +} + +class MapClass { + final int map; + + MapClass({ + required this.map, + }); + + factory MapClass.fromJson(Map json) => MapClass( + map: json["map"], + ); + + Map toJson() => { + "map": map, + }; +} + +class MetadataPropertyHandling { + final int metadataPropertyHandling; + + MetadataPropertyHandling({ + required this.metadataPropertyHandling, + }); + + factory MetadataPropertyHandling.fromJson(Map json) => MetadataPropertyHandling( + metadataPropertyHandling: json["metadata_property_handling"], + ); + + Map toJson() => { + "metadata_property_handling": metadataPropertyHandling, + }; +} + +class Module { + final int module; + + Module({ + required this.module, + }); + + factory Module.fromJson(Map json) => Module( + module: json["module"], + ); + + Map toJson() => { + "module": module, + }; +} + +class Mutable { + final int mutable; + + Mutable({ + required this.mutable, + }); + + factory Mutable.fromJson(Map json) => Mutable( + mutable: json["mutable"], + ); + + Map toJson() => { + "mutable": mutable, + }; +} + +class Mutating { + final int mutating; + + Mutating({ + required this.mutating, + }); + + factory Mutating.fromJson(Map json) => Mutating( + mutating: json["mutating"], + ); + + Map toJson() => { + "mutating": mutating, + }; +} + +class Namespace { + final int namespace; + + Namespace({ + required this.namespace, + }); + + factory Namespace.fromJson(Map json) => Namespace( + namespace: json["namespace"], + ); + + Map toJson() => { + "namespace": namespace, + }; +} + +class Native { + final int native; + + Native({ + required this.native, + }); + + factory Native.fromJson(Map json) => Native( + native: json["native"], + ); + + Map toJson() => { + "native": native, + }; +} + +class Newtonsoft { + final int newtonsoft; + + Newtonsoft({ + required this.newtonsoft, + }); + + factory Newtonsoft.fromJson(Map json) => Newtonsoft( + newtonsoft: json["newtonsoft"], + ); + + Map toJson() => { + "newtonsoft": newtonsoft, + }; +} + +class Nil { + final int nil; + + Nil({ + required this.nil, + }); + + factory Nil.fromJson(Map json) => Nil( + nil: json["nil"], + ); + + Map toJson() => { + "nil": nil, + }; +} + +class No { + final int no; + + No({ + required this.no, + }); + + factory No.fromJson(Map json) => No( + no: json["NO"], + ); + + Map toJson() => { + "NO": no, + }; +} + +class Noexcept { + final int noexcept; + + Noexcept({ + required this.noexcept, + }); + + factory Noexcept.fromJson(Map json) => Noexcept( + noexcept: json["noexcept"], + ); + + Map toJson() => { + "noexcept": noexcept, + }; +} + +class Nonatomic { + final int nonatomic; + + Nonatomic({ + required this.nonatomic, + }); + + factory Nonatomic.fromJson(Map json) => Nonatomic( + nonatomic: json["nonatomic"], + ); + + Map toJson() => { + "nonatomic": nonatomic, + }; +} + +class None { + final int none; + + None({ + required this.none, + }); + + factory None.fromJson(Map json) => None( + none: json["None"], + ); + + Map toJson() => { + "None": none, + }; +} + +class Nonlocal { + final int nonlocal; + + Nonlocal({ + required this.nonlocal, + }); + + factory Nonlocal.fromJson(Map json) => Nonlocal( + nonlocal: json["nonlocal"], + ); + + Map toJson() => { + "nonlocal": nonlocal, + }; +} + +class Nonmutating { + final int nonmutating; + + Nonmutating({ + required this.nonmutating, + }); + + factory Nonmutating.fromJson(Map json) => Nonmutating( + nonmutating: json["nonmutating"], + ); + + Map toJson() => { + "nonmutating": nonmutating, + }; +} + +class Not { + final int not; + + Not({ + required this.not, + }); + + factory Not.fromJson(Map json) => Not( + not: json["not"], + ); + + Map toJson() => { + "not": not, + }; +} + +class NotEq { + final int notEq; + + NotEq({ + required this.notEq, + }); + + factory NotEq.fromJson(Map json) => NotEq( + notEq: json["not_eq"], + ); + + Map toJson() => { + "not_eq": notEq, + }; +} + +class NsString { + final int nsString; + + NsString({ + required this.nsString, + }); + + factory NsString.fromJson(Map json) => NsString( + nsString: json["NSString"], + ); + + Map toJson() => { + "NSString": nsString, + }; +} + +class Nullptr { + final int nullptr; + + Nullptr({ + required this.nullptr, + }); + + factory Nullptr.fromJson(Map json) => Nullptr( + nullptr: json["nullptr"], + ); + + Map toJson() => { + "nullptr": nullptr, + }; +} + +class Number { + final int number; + + Number({ + required this.number, + }); + + factory Number.fromJson(Map json) => Number( + number: json["number"], + ); + + Map toJson() => { + "number": number, + }; +} + +class Is { + final int isIs; + + Is({ + required this.isIs, + }); + + factory Is.fromJson(Map json) => Is( + isIs: json["is"], + ); + + Map toJson() => { + "is": isIs, + }; +} + +class New { + final int newNew; + + New({ + required this.newNew, + }); + + factory New.fromJson(Map json) => New( + newNew: json["new"], + ); + + Map toJson() => { + "new": newNew, + }; +} + +class NoneClass { + final int none; + + NoneClass({ + required this.none, + }); + + factory NoneClass.fromJson(Map json) => NoneClass( + none: json["none"], + ); + + Map toJson() => { + "none": none, + }; +} + +class Null { + final int nullNull; + + Null({ + required this.nullNull, + }); + + factory Null.fromJson(Map json) => Null( + nullNull: json["NULL"], + ); + + Map toJson() => { + "NULL": nullNull, + }; +} + +class Operator { + final int operatorOperator; + + Operator({ + required this.operatorOperator, + }); + + factory Operator.fromJson(Map json) => Operator( + operatorOperator: json["operator"], + ); + + Map toJson() => { + "operator": operatorOperator, + }; +} + +class ProtocolClass { + final int protocol; + + ProtocolClass({ + required this.protocol, + }); + + factory ProtocolClass.fromJson(Map json) => ProtocolClass( + protocol: json["protocol"], + ); + + Map toJson() => { + "protocol": protocol, + }; +} + +class Object { + final int object; + + Object({ + required this.object, + }); + + factory Object.fromJson(Map json) => Object( + object: json["object"], + ); + + Map toJson() => { + "object": object, + }; +} + +class Of { + final int of; + + Of({ + required this.of, + }); + + factory Of.fromJson(Map json) => Of( + of: json["of"], + ); + + Map toJson() => { + "of": of, + }; +} + +class Oneway { + final int oneway; + + Oneway({ + required this.oneway, + }); + + factory Oneway.fromJson(Map json) => Oneway( + oneway: json["oneway"], + ); + + Map toJson() => { + "oneway": oneway, + }; +} + +class Open { + final int open; + + Open({ + required this.open, + }); + + factory Open.fromJson(Map json) => Open( + open: json["open"], + ); + + Map toJson() => { + "open": open, + }; +} + +class Optional { + final int optional; + + Optional({ + required this.optional, + }); + + factory Optional.fromJson(Map json) => Optional( + optional: json["optional"], + ); + + Map toJson() => { + "optional": optional, + }; +} + +class Or { + final int or; + + Or({ + required this.or, + }); + + factory Or.fromJson(Map json) => Or( + or: json["or"], + ); + + Map toJson() => { + "or": or, + }; +} + +class OrEq { + final int orEq; + + OrEq({ + required this.orEq, + }); + + factory OrEq.fromJson(Map json) => OrEq( + orEq: json["or_eq"], + ); + + Map toJson() => { + "or_eq": orEq, + }; +} + +class Out { + final int out; + + Out({ + required this.out, + }); + + factory Out.fromJson(Map json) => Out( + out: json["out"], + ); + + Map toJson() => { + "out": out, + }; +} + +class Override { + final int override; + + Override({ + required this.override, + }); + + factory Override.fromJson(Map json) => Override( + override: json["override"], + ); + + Map toJson() => { + "override": override, + }; +} + +class Package { + final int package; + + Package({ + required this.package, + }); + + factory Package.fromJson(Map json) => Package( + package: json["package"], + ); + + Map toJson() => { + "package": package, + }; +} + +class Params { + final int params; + + Params({ + required this.params, + }); + + factory Params.fromJson(Map json) => Params( + params: json["params"], + ); + + Map toJson() => { + "params": params, + }; +} + +class Pass { + final int pass; + + Pass({ + required this.pass, + }); + + factory Pass.fromJson(Map json) => Pass( + pass: json["pass"], + ); + + Map toJson() => { + "pass": pass, + }; +} + +class Port { + final int port; + + Port({ + required this.port, + }); + + factory Port.fromJson(Map json) => Port( + port: json["port"], + ); + + Map toJson() => { + "port": port, + }; +} + +class Postfix { + final int postfix; + + Postfix({ + required this.postfix, + }); + + factory Postfix.fromJson(Map json) => Postfix( + postfix: json["postfix"], + ); + + Map toJson() => { + "postfix": postfix, + }; +} + +class Precedence { + final int precedence; + + Precedence({ + required this.precedence, + }); + + factory Precedence.fromJson(Map json) => Precedence( + precedence: json["precedence"], + ); + + Map toJson() => { + "precedence": precedence, + }; +} + +class Prefix { + final int prefix; + + Prefix({ + required this.prefix, + }); + + factory Prefix.fromJson(Map json) => Prefix( + prefix: json["prefix"], + ); + + Map toJson() => { + "prefix": prefix, + }; +} + +class Print { + final int print; + + Print({ + required this.print, + }); + + factory Print.fromJson(Map json) => Print( + print: json["print"], + ); + + Map toJson() => { + "print": print, + }; +} + +class PrintMembers { + final int printMembers; + + PrintMembers({ + required this.printMembers, + }); + + factory PrintMembers.fromJson(Map json) => PrintMembers( + printMembers: json["printMembers"], + ); + + Map toJson() => { + "printMembers": printMembers, + }; +} + +class Printf { + final int printf; + + Printf({ + required this.printf, + }); + + factory Printf.fromJson(Map json) => Printf( + printf: json["printf"], + ); + + Map toJson() => { + "printf": printf, + }; +} + +class Private { + final int private; + + Private({ + required this.private, + }); + + factory Private.fromJson(Map json) => Private( + private: json["private"], + ); + + Map toJson() => { + "private": private, + }; +} + +class Protected { + final int protected; + + Protected({ + required this.protected, + }); + + factory Protected.fromJson(Map json) => Protected( + protected: json["protected"], + ); + + Map toJson() => { + "protected": protected, + }; +} + +class Protocol { + final int protocol; + + Protocol({ + required this.protocol, + }); + + factory Protocol.fromJson(Map json) => Protocol( + protocol: json["Protocol"], + ); + + Map toJson() => { + "Protocol": protocol, + }; +} + +class NullClass { + final int nullNull; + + NullClass({ + required this.nullNull, + }); + + factory NullClass.fromJson(Map json) => NullClass( + nullNull: json["null"], + ); + + Map toJson() => { + "null": nullNull, + }; +} + +class Obj4 { + final int dummy; + final Return obj4Return; + final SelfClass obj4Self; + final Set obj4Set; + final Static obj4Static; + final Super obj4Super; + final Switch obj4Switch; + final This obj4This; + final Throw obj4Throw; + final ToJson obj4ToJson; + final True obj4True; + final Try obj4Try; + final TypeClass obj4Type; + final Typedef obj4Typedef; + final Public public; + final TrueClass purpleTrue; + final Quicktype quicktype; + final Raise raise; + final Range range; + final Readonly readonly; + final Ref ref; + final Register register; + final ReinterpretCast reinterpretCast; + final Repeat repeat; + final Require require; + final Required required; + final Requires requires; + final Restrict restrict; + final Retain retain; + final Rethrows rethrows; + final Right right; + final Sbyte sbyte; + final Sealed sealed; + final Sel sel; + final Select select; + final Self self; + final Serialize serialize; + final Short short; + final Signed signed; + final Sizeof sizeof; + final Stackalloc stackalloc; + final StaticAssert staticAssert; + final StaticCast staticCast; + final Strictfp strictfp; + final StringClass string; + final Struct struct; + final Subscript subscript; + final Symbol symbol; + final Synchronized synchronized; + final System system; + final Template template; + final Then then; + final ThreadLocal threadLocal; + final Throws throws; + final TopLevelClass topLevel; + final Transient transient; + final Type type; + final Typealias typealias; + final Typeid typeid; + final Typename typename; + final Typeof typeof; + final Uint uint; + final Ulong ulong; + final Unchecked unchecked; + final Undefined undefined; + + Obj4({ + required this.dummy, + required this.obj4Return, + required this.obj4Self, + required this.obj4Set, + required this.obj4Static, + required this.obj4Super, + required this.obj4Switch, + required this.obj4This, + required this.obj4Throw, + required this.obj4ToJson, + required this.obj4True, + required this.obj4Try, + required this.obj4Type, + required this.obj4Typedef, + required this.public, + required this.purpleTrue, + required this.quicktype, + required this.raise, + required this.range, + required this.readonly, + required this.ref, + required this.register, + required this.reinterpretCast, + required this.repeat, + required this.require, + required this.required, + required this.requires, + required this.restrict, + required this.retain, + required this.rethrows, + required this.right, + required this.sbyte, + required this.sealed, + required this.sel, + required this.select, + required this.self, + required this.serialize, + required this.short, + required this.signed, + required this.sizeof, + required this.stackalloc, + required this.staticAssert, + required this.staticCast, + required this.strictfp, + required this.string, + required this.struct, + required this.subscript, + required this.symbol, + required this.synchronized, + required this.system, + required this.template, + required this.then, + required this.threadLocal, + required this.throws, + required this.topLevel, + required this.transient, + required this.type, + required this.typealias, + required this.typeid, + required this.typename, + required this.typeof, + required this.uint, + required this.ulong, + required this.unchecked, + required this.undefined, + }); + + factory Obj4.fromJson(Map json) => Obj4( + dummy: json["dummy"], + obj4Return: Return.fromJson(json["return"]), + obj4Self: SelfClass.fromJson(json["self"]), + obj4Set: Set.fromJson(json["set"]), + obj4Static: Static.fromJson(json["static"]), + obj4Super: Super.fromJson(json["super"]), + obj4Switch: Switch.fromJson(json["switch"]), + obj4This: This.fromJson(json["this"]), + obj4Throw: Throw.fromJson(json["throw"]), + obj4ToJson: ToJson.fromJson(json["to_json"]), + obj4True: True.fromJson(json["True"]), + obj4Try: Try.fromJson(json["try"]), + obj4Type: TypeClass.fromJson(json["type"]), + obj4Typedef: Typedef.fromJson(json["typedef"]), + public: Public.fromJson(json["public"]), + purpleTrue: TrueClass.fromJson(json["true"]), + quicktype: Quicktype.fromJson(json["quicktype"]), + raise: Raise.fromJson(json["raise"]), + range: Range.fromJson(json["range"]), + readonly: Readonly.fromJson(json["readonly"]), + ref: Ref.fromJson(json["ref"]), + register: Register.fromJson(json["register"]), + reinterpretCast: ReinterpretCast.fromJson(json["reinterpret_cast"]), + repeat: Repeat.fromJson(json["repeat"]), + require: Require.fromJson(json["require"]), + required: Required.fromJson(json["required"]), + requires: Requires.fromJson(json["requires"]), + restrict: Restrict.fromJson(json["restrict"]), + retain: Retain.fromJson(json["retain"]), + rethrows: Rethrows.fromJson(json["rethrows"]), + right: Right.fromJson(json["right"]), + sbyte: Sbyte.fromJson(json["sbyte"]), + sealed: Sealed.fromJson(json["sealed"]), + sel: Sel.fromJson(json["SEL"]), + select: Select.fromJson(json["select"]), + self: Self.fromJson(json["Self"]), + serialize: Serialize.fromJson(json["serialize"]), + short: Short.fromJson(json["short"]), + signed: Signed.fromJson(json["signed"]), + sizeof: Sizeof.fromJson(json["sizeof"]), + stackalloc: Stackalloc.fromJson(json["stackalloc"]), + staticAssert: StaticAssert.fromJson(json["static_assert"]), + staticCast: StaticCast.fromJson(json["static_cast"]), + strictfp: Strictfp.fromJson(json["strictfp"]), + string: StringClass.fromJson(json["string"]), + struct: Struct.fromJson(json["struct"]), + subscript: Subscript.fromJson(json["subscript"]), + symbol: Symbol.fromJson(json["symbol"]), + synchronized: Synchronized.fromJson(json["synchronized"]), + system: System.fromJson(json["system"]), + template: Template.fromJson(json["template"]), + then: Then.fromJson(json["then"]), + threadLocal: ThreadLocal.fromJson(json["thread_local"]), + throws: Throws.fromJson(json["throws"]), + topLevel: TopLevelClass.fromJson(json["top_level"]), + transient: Transient.fromJson(json["transient"]), + type: Type.fromJson(json["Type"]), + typealias: Typealias.fromJson(json["typealias"]), + typeid: Typeid.fromJson(json["typeid"]), + typename: Typename.fromJson(json["typename"]), + typeof: Typeof.fromJson(json["typeof"]), + uint: Uint.fromJson(json["uint"]), + ulong: Ulong.fromJson(json["ulong"]), + unchecked: Unchecked.fromJson(json["unchecked"]), + undefined: Undefined.fromJson(json["undefined"]), + ); + + Map toJson() => { + "dummy": dummy, + "return": obj4Return.toJson(), + "self": obj4Self.toJson(), + "set": obj4Set.toJson(), + "static": obj4Static.toJson(), + "super": obj4Super.toJson(), + "switch": obj4Switch.toJson(), + "this": obj4This.toJson(), + "throw": obj4Throw.toJson(), + "to_json": obj4ToJson.toJson(), + "True": obj4True.toJson(), + "try": obj4Try.toJson(), + "type": obj4Type.toJson(), + "typedef": obj4Typedef.toJson(), + "public": public.toJson(), + "true": purpleTrue.toJson(), + "quicktype": quicktype.toJson(), + "raise": raise.toJson(), + "range": range.toJson(), + "readonly": readonly.toJson(), + "ref": ref.toJson(), + "register": register.toJson(), + "reinterpret_cast": reinterpretCast.toJson(), + "repeat": repeat.toJson(), + "require": require.toJson(), + "required": required.toJson(), + "requires": requires.toJson(), + "restrict": restrict.toJson(), + "retain": retain.toJson(), + "rethrows": rethrows.toJson(), + "right": right.toJson(), + "sbyte": sbyte.toJson(), + "sealed": sealed.toJson(), + "SEL": sel.toJson(), + "select": select.toJson(), + "Self": self.toJson(), + "serialize": serialize.toJson(), + "short": short.toJson(), + "signed": signed.toJson(), + "sizeof": sizeof.toJson(), + "stackalloc": stackalloc.toJson(), + "static_assert": staticAssert.toJson(), + "static_cast": staticCast.toJson(), + "strictfp": strictfp.toJson(), + "string": string.toJson(), + "struct": struct.toJson(), + "subscript": subscript.toJson(), + "symbol": symbol.toJson(), + "synchronized": synchronized.toJson(), + "system": system.toJson(), + "template": template.toJson(), + "then": then.toJson(), + "thread_local": threadLocal.toJson(), + "throws": throws.toJson(), + "top_level": topLevel.toJson(), + "transient": transient.toJson(), + "Type": type.toJson(), + "typealias": typealias.toJson(), + "typeid": typeid.toJson(), + "typename": typename.toJson(), + "typeof": typeof.toJson(), + "uint": uint.toJson(), + "ulong": ulong.toJson(), + "unchecked": unchecked.toJson(), + "undefined": undefined.toJson(), + }; +} + +class Return { + final int returnReturn; + + Return({ + required this.returnReturn, + }); + + factory Return.fromJson(Map json) => Return( + returnReturn: json["return"], + ); + + Map toJson() => { + "return": returnReturn, + }; +} + +class SelfClass { + final int self; + + SelfClass({ + required this.self, + }); + + factory SelfClass.fromJson(Map json) => SelfClass( + self: json["self"], + ); + + Map toJson() => { + "self": self, + }; +} + +class Set { + final int setSet; + + Set({ + required this.setSet, + }); + + factory Set.fromJson(Map json) => Set( + setSet: json["set"], + ); + + Map toJson() => { + "set": setSet, + }; +} + +class Static { + final int staticStatic; + + Static({ + required this.staticStatic, + }); + + factory Static.fromJson(Map json) => Static( + staticStatic: json["static"], + ); + + Map toJson() => { + "static": staticStatic, + }; +} + +class Super { + final int superSuper; + + Super({ + required this.superSuper, + }); + + factory Super.fromJson(Map json) => Super( + superSuper: json["super"], + ); + + Map toJson() => { + "super": superSuper, + }; +} + +class Switch { + final int switchSwitch; + + Switch({ + required this.switchSwitch, + }); + + factory Switch.fromJson(Map json) => Switch( + switchSwitch: json["switch"], + ); + + Map toJson() => { + "switch": switchSwitch, + }; +} + +class This { + final int thisThis; + + This({ + required this.thisThis, + }); + + factory This.fromJson(Map json) => This( + thisThis: json["this"], + ); + + Map toJson() => { + "this": thisThis, + }; +} + +class Throw { + final int throwThrow; + + Throw({ + required this.throwThrow, + }); + + factory Throw.fromJson(Map json) => Throw( + throwThrow: json["throw"], + ); + + Map toJson() => { + "throw": throwThrow, + }; +} + +class ToJson { + final int toJsonToJson; + + ToJson({ + required this.toJsonToJson, + }); + + factory ToJson.fromJson(Map json) => ToJson( + toJsonToJson: json["to_json"], + ); + + Map toJson() => { + "to_json": toJsonToJson, + }; +} + +class True { + final int trueTrue; + + True({ + required this.trueTrue, + }); + + factory True.fromJson(Map json) => True( + trueTrue: json["True"], + ); + + Map toJson() => { + "True": trueTrue, + }; +} + +class Try { + final int tryTry; + + Try({ + required this.tryTry, + }); + + factory Try.fromJson(Map json) => Try( + tryTry: json["try"], + ); + + Map toJson() => { + "try": tryTry, + }; +} + +class TypeClass { + final int type; + + TypeClass({ + required this.type, + }); + + factory TypeClass.fromJson(Map json) => TypeClass( + type: json["type"], + ); + + Map toJson() => { + "type": type, + }; +} + +class Typedef { + final int typedefTypedef; + + Typedef({ + required this.typedefTypedef, + }); + + factory Typedef.fromJson(Map json) => Typedef( + typedefTypedef: json["typedef"], + ); + + Map toJson() => { + "typedef": typedefTypedef, + }; +} + +class Public { + final int public; + + Public({ + required this.public, + }); + + factory Public.fromJson(Map json) => Public( + public: json["public"], + ); + + Map toJson() => { + "public": public, + }; +} + +class TrueClass { + final int trueTrue; + + TrueClass({ + required this.trueTrue, + }); + + factory TrueClass.fromJson(Map json) => TrueClass( + trueTrue: json["true"], + ); + + Map toJson() => { + "true": trueTrue, + }; +} + +class Quicktype { + final int quicktype; + + Quicktype({ + required this.quicktype, + }); + + factory Quicktype.fromJson(Map json) => Quicktype( + quicktype: json["quicktype"], + ); + + Map toJson() => { + "quicktype": quicktype, + }; +} + +class Raise { + final int raise; + + Raise({ + required this.raise, + }); + + factory Raise.fromJson(Map json) => Raise( + raise: json["raise"], + ); + + Map toJson() => { + "raise": raise, + }; +} + +class Range { + final int range; + + Range({ + required this.range, + }); + + factory Range.fromJson(Map json) => Range( + range: json["range"], + ); + + Map toJson() => { + "range": range, + }; +} + +class Readonly { + final int readonly; + + Readonly({ + required this.readonly, + }); + + factory Readonly.fromJson(Map json) => Readonly( + readonly: json["readonly"], + ); + + Map toJson() => { + "readonly": readonly, + }; +} + +class Ref { + final int ref; + + Ref({ + required this.ref, + }); + + factory Ref.fromJson(Map json) => Ref( + ref: json["ref"], + ); + + Map toJson() => { + "ref": ref, + }; +} + +class Register { + final int register; + + Register({ + required this.register, + }); + + factory Register.fromJson(Map json) => Register( + register: json["register"], + ); + + Map toJson() => { + "register": register, + }; +} + +class ReinterpretCast { + final int reinterpretCast; + + ReinterpretCast({ + required this.reinterpretCast, + }); + + factory ReinterpretCast.fromJson(Map json) => ReinterpretCast( + reinterpretCast: json["reinterpret_cast"], + ); + + Map toJson() => { + "reinterpret_cast": reinterpretCast, + }; +} + +class Repeat { + final int repeat; + + Repeat({ + required this.repeat, + }); + + factory Repeat.fromJson(Map json) => Repeat( + repeat: json["repeat"], + ); + + Map toJson() => { + "repeat": repeat, + }; +} + +class Require { + final int require; + + Require({ + required this.require, + }); + + factory Require.fromJson(Map json) => Require( + require: json["require"], + ); + + Map toJson() => { + "require": require, + }; +} + +class Required { + final int required; + + Required({ + required this.required, + }); + + factory Required.fromJson(Map json) => Required( + required: json["required"], + ); + + Map toJson() => { + "required": required, + }; +} + +class Requires { + final int requires; + + Requires({ + required this.requires, + }); + + factory Requires.fromJson(Map json) => Requires( + requires: json["requires"], + ); + + Map toJson() => { + "requires": requires, + }; +} + +class Restrict { + final int restrict; + + Restrict({ + required this.restrict, + }); + + factory Restrict.fromJson(Map json) => Restrict( + restrict: json["restrict"], + ); + + Map toJson() => { + "restrict": restrict, + }; +} + +class Retain { + final int retain; + + Retain({ + required this.retain, + }); + + factory Retain.fromJson(Map json) => Retain( + retain: json["retain"], + ); + + Map toJson() => { + "retain": retain, + }; +} + +class Rethrows { + final int rethrows; + + Rethrows({ + required this.rethrows, + }); + + factory Rethrows.fromJson(Map json) => Rethrows( + rethrows: json["rethrows"], + ); + + Map toJson() => { + "rethrows": rethrows, + }; +} + +class Right { + final int right; + + Right({ + required this.right, + }); + + factory Right.fromJson(Map json) => Right( + right: json["right"], + ); + + Map toJson() => { + "right": right, + }; +} + +class Sbyte { + final int sbyte; + + Sbyte({ + required this.sbyte, + }); + + factory Sbyte.fromJson(Map json) => Sbyte( + sbyte: json["sbyte"], + ); + + Map toJson() => { + "sbyte": sbyte, + }; +} + +class Sealed { + final int sealed; + + Sealed({ + required this.sealed, + }); + + factory Sealed.fromJson(Map json) => Sealed( + sealed: json["sealed"], + ); + + Map toJson() => { + "sealed": sealed, + }; +} + +class Sel { + final int sel; + + Sel({ + required this.sel, + }); + + factory Sel.fromJson(Map json) => Sel( + sel: json["SEL"], + ); + + Map toJson() => { + "SEL": sel, + }; +} + +class Select { + final int select; + + Select({ + required this.select, + }); + + factory Select.fromJson(Map json) => Select( + select: json["select"], + ); + + Map toJson() => { + "select": select, + }; +} + +class Self { + final int self; + + Self({ + required this.self, + }); + + factory Self.fromJson(Map json) => Self( + self: json["Self"], + ); + + Map toJson() => { + "Self": self, + }; +} + +class Serialize { + final int serialize; + + Serialize({ + required this.serialize, + }); + + factory Serialize.fromJson(Map json) => Serialize( + serialize: json["serialize"], + ); + + Map toJson() => { + "serialize": serialize, + }; +} + +class Short { + final int short; + + Short({ + required this.short, + }); + + factory Short.fromJson(Map json) => Short( + short: json["short"], + ); + + Map toJson() => { + "short": short, + }; +} + +class Signed { + final int signed; + + Signed({ + required this.signed, + }); + + factory Signed.fromJson(Map json) => Signed( + signed: json["signed"], + ); + + Map toJson() => { + "signed": signed, + }; +} + +class Sizeof { + final int sizeof; + + Sizeof({ + required this.sizeof, + }); + + factory Sizeof.fromJson(Map json) => Sizeof( + sizeof: json["sizeof"], + ); + + Map toJson() => { + "sizeof": sizeof, + }; +} + +class Stackalloc { + final int stackalloc; + + Stackalloc({ + required this.stackalloc, + }); + + factory Stackalloc.fromJson(Map json) => Stackalloc( + stackalloc: json["stackalloc"], + ); + + Map toJson() => { + "stackalloc": stackalloc, + }; +} + +class StaticAssert { + final int staticAssert; + + StaticAssert({ + required this.staticAssert, + }); + + factory StaticAssert.fromJson(Map json) => StaticAssert( + staticAssert: json["static_assert"], + ); + + Map toJson() => { + "static_assert": staticAssert, + }; +} + +class StaticCast { + final int staticCast; + + StaticCast({ + required this.staticCast, + }); + + factory StaticCast.fromJson(Map json) => StaticCast( + staticCast: json["static_cast"], + ); + + Map toJson() => { + "static_cast": staticCast, + }; +} + +class Strictfp { + final int strictfp; + + Strictfp({ + required this.strictfp, + }); + + factory Strictfp.fromJson(Map json) => Strictfp( + strictfp: json["strictfp"], + ); + + Map toJson() => { + "strictfp": strictfp, + }; +} + +class StringClass { + final int string; + + StringClass({ + required this.string, + }); + + factory StringClass.fromJson(Map json) => StringClass( + string: json["string"], + ); + + Map toJson() => { + "string": string, + }; +} + +class Struct { + final int struct; + + Struct({ + required this.struct, + }); + + factory Struct.fromJson(Map json) => Struct( + struct: json["struct"], + ); + + Map toJson() => { + "struct": struct, + }; +} + +class Subscript { + final int subscript; + + Subscript({ + required this.subscript, + }); + + factory Subscript.fromJson(Map json) => Subscript( + subscript: json["subscript"], + ); + + Map toJson() => { + "subscript": subscript, + }; +} + +class Symbol { + final int symbol; + + Symbol({ + required this.symbol, + }); + + factory Symbol.fromJson(Map json) => Symbol( + symbol: json["symbol"], + ); + + Map toJson() => { + "symbol": symbol, + }; +} + +class Synchronized { + final int synchronized; + + Synchronized({ + required this.synchronized, + }); + + factory Synchronized.fromJson(Map json) => Synchronized( + synchronized: json["synchronized"], + ); + + Map toJson() => { + "synchronized": synchronized, + }; +} + +class System { + final int system; + + System({ + required this.system, + }); + + factory System.fromJson(Map json) => System( + system: json["system"], + ); + + Map toJson() => { + "system": system, + }; +} + +class Template { + final int template; + + Template({ + required this.template, + }); + + factory Template.fromJson(Map json) => Template( + template: json["template"], + ); + + Map toJson() => { + "template": template, + }; +} + +class Then { + final int then; + + Then({ + required this.then, + }); + + factory Then.fromJson(Map json) => Then( + then: json["then"], + ); + + Map toJson() => { + "then": then, + }; +} + +class ThreadLocal { + final int threadLocal; + + ThreadLocal({ + required this.threadLocal, + }); + + factory ThreadLocal.fromJson(Map json) => ThreadLocal( + threadLocal: json["thread_local"], + ); + + Map toJson() => { + "thread_local": threadLocal, + }; +} + +class Throws { + final int throws; + + Throws({ + required this.throws, + }); + + factory Throws.fromJson(Map json) => Throws( + throws: json["throws"], + ); + + Map toJson() => { + "throws": throws, + }; +} + +class TopLevelClass { + final int topLevel; + + TopLevelClass({ + required this.topLevel, + }); + + factory TopLevelClass.fromJson(Map json) => TopLevelClass( + topLevel: json["top_level"], + ); + + Map toJson() => { + "top_level": topLevel, + }; +} + +class Transient { + final int transient; + + Transient({ + required this.transient, + }); + + factory Transient.fromJson(Map json) => Transient( + transient: json["transient"], + ); + + Map toJson() => { + "transient": transient, + }; +} + +class Type { + final int type; + + Type({ + required this.type, + }); + + factory Type.fromJson(Map json) => Type( + type: json["Type"], + ); + + Map toJson() => { + "Type": type, + }; +} + +class Typealias { + final int typealias; + + Typealias({ + required this.typealias, + }); + + factory Typealias.fromJson(Map json) => Typealias( + typealias: json["typealias"], + ); + + Map toJson() => { + "typealias": typealias, + }; +} + +class Typeid { + final int typeid; + + Typeid({ + required this.typeid, + }); + + factory Typeid.fromJson(Map json) => Typeid( + typeid: json["typeid"], + ); + + Map toJson() => { + "typeid": typeid, + }; +} + +class Typename { + final int typename; + + Typename({ + required this.typename, + }); + + factory Typename.fromJson(Map json) => Typename( + typename: json["typename"], + ); + + Map toJson() => { + "typename": typename, + }; +} + +class Typeof { + final int typeof; + + Typeof({ + required this.typeof, + }); + + factory Typeof.fromJson(Map json) => Typeof( + typeof: json["typeof"], + ); + + Map toJson() => { + "typeof": typeof, + }; +} + +class Uint { + final int uint; + + Uint({ + required this.uint, + }); + + factory Uint.fromJson(Map json) => Uint( + uint: json["uint"], + ); + + Map toJson() => { + "uint": uint, + }; +} + +class Ulong { + final int ulong; + + Ulong({ + required this.ulong, + }); + + factory Ulong.fromJson(Map json) => Ulong( + ulong: json["ulong"], + ); + + Map toJson() => { + "ulong": ulong, + }; +} + +class Unchecked { + final int unchecked; + + Unchecked({ + required this.unchecked, + }); + + factory Unchecked.fromJson(Map json) => Unchecked( + unchecked: json["unchecked"], + ); + + Map toJson() => { + "unchecked": unchecked, + }; +} + +class Undefined { + final int undefined; + + Undefined({ + required this.undefined, + }); + + factory Undefined.fromJson(Map json) => Undefined( + undefined: json["undefined"], + ); + + Map toJson() => { + "undefined": undefined, + }; +} + +class Obj5 { + final int dummy; + final Var obj5Var; + final Void obj5Void; + final While obj5While; + final With obj5With; + final Yield obj5Yield; + final Union union; + final Unowned unowned; + final Unsafe unsafe; + final Unsigned unsigned; + final Ushort ushort; + final Using using; + final Virtual virtual; + final Volatile volatile; + final WcharT wcharT; + final Weak weak; + final Where where; + final WillSet willSet; + final Xor xor; + final XorEq xorEq; + final Yes yes; + + Obj5({ + required this.dummy, + required this.obj5Var, + required this.obj5Void, + required this.obj5While, + required this.obj5With, + required this.obj5Yield, + required this.union, + required this.unowned, + required this.unsafe, + required this.unsigned, + required this.ushort, + required this.using, + required this.virtual, + required this.volatile, + required this.wcharT, + required this.weak, + required this.where, + required this.willSet, + required this.xor, + required this.xorEq, + required this.yes, + }); + + factory Obj5.fromJson(Map json) => Obj5( + dummy: json["dummy"], + obj5Var: Var.fromJson(json["var"]), + obj5Void: Void.fromJson(json["void"]), + obj5While: While.fromJson(json["while"]), + obj5With: With.fromJson(json["with"]), + obj5Yield: Yield.fromJson(json["yield"]), + union: Union.fromJson(json["union"]), + unowned: Unowned.fromJson(json["unowned"]), + unsafe: Unsafe.fromJson(json["unsafe"]), + unsigned: Unsigned.fromJson(json["unsigned"]), + ushort: Ushort.fromJson(json["ushort"]), + using: Using.fromJson(json["using"]), + virtual: Virtual.fromJson(json["virtual"]), + volatile: Volatile.fromJson(json["volatile"]), + wcharT: WcharT.fromJson(json["wchar_t"]), + weak: Weak.fromJson(json["weak"]), + where: Where.fromJson(json["where"]), + willSet: WillSet.fromJson(json["willSet"]), + xor: Xor.fromJson(json["xor"]), + xorEq: XorEq.fromJson(json["xor_eq"]), + yes: Yes.fromJson(json["YES"]), + ); + + Map toJson() => { + "dummy": dummy, + "var": obj5Var.toJson(), + "void": obj5Void.toJson(), + "while": obj5While.toJson(), + "with": obj5With.toJson(), + "yield": obj5Yield.toJson(), + "union": union.toJson(), + "unowned": unowned.toJson(), + "unsafe": unsafe.toJson(), + "unsigned": unsigned.toJson(), + "ushort": ushort.toJson(), + "using": using.toJson(), + "virtual": virtual.toJson(), + "volatile": volatile.toJson(), + "wchar_t": wcharT.toJson(), + "weak": weak.toJson(), + "where": where.toJson(), + "willSet": willSet.toJson(), + "xor": xor.toJson(), + "xor_eq": xorEq.toJson(), + "YES": yes.toJson(), + }; +} + +class Var { + final int varVar; + + Var({ + required this.varVar, + }); + + factory Var.fromJson(Map json) => Var( + varVar: json["var"], + ); + + Map toJson() => { + "var": varVar, + }; +} + +class Void { + final int voidVoid; + + Void({ + required this.voidVoid, + }); + + factory Void.fromJson(Map json) => Void( + voidVoid: json["void"], + ); + + Map toJson() => { + "void": voidVoid, + }; +} + +class While { + final int whileWhile; + + While({ + required this.whileWhile, + }); + + factory While.fromJson(Map json) => While( + whileWhile: json["while"], + ); + + Map toJson() => { + "while": whileWhile, + }; +} + +class With { + final int withWith; + + With({ + required this.withWith, + }); + + factory With.fromJson(Map json) => With( + withWith: json["with"], + ); + + Map toJson() => { + "with": withWith, + }; +} + +class Yield { + final int yieldYield; + + Yield({ + required this.yieldYield, + }); + + factory Yield.fromJson(Map json) => Yield( + yieldYield: json["yield"], + ); + + Map toJson() => { + "yield": yieldYield, + }; +} + +class Union { + final int union; + + Union({ + required this.union, + }); + + factory Union.fromJson(Map json) => Union( + union: json["union"], + ); + + Map toJson() => { + "union": union, + }; +} + +class Unowned { + final int unowned; + + Unowned({ + required this.unowned, + }); + + factory Unowned.fromJson(Map json) => Unowned( + unowned: json["unowned"], + ); + + Map toJson() => { + "unowned": unowned, + }; +} + +class Unsafe { + final int unsafe; + + Unsafe({ + required this.unsafe, + }); + + factory Unsafe.fromJson(Map json) => Unsafe( + unsafe: json["unsafe"], + ); + + Map toJson() => { + "unsafe": unsafe, + }; +} + +class Unsigned { + final int unsigned; + + Unsigned({ + required this.unsigned, + }); + + factory Unsigned.fromJson(Map json) => Unsigned( + unsigned: json["unsigned"], + ); + + Map toJson() => { + "unsigned": unsigned, + }; +} + +class Ushort { + final int ushort; + + Ushort({ + required this.ushort, + }); + + factory Ushort.fromJson(Map json) => Ushort( + ushort: json["ushort"], + ); + + Map toJson() => { + "ushort": ushort, + }; +} + +class Using { + final int using; + + Using({ + required this.using, + }); + + factory Using.fromJson(Map json) => Using( + using: json["using"], + ); + + Map toJson() => { + "using": using, + }; +} + +class Virtual { + final int virtual; + + Virtual({ + required this.virtual, + }); + + factory Virtual.fromJson(Map json) => Virtual( + virtual: json["virtual"], + ); + + Map toJson() => { + "virtual": virtual, + }; +} + +class Volatile { + final int volatile; + + Volatile({ + required this.volatile, + }); + + factory Volatile.fromJson(Map json) => Volatile( + volatile: json["volatile"], + ); + + Map toJson() => { + "volatile": volatile, + }; +} + +class WcharT { + final int wcharT; + + WcharT({ + required this.wcharT, + }); + + factory WcharT.fromJson(Map json) => WcharT( + wcharT: json["wchar_t"], + ); + + Map toJson() => { + "wchar_t": wcharT, + }; +} + +class Weak { + final int weak; + + Weak({ + required this.weak, + }); + + factory Weak.fromJson(Map json) => Weak( + weak: json["weak"], + ); + + Map toJson() => { + "weak": weak, + }; +} + +class Where { + final int where; + + Where({ + required this.where, + }); + + factory Where.fromJson(Map json) => Where( + where: json["where"], + ); + + Map toJson() => { + "where": where, + }; +} + +class WillSet { + final int willSet; + + WillSet({ + required this.willSet, + }); + + factory WillSet.fromJson(Map json) => WillSet( + willSet: json["willSet"], + ); + + Map toJson() => { + "willSet": willSet, + }; +} + +class Xor { + final int xor; + + Xor({ + required this.xor, + }); + + factory Xor.fromJson(Map json) => Xor( + xor: json["xor"], + ); + + Map toJson() => { + "xor": xor, + }; +} + +class XorEq { + final int xorEq; + + XorEq({ + required this.xorEq, + }); + + factory XorEq.fromJson(Map json) => XorEq( + xorEq: json["xor_eq"], + ); + + Map toJson() => { + "xor_eq": xorEq, + }; +} + +class Yes { + final int yes; + + Yes({ + required this.yes, + }); + + factory Yes.fromJson(Map json) => Yes( + yes: json["YES"], + ); + + Map toJson() => { + "YES": yes, + }; +} diff --git a/head/schema-dart/test/inputs/schema/keyword-unions.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/keyword-unions.schema/default/TopLevel.dart new file mode 100644 index 0000000..5be94f5 --- /dev/null +++ b/head/schema-dart/test/inputs/schema/keyword-unions.schema/default/TopLevel.dart @@ -0,0 +1,3889 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + final dynamic empty; + final dynamic purpleBool; + final dynamic complex; + final dynamic imaginery; + final dynamic topLevelAbstract; + final dynamic alignas; + final dynamic alignof; + final dynamic and; + final dynamic andEq; + final dynamic topLevelAny; + final dynamic any; + final dynamic array; + final dynamic topLevelAs; + final dynamic asm; + final dynamic topLevelAssert; + final dynamic associatedtype; + final dynamic associativity; + final dynamic topLevelAsync; + final dynamic atomic; + final dynamic atomicCancel; + final dynamic atomicCommit; + final dynamic atomicNoexcept; + final dynamic auto; + final dynamic topLevelAwait; + final dynamic base; + final dynamic bitand; + final dynamic bitor; + final dynamic topLevelBool; + final dynamic fluffyBool; + final dynamic boolean; + final dynamic topLevelBreak; + final dynamic bycopy; + final dynamic byref; + final dynamic byte; + final dynamic topLevelCase; + final dynamic topLevelCatch; + final dynamic chan; + final dynamic char; + final dynamic char16T; + final dynamic char32T; + final dynamic checked; + final dynamic purpleClass; + final dynamic topLevelClass; + final dynamic coAwait; + final dynamic coReturn; + final dynamic coYield; + final dynamic compl; + final dynamic concept; + final dynamic console; + final dynamic topLevelConst; + final dynamic constCast; + final dynamic constexpr; + final dynamic constructor; + final dynamic topLevelContinue; + final dynamic convenience; + final dynamic convert; + final dynamic converter; + final dynamic date; + final dynamic dateParseHandling; + final dynamic debugger; + final dynamic decimal; + final dynamic declare; + final dynamic decltype; + final dynamic decodeString; + final dynamic def; + final dynamic topLevelDefault; + final dynamic defer; + final dynamic deinit; + final dynamic del; + final dynamic delegate; + final dynamic delete; + final dynamic dict; + final dynamic dictionary; + final dynamic didSet; + final dynamic topLevelDo; + final dynamic topLevelDouble; + final double? dummy; + final dynamic topLevelDynamic; + final dynamic dynamicCast; + final dynamic elif; + final dynamic topLevelElse; + final dynamic encodeQuickType; + final dynamic topLevelEnum; + final dynamic event; + final dynamic except; + final dynamic exception; + final dynamic explicit; + final dynamic topLevelExport; + final dynamic exposing; + final dynamic topLevelExtends; + final dynamic extension; + final dynamic extern; + final dynamic fallthrough; + final dynamic purpleFalse; + final dynamic topLevelFalse; + final dynamic fileprivate; + final dynamic topLevelFinal; + final dynamic topLevelFinally; + final dynamic fixed; + final dynamic float; + final dynamic topLevelFor; + final dynamic foreach; + final dynamic friend; + final dynamic from; + final dynamic topLevelFromJson; + final dynamic func; + final dynamic function; + final dynamic topLevelGet; + final dynamic global; + final dynamic go; + final dynamic goto; + final dynamic guard; + final dynamic hasOwnProperty; + final dynamic id; + final dynamic topLevelIf; + final dynamic imp; + final dynamic topLevelImplements; + final dynamic implicit; + final dynamic topLevelImport; + final dynamic topLevelIn; + final dynamic indirect; + final dynamic infix; + final dynamic init; + final dynamic inline; + final dynamic inout; + final dynamic instanceof; + final dynamic topLevelInt; + final dynamic topLevelInterface; + final dynamic internal; + final dynamic topLevelIs; + final dynamic iterable; + final dynamic jdec; + final dynamic jenc; + final dynamic jpipe; + final dynamic json; + final dynamic jsonConverter; + final dynamic jsonSerializer; + final dynamic jsonToken; + final dynamic jsonWriter; + final dynamic lambda; + final dynamic lazy; + final dynamic left; + final dynamic let; + final dynamic list; + final dynamic lock; + final dynamic long; + final dynamic map; + final dynamic metadataPropertyHandling; + final dynamic module; + final dynamic mutable; + final dynamic mutating; + final dynamic namespace; + final dynamic native; + final dynamic topLevelNew; + final dynamic newtonsoft; + final dynamic nil; + final dynamic no; + final dynamic noexcept; + final dynamic nonatomic; + final dynamic topLevelNone; + final dynamic none; + final dynamic nonlocal; + final dynamic nonmutating; + final dynamic not; + final dynamic notEq; + final dynamic nsString; + final dynamic topLevelNull; + final dynamic purpleNull; + final dynamic nullptr; + final dynamic number; + final dynamic object; + final dynamic of; + final dynamic oneway; + final dynamic open; + final dynamic topLevelOperator; + final dynamic optional; + final dynamic or; + final dynamic orEq; + final dynamic out; + final dynamic override; + final dynamic package; + final dynamic params; + final dynamic pass; + final dynamic port; + final dynamic postfix; + final dynamic precedence; + final dynamic prefix; + final dynamic print; + final dynamic printf; + final dynamic private; + final dynamic protected; + final dynamic protocol; + final dynamic topLevelProtocol; + final dynamic public; + final dynamic quicktype; + final dynamic raise; + final dynamic range; + final dynamic readonly; + final dynamic ref; + final dynamic register; + final dynamic reinterpretCast; + final dynamic repeat; + final dynamic require; + final dynamic required; + final dynamic requires; + final dynamic restrict; + final dynamic retain; + final dynamic rethrows; + final dynamic topLevelReturn; + final dynamic right; + final dynamic sbyte; + final dynamic sealed; + final dynamic sel; + final dynamic select; + final dynamic self; + final dynamic topLevelSelf; + final dynamic serialize; + final dynamic topLevelSet; + final dynamic short; + final dynamic signed; + final dynamic sizeof; + final dynamic stackalloc; + final dynamic topLevelStatic; + final dynamic staticAssert; + final dynamic staticCast; + final dynamic strictfp; + final dynamic string; + final dynamic struct; + final dynamic subscript; + final dynamic topLevelSuper; + final dynamic topLevelSwitch; + final dynamic symbol; + final dynamic synchronized; + final dynamic system; + final dynamic template; + final dynamic then; + final dynamic topLevelThis; + final dynamic threadLocal; + final dynamic topLevelThrow; + final dynamic throws; + final dynamic topLevelToJson; + final dynamic topLevel; + final dynamic transient; + final dynamic topLevelTrue; + final dynamic purpleTrue; + final dynamic topLevelTry; + final dynamic type; + final dynamic topLevelType; + final dynamic typealias; + final dynamic topLevelTypedef; + final dynamic typeid; + final dynamic typename; + final dynamic typeof; + final dynamic uint; + final dynamic ulong; + final dynamic unchecked; + final dynamic undefined; + final dynamic union; + final dynamic unowned; + final dynamic unsafe; + final dynamic unsigned; + final dynamic ushort; + final dynamic using; + final dynamic topLevelVar; + final dynamic virtual; + final dynamic topLevelVoid; + final dynamic volatile; + final dynamic wcharT; + final dynamic weak; + final dynamic where; + final dynamic topLevelWhile; + final dynamic willSet; + final dynamic topLevelWith; + final dynamic xor; + final dynamic xorEq; + final dynamic yes; + final dynamic topLevelYield; + + TopLevel({ + this.empty, + this.purpleBool, + this.complex, + this.imaginery, + this.topLevelAbstract, + this.alignas, + this.alignof, + this.and, + this.andEq, + this.topLevelAny, + this.any, + this.array, + this.topLevelAs, + this.asm, + this.topLevelAssert, + this.associatedtype, + this.associativity, + this.topLevelAsync, + this.atomic, + this.atomicCancel, + this.atomicCommit, + this.atomicNoexcept, + this.auto, + this.topLevelAwait, + this.base, + this.bitand, + this.bitor, + this.topLevelBool, + this.fluffyBool, + this.boolean, + this.topLevelBreak, + this.bycopy, + this.byref, + this.byte, + this.topLevelCase, + this.topLevelCatch, + this.chan, + this.char, + this.char16T, + this.char32T, + this.checked, + this.purpleClass, + this.topLevelClass, + this.coAwait, + this.coReturn, + this.coYield, + this.compl, + this.concept, + this.console, + this.topLevelConst, + this.constCast, + this.constexpr, + this.constructor, + this.topLevelContinue, + this.convenience, + this.convert, + this.converter, + this.date, + this.dateParseHandling, + this.debugger, + this.decimal, + this.declare, + this.decltype, + this.decodeString, + this.def, + this.topLevelDefault, + this.defer, + this.deinit, + this.del, + this.delegate, + this.delete, + this.dict, + this.dictionary, + this.didSet, + this.topLevelDo, + this.topLevelDouble, + this.dummy, + this.topLevelDynamic, + this.dynamicCast, + this.elif, + this.topLevelElse, + this.encodeQuickType, + this.topLevelEnum, + this.event, + this.except, + this.exception, + this.explicit, + this.topLevelExport, + this.exposing, + this.topLevelExtends, + this.extension, + this.extern, + this.fallthrough, + this.purpleFalse, + this.topLevelFalse, + this.fileprivate, + this.topLevelFinal, + this.topLevelFinally, + this.fixed, + this.float, + this.topLevelFor, + this.foreach, + this.friend, + this.from, + this.topLevelFromJson, + this.func, + this.function, + this.topLevelGet, + this.global, + this.go, + this.goto, + this.guard, + this.hasOwnProperty, + this.id, + this.topLevelIf, + this.imp, + this.topLevelImplements, + this.implicit, + this.topLevelImport, + this.topLevelIn, + this.indirect, + this.infix, + this.init, + this.inline, + this.inout, + this.instanceof, + this.topLevelInt, + this.topLevelInterface, + this.internal, + this.topLevelIs, + this.iterable, + this.jdec, + this.jenc, + this.jpipe, + this.json, + this.jsonConverter, + this.jsonSerializer, + this.jsonToken, + this.jsonWriter, + this.lambda, + this.lazy, + this.left, + this.let, + this.list, + this.lock, + this.long, + this.map, + this.metadataPropertyHandling, + this.module, + this.mutable, + this.mutating, + this.namespace, + this.native, + this.topLevelNew, + this.newtonsoft, + this.nil, + this.no, + this.noexcept, + this.nonatomic, + this.topLevelNone, + this.none, + this.nonlocal, + this.nonmutating, + this.not, + this.notEq, + this.nsString, + this.topLevelNull, + this.purpleNull, + this.nullptr, + this.number, + this.object, + this.of, + this.oneway, + this.open, + this.topLevelOperator, + this.optional, + this.or, + this.orEq, + this.out, + this.override, + this.package, + this.params, + this.pass, + this.port, + this.postfix, + this.precedence, + this.prefix, + this.print, + this.printf, + this.private, + this.protected, + this.protocol, + this.topLevelProtocol, + this.public, + this.quicktype, + this.raise, + this.range, + this.readonly, + this.ref, + this.register, + this.reinterpretCast, + this.repeat, + this.require, + this.required, + this.requires, + this.restrict, + this.retain, + this.rethrows, + this.topLevelReturn, + this.right, + this.sbyte, + this.sealed, + this.sel, + this.select, + this.self, + this.topLevelSelf, + this.serialize, + this.topLevelSet, + this.short, + this.signed, + this.sizeof, + this.stackalloc, + this.topLevelStatic, + this.staticAssert, + this.staticCast, + this.strictfp, + this.string, + this.struct, + this.subscript, + this.topLevelSuper, + this.topLevelSwitch, + this.symbol, + this.synchronized, + this.system, + this.template, + this.then, + this.topLevelThis, + this.threadLocal, + this.topLevelThrow, + this.throws, + this.topLevelToJson, + this.topLevel, + this.transient, + this.topLevelTrue, + this.purpleTrue, + this.topLevelTry, + this.type, + this.topLevelType, + this.typealias, + this.topLevelTypedef, + this.typeid, + this.typename, + this.typeof, + this.uint, + this.ulong, + this.unchecked, + this.undefined, + this.union, + this.unowned, + this.unsafe, + this.unsigned, + this.ushort, + this.using, + this.topLevelVar, + this.virtual, + this.topLevelVoid, + this.volatile, + this.wcharT, + this.weak, + this.where, + this.topLevelWhile, + this.willSet, + this.topLevelWith, + this.xor, + this.xorEq, + this.yes, + this.topLevelYield, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + empty: json["_"], + purpleBool: json["_Bool"], + complex: json["_Complex"], + imaginery: json["_Imaginery"], + topLevelAbstract: json["abstract"], + alignas: json["alignas"], + alignof: json["alignof"], + and: json["and"], + andEq: json["and_eq"], + topLevelAny: json["any"], + any: json["Any"], + array: json["array"], + topLevelAs: json["as"], + asm: json["asm"], + topLevelAssert: json["assert"], + associatedtype: json["associatedtype"], + associativity: json["associativity"], + topLevelAsync: json["async"], + atomic: json["atomic"], + atomicCancel: json["atomic_cancel"], + atomicCommit: json["atomic_commit"], + atomicNoexcept: json["atomic_noexcept"], + auto: json["auto"], + topLevelAwait: json["await"], + base: json["base"], + bitand: json["bitand"], + bitor: json["bitor"], + topLevelBool: json["BOOL"], + fluffyBool: json["bool"], + boolean: json["boolean"], + topLevelBreak: json["break"], + bycopy: json["bycopy"], + byref: json["byref"], + byte: json["byte"], + topLevelCase: json["case"], + topLevelCatch: json["catch"], + chan: json["chan"], + char: json["char"], + char16T: json["char16_t"], + char32T: json["char32_t"], + checked: json["checked"], + purpleClass: json["class"], + topLevelClass: json["Class"], + coAwait: json["co_await"], + coReturn: json["co_return"], + coYield: json["co_yield"], + compl: json["compl"], + concept: json["concept"], + console: json["console"], + topLevelConst: json["const"], + constCast: json["const_cast"], + constexpr: json["constexpr"], + constructor: json["constructor"], + topLevelContinue: json["continue"], + convenience: json["convenience"], + convert: json["convert"], + converter: json["converter"], + date: json["date"], + dateParseHandling: json["date_parse_handling"], + debugger: json["debugger"], + decimal: json["decimal"], + declare: json["declare"], + decltype: json["decltype"], + decodeString: json["decode_string"], + def: json["def"], + topLevelDefault: json["default"], + defer: json["defer"], + deinit: json["deinit"], + del: json["del"], + delegate: json["delegate"], + delete: json["delete"], + dict: json["dict"], + dictionary: json["dictionary"], + didSet: json["didSet"], + topLevelDo: json["do"], + topLevelDouble: json["double"], + dummy: json["dummy"]?.toDouble(), + topLevelDynamic: json["dynamic"], + dynamicCast: json["dynamic_cast"], + elif: json["elif"], + topLevelElse: json["else"], + encodeQuickType: json["encode_quick_type"], + topLevelEnum: json["enum"], + event: json["event"], + except: json["except"], + exception: json["exception"], + explicit: json["explicit"], + topLevelExport: json["export"], + exposing: json["exposing"], + topLevelExtends: json["extends"], + extension: json["extension"], + extern: json["extern"], + fallthrough: json["fallthrough"], + purpleFalse: json["false"], + topLevelFalse: json["False"], + fileprivate: json["fileprivate"], + topLevelFinal: json["final"], + topLevelFinally: json["finally"], + fixed: json["fixed"], + float: json["float"], + topLevelFor: json["for"], + foreach: json["foreach"], + friend: json["friend"], + from: json["from"], + topLevelFromJson: json["from_json"], + func: json["func"], + function: json["function"], + topLevelGet: json["get"], + global: json["global"], + go: json["go"], + goto: json["goto"], + guard: json["guard"], + hasOwnProperty: json["hasOwnProperty"], + id: json["id"], + topLevelIf: json["if"], + imp: json["IMP"], + topLevelImplements: json["implements"], + implicit: json["implicit"], + topLevelImport: json["import"], + topLevelIn: json["in"], + indirect: json["indirect"], + infix: json["infix"], + init: json["init"], + inline: json["inline"], + inout: json["inout"], + instanceof: json["instanceof"], + topLevelInt: json["int"], + topLevelInterface: json["interface"], + internal: json["internal"], + topLevelIs: json["is"], + iterable: json["iterable"], + jdec: json["jdec"], + jenc: json["jenc"], + jpipe: json["jpipe"], + json: json["json"], + jsonConverter: json["json_converter"], + jsonSerializer: json["json_serializer"], + jsonToken: json["json_token"], + jsonWriter: json["json_writer"], + lambda: json["lambda"], + lazy: json["lazy"], + left: json["left"], + let: json["let"], + list: json["list"], + lock: json["lock"], + long: json["long"], + map: json["map"], + metadataPropertyHandling: json["metadata_property_handling"], + module: json["module"], + mutable: json["mutable"], + mutating: json["mutating"], + namespace: json["namespace"], + native: json["native"], + topLevelNew: json["new"], + newtonsoft: json["newtonsoft"], + nil: json["nil"], + no: json["NO"], + noexcept: json["noexcept"], + nonatomic: json["nonatomic"], + topLevelNone: json["none"], + none: json["None"], + nonlocal: json["nonlocal"], + nonmutating: json["nonmutating"], + not: json["not"], + notEq: json["not_eq"], + nsString: json["NSString"], + topLevelNull: json["NULL"], + purpleNull: json["null"], + nullptr: json["nullptr"], + number: json["number"], + object: json["object"], + of: json["of"], + oneway: json["oneway"], + open: json["open"], + topLevelOperator: json["operator"], + optional: json["optional"], + or: json["or"], + orEq: json["or_eq"], + out: json["out"], + override: json["override"], + package: json["package"], + params: json["params"], + pass: json["pass"], + port: json["port"], + postfix: json["postfix"], + precedence: json["precedence"], + prefix: json["prefix"], + print: json["print"], + printf: json["printf"], + private: json["private"], + protected: json["protected"], + protocol: json["Protocol"], + topLevelProtocol: json["protocol"], + public: json["public"], + quicktype: json["quicktype"], + raise: json["raise"], + range: json["range"], + readonly: json["readonly"], + ref: json["ref"], + register: json["register"], + reinterpretCast: json["reinterpret_cast"], + repeat: json["repeat"], + require: json["require"], + required: json["required"], + requires: json["requires"], + restrict: json["restrict"], + retain: json["retain"], + rethrows: json["rethrows"], + topLevelReturn: json["return"], + right: json["right"], + sbyte: json["sbyte"], + sealed: json["sealed"], + sel: json["SEL"], + select: json["select"], + self: json["Self"], + topLevelSelf: json["self"], + serialize: json["serialize"], + topLevelSet: json["set"], + short: json["short"], + signed: json["signed"], + sizeof: json["sizeof"], + stackalloc: json["stackalloc"], + topLevelStatic: json["static"], + staticAssert: json["static_assert"], + staticCast: json["static_cast"], + strictfp: json["strictfp"], + string: json["string"], + struct: json["struct"], + subscript: json["subscript"], + topLevelSuper: json["super"], + topLevelSwitch: json["switch"], + symbol: json["symbol"], + synchronized: json["synchronized"], + system: json["system"], + template: json["template"], + then: json["then"], + topLevelThis: json["this"], + threadLocal: json["thread_local"], + topLevelThrow: json["throw"], + throws: json["throws"], + topLevelToJson: json["to_json"], + topLevel: json["top_level"], + transient: json["transient"], + topLevelTrue: json["True"], + purpleTrue: json["true"], + topLevelTry: json["try"], + type: json["Type"], + topLevelType: json["type"], + typealias: json["typealias"], + topLevelTypedef: json["typedef"], + typeid: json["typeid"], + typename: json["typename"], + typeof: json["typeof"], + uint: json["uint"], + ulong: json["ulong"], + unchecked: json["unchecked"], + undefined: json["undefined"], + union: json["union"], + unowned: json["unowned"], + unsafe: json["unsafe"], + unsigned: json["unsigned"], + ushort: json["ushort"], + using: json["using"], + topLevelVar: json["var"], + virtual: json["virtual"], + topLevelVoid: json["void"], + volatile: json["volatile"], + wcharT: json["wchar_t"], + weak: json["weak"], + where: json["where"], + topLevelWhile: json["while"], + willSet: json["willSet"], + topLevelWith: json["with"], + xor: json["xor"], + xorEq: json["xor_eq"], + yes: json["YES"], + topLevelYield: json["yield"], + ); + + Map toJson() => { + "_": empty, + "_Bool": purpleBool, + "_Complex": complex, + "_Imaginery": imaginery, + "abstract": topLevelAbstract, + "alignas": alignas, + "alignof": alignof, + "and": and, + "and_eq": andEq, + "any": topLevelAny, + "Any": any, + "array": array, + "as": topLevelAs, + "asm": asm, + "assert": topLevelAssert, + "associatedtype": associatedtype, + "associativity": associativity, + "async": topLevelAsync, + "atomic": atomic, + "atomic_cancel": atomicCancel, + "atomic_commit": atomicCommit, + "atomic_noexcept": atomicNoexcept, + "auto": auto, + "await": topLevelAwait, + "base": base, + "bitand": bitand, + "bitor": bitor, + "BOOL": topLevelBool, + "bool": fluffyBool, + "boolean": boolean, + "break": topLevelBreak, + "bycopy": bycopy, + "byref": byref, + "byte": byte, + "case": topLevelCase, + "catch": topLevelCatch, + "chan": chan, + "char": char, + "char16_t": char16T, + "char32_t": char32T, + "checked": checked, + "class": purpleClass, + "Class": topLevelClass, + "co_await": coAwait, + "co_return": coReturn, + "co_yield": coYield, + "compl": compl, + "concept": concept, + "console": console, + "const": topLevelConst, + "const_cast": constCast, + "constexpr": constexpr, + "constructor": constructor, + "continue": topLevelContinue, + "convenience": convenience, + "convert": convert, + "converter": converter, + "date": date, + "date_parse_handling": dateParseHandling, + "debugger": debugger, + "decimal": decimal, + "declare": declare, + "decltype": decltype, + "decode_string": decodeString, + "def": def, + "default": topLevelDefault, + "defer": defer, + "deinit": deinit, + "del": del, + "delegate": delegate, + "delete": delete, + "dict": dict, + "dictionary": dictionary, + "didSet": didSet, + "do": topLevelDo, + "double": topLevelDouble, + "dummy": dummy, + "dynamic": topLevelDynamic, + "dynamic_cast": dynamicCast, + "elif": elif, + "else": topLevelElse, + "encode_quick_type": encodeQuickType, + "enum": topLevelEnum, + "event": event, + "except": except, + "exception": exception, + "explicit": explicit, + "export": topLevelExport, + "exposing": exposing, + "extends": topLevelExtends, + "extension": extension, + "extern": extern, + "fallthrough": fallthrough, + "false": purpleFalse, + "False": topLevelFalse, + "fileprivate": fileprivate, + "final": topLevelFinal, + "finally": topLevelFinally, + "fixed": fixed, + "float": float, + "for": topLevelFor, + "foreach": foreach, + "friend": friend, + "from": from, + "from_json": topLevelFromJson, + "func": func, + "function": function, + "get": topLevelGet, + "global": global, + "go": go, + "goto": goto, + "guard": guard, + "hasOwnProperty": hasOwnProperty, + "id": id, + "if": topLevelIf, + "IMP": imp, + "implements": topLevelImplements, + "implicit": implicit, + "import": topLevelImport, + "in": topLevelIn, + "indirect": indirect, + "infix": infix, + "init": init, + "inline": inline, + "inout": inout, + "instanceof": instanceof, + "int": topLevelInt, + "interface": topLevelInterface, + "internal": internal, + "is": topLevelIs, + "iterable": iterable, + "jdec": jdec, + "jenc": jenc, + "jpipe": jpipe, + "json": json, + "json_converter": jsonConverter, + "json_serializer": jsonSerializer, + "json_token": jsonToken, + "json_writer": jsonWriter, + "lambda": lambda, + "lazy": lazy, + "left": left, + "let": let, + "list": list, + "lock": lock, + "long": long, + "map": map, + "metadata_property_handling": metadataPropertyHandling, + "module": module, + "mutable": mutable, + "mutating": mutating, + "namespace": namespace, + "native": native, + "new": topLevelNew, + "newtonsoft": newtonsoft, + "nil": nil, + "NO": no, + "noexcept": noexcept, + "nonatomic": nonatomic, + "none": topLevelNone, + "None": none, + "nonlocal": nonlocal, + "nonmutating": nonmutating, + "not": not, + "not_eq": notEq, + "NSString": nsString, + "NULL": topLevelNull, + "null": purpleNull, + "nullptr": nullptr, + "number": number, + "object": object, + "of": of, + "oneway": oneway, + "open": open, + "operator": topLevelOperator, + "optional": optional, + "or": or, + "or_eq": orEq, + "out": out, + "override": override, + "package": package, + "params": params, + "pass": pass, + "port": port, + "postfix": postfix, + "precedence": precedence, + "prefix": prefix, + "print": print, + "printf": printf, + "private": private, + "protected": protected, + "Protocol": protocol, + "protocol": topLevelProtocol, + "public": public, + "quicktype": quicktype, + "raise": raise, + "range": range, + "readonly": readonly, + "ref": ref, + "register": register, + "reinterpret_cast": reinterpretCast, + "repeat": repeat, + "require": require, + "required": required, + "requires": requires, + "restrict": restrict, + "retain": retain, + "rethrows": rethrows, + "return": topLevelReturn, + "right": right, + "sbyte": sbyte, + "sealed": sealed, + "SEL": sel, + "select": select, + "Self": self, + "self": topLevelSelf, + "serialize": serialize, + "set": topLevelSet, + "short": short, + "signed": signed, + "sizeof": sizeof, + "stackalloc": stackalloc, + "static": topLevelStatic, + "static_assert": staticAssert, + "static_cast": staticCast, + "strictfp": strictfp, + "string": string, + "struct": struct, + "subscript": subscript, + "super": topLevelSuper, + "switch": topLevelSwitch, + "symbol": symbol, + "synchronized": synchronized, + "system": system, + "template": template, + "then": then, + "this": topLevelThis, + "thread_local": threadLocal, + "throw": topLevelThrow, + "throws": throws, + "to_json": topLevelToJson, + "top_level": topLevel, + "transient": transient, + "True": topLevelTrue, + "true": purpleTrue, + "try": topLevelTry, + "Type": type, + "type": topLevelType, + "typealias": typealias, + "typedef": topLevelTypedef, + "typeid": typeid, + "typename": typename, + "typeof": typeof, + "uint": uint, + "ulong": ulong, + "unchecked": unchecked, + "undefined": undefined, + "union": union, + "unowned": unowned, + "unsafe": unsafe, + "unsigned": unsigned, + "ushort": ushort, + "using": using, + "var": topLevelVar, + "virtual": virtual, + "void": topLevelVoid, + "volatile": volatile, + "wchar_t": wcharT, + "weak": weak, + "where": where, + "while": topLevelWhile, + "willSet": willSet, + "with": topLevelWith, + "xor": xor, + "xor_eq": xorEq, + "YES": yes, + "yield": topLevelYield, + }; +} + +class Alignas { + Alignas(); + + factory Alignas.fromJson(Map json) => Alignas( + ); + + Map toJson() => { + }; +} + +class Alignof { + Alignof(); + + factory Alignof.fromJson(Map json) => Alignof( + ); + + Map toJson() => { + }; +} + +class And { + And(); + + factory And.fromJson(Map json) => And( + ); + + Map toJson() => { + }; +} + +class AndEq { + AndEq(); + + factory AndEq.fromJson(Map json) => AndEq( + ); + + Map toJson() => { + }; +} + +class Any { + Any(); + + factory Any.fromJson(Map json) => Any( + ); + + Map toJson() => { + }; +} + +class Array { + Array(); + + factory Array.fromJson(Map json) => Array( + ); + + Map toJson() => { + }; +} + +class Asm { + Asm(); + + factory Asm.fromJson(Map json) => Asm( + ); + + Map toJson() => { + }; +} + +class Associatedtype { + Associatedtype(); + + factory Associatedtype.fromJson(Map json) => Associatedtype( + ); + + Map toJson() => { + }; +} + +class Associativity { + Associativity(); + + factory Associativity.fromJson(Map json) => Associativity( + ); + + Map toJson() => { + }; +} + +class Atomic { + Atomic(); + + factory Atomic.fromJson(Map json) => Atomic( + ); + + Map toJson() => { + }; +} + +class AtomicCancel { + AtomicCancel(); + + factory AtomicCancel.fromJson(Map json) => AtomicCancel( + ); + + Map toJson() => { + }; +} + +class AtomicCommit { + AtomicCommit(); + + factory AtomicCommit.fromJson(Map json) => AtomicCommit( + ); + + Map toJson() => { + }; +} + +class AtomicNoexcept { + AtomicNoexcept(); + + factory AtomicNoexcept.fromJson(Map json) => AtomicNoexcept( + ); + + Map toJson() => { + }; +} + +class Auto { + Auto(); + + factory Auto.fromJson(Map json) => Auto( + ); + + Map toJson() => { + }; +} + +class Base { + Base(); + + factory Base.fromJson(Map json) => Base( + ); + + Map toJson() => { + }; +} + +class Bitand { + Bitand(); + + factory Bitand.fromJson(Map json) => Bitand( + ); + + Map toJson() => { + }; +} + +class Bitor { + Bitor(); + + factory Bitor.fromJson(Map json) => Bitor( + ); + + Map toJson() => { + }; +} + +class Boolean { + Boolean(); + + factory Boolean.fromJson(Map json) => Boolean( + ); + + Map toJson() => { + }; +} + +class Bycopy { + Bycopy(); + + factory Bycopy.fromJson(Map json) => Bycopy( + ); + + Map toJson() => { + }; +} + +class Byref { + Byref(); + + factory Byref.fromJson(Map json) => Byref( + ); + + Map toJson() => { + }; +} + +class Byte { + Byte(); + + factory Byte.fromJson(Map json) => Byte( + ); + + Map toJson() => { + }; +} + +class Chan { + Chan(); + + factory Chan.fromJson(Map json) => Chan( + ); + + Map toJson() => { + }; +} + +class Char { + Char(); + + factory Char.fromJson(Map json) => Char( + ); + + Map toJson() => { + }; +} + +class Char16T { + Char16T(); + + factory Char16T.fromJson(Map json) => Char16T( + ); + + Map toJson() => { + }; +} + +class Char32T { + Char32T(); + + factory Char32T.fromJson(Map json) => Char32T( + ); + + Map toJson() => { + }; +} + +class Checked { + Checked(); + + factory Checked.fromJson(Map json) => Checked( + ); + + Map toJson() => { + }; +} + +class CoAwait { + CoAwait(); + + factory CoAwait.fromJson(Map json) => CoAwait( + ); + + Map toJson() => { + }; +} + +class CoReturn { + CoReturn(); + + factory CoReturn.fromJson(Map json) => CoReturn( + ); + + Map toJson() => { + }; +} + +class CoYield { + CoYield(); + + factory CoYield.fromJson(Map json) => CoYield( + ); + + Map toJson() => { + }; +} + +class Compl { + Compl(); + + factory Compl.fromJson(Map json) => Compl( + ); + + Map toJson() => { + }; +} + +class Complex { + Complex(); + + factory Complex.fromJson(Map json) => Complex( + ); + + Map toJson() => { + }; +} + +class Concept { + Concept(); + + factory Concept.fromJson(Map json) => Concept( + ); + + Map toJson() => { + }; +} + +class Console { + Console(); + + factory Console.fromJson(Map json) => Console( + ); + + Map toJson() => { + }; +} + +class ConstCast { + ConstCast(); + + factory ConstCast.fromJson(Map json) => ConstCast( + ); + + Map toJson() => { + }; +} + +class Constexpr { + Constexpr(); + + factory Constexpr.fromJson(Map json) => Constexpr( + ); + + Map toJson() => { + }; +} + +class Constructor { + Constructor(); + + factory Constructor.fromJson(Map json) => Constructor( + ); + + Map toJson() => { + }; +} + +class Convenience { + Convenience(); + + factory Convenience.fromJson(Map json) => Convenience( + ); + + Map toJson() => { + }; +} + +class Convert { + Convert(); + + factory Convert.fromJson(Map json) => Convert( + ); + + Map toJson() => { + }; +} + +class Converter { + Converter(); + + factory Converter.fromJson(Map json) => Converter( + ); + + Map toJson() => { + }; +} + +class Date { + Date(); + + factory Date.fromJson(Map json) => Date( + ); + + Map toJson() => { + }; +} + +class DateParseHandling { + DateParseHandling(); + + factory DateParseHandling.fromJson(Map json) => DateParseHandling( + ); + + Map toJson() => { + }; +} + +class Debugger { + Debugger(); + + factory Debugger.fromJson(Map json) => Debugger( + ); + + Map toJson() => { + }; +} + +class Decimal { + Decimal(); + + factory Decimal.fromJson(Map json) => Decimal( + ); + + Map toJson() => { + }; +} + +class Declare { + Declare(); + + factory Declare.fromJson(Map json) => Declare( + ); + + Map toJson() => { + }; +} + +class Decltype { + Decltype(); + + factory Decltype.fromJson(Map json) => Decltype( + ); + + Map toJson() => { + }; +} + +class DecodeString { + DecodeString(); + + factory DecodeString.fromJson(Map json) => DecodeString( + ); + + Map toJson() => { + }; +} + +class Def { + Def(); + + factory Def.fromJson(Map json) => Def( + ); + + Map toJson() => { + }; +} + +class Defer { + Defer(); + + factory Defer.fromJson(Map json) => Defer( + ); + + Map toJson() => { + }; +} + +class Deinit { + Deinit(); + + factory Deinit.fromJson(Map json) => Deinit( + ); + + Map toJson() => { + }; +} + +class Del { + Del(); + + factory Del.fromJson(Map json) => Del( + ); + + Map toJson() => { + }; +} + +class Delegate { + Delegate(); + + factory Delegate.fromJson(Map json) => Delegate( + ); + + Map toJson() => { + }; +} + +class Delete { + Delete(); + + factory Delete.fromJson(Map json) => Delete( + ); + + Map toJson() => { + }; +} + +class Dict { + Dict(); + + factory Dict.fromJson(Map json) => Dict( + ); + + Map toJson() => { + }; +} + +class Dictionary { + Dictionary(); + + factory Dictionary.fromJson(Map json) => Dictionary( + ); + + Map toJson() => { + }; +} + +class DidSet { + DidSet(); + + factory DidSet.fromJson(Map json) => DidSet( + ); + + Map toJson() => { + }; +} + +class DynamicCast { + DynamicCast(); + + factory DynamicCast.fromJson(Map json) => DynamicCast( + ); + + Map toJson() => { + }; +} + +class Elif { + Elif(); + + factory Elif.fromJson(Map json) => Elif( + ); + + Map toJson() => { + }; +} + +class Empty { + Empty(); + + factory Empty.fromJson(Map json) => Empty( + ); + + Map toJson() => { + }; +} + +class EncodeQuickType { + EncodeQuickType(); + + factory EncodeQuickType.fromJson(Map json) => EncodeQuickType( + ); + + Map toJson() => { + }; +} + +class Event { + Event(); + + factory Event.fromJson(Map json) => Event( + ); + + Map toJson() => { + }; +} + +class Except { + Except(); + + factory Except.fromJson(Map json) => Except( + ); + + Map toJson() => { + }; +} + +class Exception { + Exception(); + + factory Exception.fromJson(Map json) => Exception( + ); + + Map toJson() => { + }; +} + +class Explicit { + Explicit(); + + factory Explicit.fromJson(Map json) => Explicit( + ); + + Map toJson() => { + }; +} + +class Exposing { + Exposing(); + + factory Exposing.fromJson(Map json) => Exposing( + ); + + Map toJson() => { + }; +} + +class Extension { + Extension(); + + factory Extension.fromJson(Map json) => Extension( + ); + + Map toJson() => { + }; +} + +class Extern { + Extern(); + + factory Extern.fromJson(Map json) => Extern( + ); + + Map toJson() => { + }; +} + +class Fallthrough { + Fallthrough(); + + factory Fallthrough.fromJson(Map json) => Fallthrough( + ); + + Map toJson() => { + }; +} + +class Fileprivate { + Fileprivate(); + + factory Fileprivate.fromJson(Map json) => Fileprivate( + ); + + Map toJson() => { + }; +} + +class Fixed { + Fixed(); + + factory Fixed.fromJson(Map json) => Fixed( + ); + + Map toJson() => { + }; +} + +class Float { + Float(); + + factory Float.fromJson(Map json) => Float( + ); + + Map toJson() => { + }; +} + +class UnionBoolBool { + UnionBoolBool(); + + factory UnionBoolBool.fromJson(Map json) => UnionBoolBool( + ); + + Map toJson() => { + }; +} + +class Foreach { + Foreach(); + + factory Foreach.fromJson(Map json) => Foreach( + ); + + Map toJson() => { + }; +} + +class Friend { + Friend(); + + factory Friend.fromJson(Map json) => Friend( + ); + + Map toJson() => { + }; +} + +class From { + From(); + + factory From.fromJson(Map json) => From( + ); + + Map toJson() => { + }; +} + +class Func { + Func(); + + factory Func.fromJson(Map json) => Func( + ); + + Map toJson() => { + }; +} + +class FunctionClass { + FunctionClass(); + + factory FunctionClass.fromJson(Map json) => FunctionClass( + ); + + Map toJson() => { + }; +} + +class Global { + Global(); + + factory Global.fromJson(Map json) => Global( + ); + + Map toJson() => { + }; +} + +class Go { + Go(); + + factory Go.fromJson(Map json) => Go( + ); + + Map toJson() => { + }; +} + +class Goto { + Goto(); + + factory Goto.fromJson(Map json) => Goto( + ); + + Map toJson() => { + }; +} + +class Guard { + Guard(); + + factory Guard.fromJson(Map json) => Guard( + ); + + Map toJson() => { + }; +} + +class HasOwnProperty { + HasOwnProperty(); + + factory HasOwnProperty.fromJson(Map json) => HasOwnProperty( + ); + + Map toJson() => { + }; +} + +class Id { + Id(); + + factory Id.fromJson(Map json) => Id( + ); + + Map toJson() => { + }; +} + +class Imaginery { + Imaginery(); + + factory Imaginery.fromJson(Map json) => Imaginery( + ); + + Map toJson() => { + }; +} + +class Imp { + Imp(); + + factory Imp.fromJson(Map json) => Imp( + ); + + Map toJson() => { + }; +} + +class Implicit { + Implicit(); + + factory Implicit.fromJson(Map json) => Implicit( + ); + + Map toJson() => { + }; +} + +class Indirect { + Indirect(); + + factory Indirect.fromJson(Map json) => Indirect( + ); + + Map toJson() => { + }; +} + +class Infix { + Infix(); + + factory Infix.fromJson(Map json) => Infix( + ); + + Map toJson() => { + }; +} + +class Init { + Init(); + + factory Init.fromJson(Map json) => Init( + ); + + Map toJson() => { + }; +} + +class Inline { + Inline(); + + factory Inline.fromJson(Map json) => Inline( + ); + + Map toJson() => { + }; +} + +class Inout { + Inout(); + + factory Inout.fromJson(Map json) => Inout( + ); + + Map toJson() => { + }; +} + +class Instanceof { + Instanceof(); + + factory Instanceof.fromJson(Map json) => Instanceof( + ); + + Map toJson() => { + }; +} + +class Internal { + Internal(); + + factory Internal.fromJson(Map json) => Internal( + ); + + Map toJson() => { + }; +} + +class Iterable { + Iterable(); + + factory Iterable.fromJson(Map json) => Iterable( + ); + + Map toJson() => { + }; +} + +class Jdec { + Jdec(); + + factory Jdec.fromJson(Map json) => Jdec( + ); + + Map toJson() => { + }; +} + +class Jenc { + Jenc(); + + factory Jenc.fromJson(Map json) => Jenc( + ); + + Map toJson() => { + }; +} + +class Jpipe { + Jpipe(); + + factory Jpipe.fromJson(Map json) => Jpipe( + ); + + Map toJson() => { + }; +} + +class Json { + Json(); + + factory Json.fromJson(Map json) => Json( + ); + + Map toJson() => { + }; +} + +class JsonConverter { + JsonConverter(); + + factory JsonConverter.fromJson(Map json) => JsonConverter( + ); + + Map toJson() => { + }; +} + +class JsonSerializer { + JsonSerializer(); + + factory JsonSerializer.fromJson(Map json) => JsonSerializer( + ); + + Map toJson() => { + }; +} + +class JsonToken { + JsonToken(); + + factory JsonToken.fromJson(Map json) => JsonToken( + ); + + Map toJson() => { + }; +} + +class JsonWriter { + JsonWriter(); + + factory JsonWriter.fromJson(Map json) => JsonWriter( + ); + + Map toJson() => { + }; +} + +class Lambda { + Lambda(); + + factory Lambda.fromJson(Map json) => Lambda( + ); + + Map toJson() => { + }; +} + +class Lazy { + Lazy(); + + factory Lazy.fromJson(Map json) => Lazy( + ); + + Map toJson() => { + }; +} + +class Left { + Left(); + + factory Left.fromJson(Map json) => Left( + ); + + Map toJson() => { + }; +} + +class Let { + Let(); + + factory Let.fromJson(Map json) => Let( + ); + + Map toJson() => { + }; +} + +class ListClass { + ListClass(); + + factory ListClass.fromJson(Map json) => ListClass( + ); + + Map toJson() => { + }; +} + +class Lock { + Lock(); + + factory Lock.fromJson(Map json) => Lock( + ); + + Map toJson() => { + }; +} + +class Long { + Long(); + + factory Long.fromJson(Map json) => Long( + ); + + Map toJson() => { + }; +} + +class MapClass { + MapClass(); + + factory MapClass.fromJson(Map json) => MapClass( + ); + + Map toJson() => { + }; +} + +class MetadataPropertyHandling { + MetadataPropertyHandling(); + + factory MetadataPropertyHandling.fromJson(Map json) => MetadataPropertyHandling( + ); + + Map toJson() => { + }; +} + +class Module { + Module(); + + factory Module.fromJson(Map json) => Module( + ); + + Map toJson() => { + }; +} + +class Mutable { + Mutable(); + + factory Mutable.fromJson(Map json) => Mutable( + ); + + Map toJson() => { + }; +} + +class Mutating { + Mutating(); + + factory Mutating.fromJson(Map json) => Mutating( + ); + + Map toJson() => { + }; +} + +class Namespace { + Namespace(); + + factory Namespace.fromJson(Map json) => Namespace( + ); + + Map toJson() => { + }; +} + +class Native { + Native(); + + factory Native.fromJson(Map json) => Native( + ); + + Map toJson() => { + }; +} + +class Newtonsoft { + Newtonsoft(); + + factory Newtonsoft.fromJson(Map json) => Newtonsoft( + ); + + Map toJson() => { + }; +} + +class Nil { + Nil(); + + factory Nil.fromJson(Map json) => Nil( + ); + + Map toJson() => { + }; +} + +class No { + No(); + + factory No.fromJson(Map json) => No( + ); + + Map toJson() => { + }; +} + +class Noexcept { + Noexcept(); + + factory Noexcept.fromJson(Map json) => Noexcept( + ); + + Map toJson() => { + }; +} + +class Nonatomic { + Nonatomic(); + + factory Nonatomic.fromJson(Map json) => Nonatomic( + ); + + Map toJson() => { + }; +} + +class None { + None(); + + factory None.fromJson(Map json) => None( + ); + + Map toJson() => { + }; +} + +class Nonlocal { + Nonlocal(); + + factory Nonlocal.fromJson(Map json) => Nonlocal( + ); + + Map toJson() => { + }; +} + +class Nonmutating { + Nonmutating(); + + factory Nonmutating.fromJson(Map json) => Nonmutating( + ); + + Map toJson() => { + }; +} + +class Not { + Not(); + + factory Not.fromJson(Map json) => Not( + ); + + Map toJson() => { + }; +} + +class NotEq { + NotEq(); + + factory NotEq.fromJson(Map json) => NotEq( + ); + + Map toJson() => { + }; +} + +class NsString { + NsString(); + + factory NsString.fromJson(Map json) => NsString( + ); + + Map toJson() => { + }; +} + +class Nullptr { + Nullptr(); + + factory Nullptr.fromJson(Map json) => Nullptr( + ); + + Map toJson() => { + }; +} + +class Number { + Number(); + + factory Number.fromJson(Map json) => Number( + ); + + Map toJson() => { + }; +} + +class Object { + Object(); + + factory Object.fromJson(Map json) => Object( + ); + + Map toJson() => { + }; +} + +class Of { + Of(); + + factory Of.fromJson(Map json) => Of( + ); + + Map toJson() => { + }; +} + +class Oneway { + Oneway(); + + factory Oneway.fromJson(Map json) => Oneway( + ); + + Map toJson() => { + }; +} + +class Open { + Open(); + + factory Open.fromJson(Map json) => Open( + ); + + Map toJson() => { + }; +} + +class Optional { + Optional(); + + factory Optional.fromJson(Map json) => Optional( + ); + + Map toJson() => { + }; +} + +class Or { + Or(); + + factory Or.fromJson(Map json) => Or( + ); + + Map toJson() => { + }; +} + +class OrEq { + OrEq(); + + factory OrEq.fromJson(Map json) => OrEq( + ); + + Map toJson() => { + }; +} + +class Out { + Out(); + + factory Out.fromJson(Map json) => Out( + ); + + Map toJson() => { + }; +} + +class Override { + Override(); + + factory Override.fromJson(Map json) => Override( + ); + + Map toJson() => { + }; +} + +class Package { + Package(); + + factory Package.fromJson(Map json) => Package( + ); + + Map toJson() => { + }; +} + +class Params { + Params(); + + factory Params.fromJson(Map json) => Params( + ); + + Map toJson() => { + }; +} + +class Pass { + Pass(); + + factory Pass.fromJson(Map json) => Pass( + ); + + Map toJson() => { + }; +} + +class Port { + Port(); + + factory Port.fromJson(Map json) => Port( + ); + + Map toJson() => { + }; +} + +class Postfix { + Postfix(); + + factory Postfix.fromJson(Map json) => Postfix( + ); + + Map toJson() => { + }; +} + +class Precedence { + Precedence(); + + factory Precedence.fromJson(Map json) => Precedence( + ); + + Map toJson() => { + }; +} + +class Prefix { + Prefix(); + + factory Prefix.fromJson(Map json) => Prefix( + ); + + Map toJson() => { + }; +} + +class Print { + Print(); + + factory Print.fromJson(Map json) => Print( + ); + + Map toJson() => { + }; +} + +class Printf { + Printf(); + + factory Printf.fromJson(Map json) => Printf( + ); + + Map toJson() => { + }; +} + +class Private { + Private(); + + factory Private.fromJson(Map json) => Private( + ); + + Map toJson() => { + }; +} + +class Protected { + Protected(); + + factory Protected.fromJson(Map json) => Protected( + ); + + Map toJson() => { + }; +} + +class Protocol { + Protocol(); + + factory Protocol.fromJson(Map json) => Protocol( + ); + + Map toJson() => { + }; +} + +class Public { + Public(); + + factory Public.fromJson(Map json) => Public( + ); + + Map toJson() => { + }; +} + +class BoolClass { + BoolClass(); + + factory BoolClass.fromJson(Map json) => BoolClass( + ); + + Map toJson() => { + }; +} + +class ClassClass { + ClassClass(); + + factory ClassClass.fromJson(Map json) => ClassClass( + ); + + Map toJson() => { + }; +} + +class FalseClass { + FalseClass(); + + factory FalseClass.fromJson(Map json) => FalseClass( + ); + + Map toJson() => { + }; +} + +class NullClass { + NullClass(); + + factory NullClass.fromJson(Map json) => NullClass( + ); + + Map toJson() => { + }; +} + +class TrueClass { + TrueClass(); + + factory TrueClass.fromJson(Map json) => TrueClass( + ); + + Map toJson() => { + }; +} + +class Quicktype { + Quicktype(); + + factory Quicktype.fromJson(Map json) => Quicktype( + ); + + Map toJson() => { + }; +} + +class Raise { + Raise(); + + factory Raise.fromJson(Map json) => Raise( + ); + + Map toJson() => { + }; +} + +class Range { + Range(); + + factory Range.fromJson(Map json) => Range( + ); + + Map toJson() => { + }; +} + +class Readonly { + Readonly(); + + factory Readonly.fromJson(Map json) => Readonly( + ); + + Map toJson() => { + }; +} + +class Ref { + Ref(); + + factory Ref.fromJson(Map json) => Ref( + ); + + Map toJson() => { + }; +} + +class Register { + Register(); + + factory Register.fromJson(Map json) => Register( + ); + + Map toJson() => { + }; +} + +class ReinterpretCast { + ReinterpretCast(); + + factory ReinterpretCast.fromJson(Map json) => ReinterpretCast( + ); + + Map toJson() => { + }; +} + +class Repeat { + Repeat(); + + factory Repeat.fromJson(Map json) => Repeat( + ); + + Map toJson() => { + }; +} + +class Require { + Require(); + + factory Require.fromJson(Map json) => Require( + ); + + Map toJson() => { + }; +} + +class Required { + Required(); + + factory Required.fromJson(Map json) => Required( + ); + + Map toJson() => { + }; +} + +class Requires { + Requires(); + + factory Requires.fromJson(Map json) => Requires( + ); + + Map toJson() => { + }; +} + +class Restrict { + Restrict(); + + factory Restrict.fromJson(Map json) => Restrict( + ); + + Map toJson() => { + }; +} + +class Retain { + Retain(); + + factory Retain.fromJson(Map json) => Retain( + ); + + Map toJson() => { + }; +} + +class Rethrows { + Rethrows(); + + factory Rethrows.fromJson(Map json) => Rethrows( + ); + + Map toJson() => { + }; +} + +class Right { + Right(); + + factory Right.fromJson(Map json) => Right( + ); + + Map toJson() => { + }; +} + +class Sbyte { + Sbyte(); + + factory Sbyte.fromJson(Map json) => Sbyte( + ); + + Map toJson() => { + }; +} + +class Sealed { + Sealed(); + + factory Sealed.fromJson(Map json) => Sealed( + ); + + Map toJson() => { + }; +} + +class Sel { + Sel(); + + factory Sel.fromJson(Map json) => Sel( + ); + + Map toJson() => { + }; +} + +class Select { + Select(); + + factory Select.fromJson(Map json) => Select( + ); + + Map toJson() => { + }; +} + +class Self { + Self(); + + factory Self.fromJson(Map json) => Self( + ); + + Map toJson() => { + }; +} + +class Serialize { + Serialize(); + + factory Serialize.fromJson(Map json) => Serialize( + ); + + Map toJson() => { + }; +} + +class Short { + Short(); + + factory Short.fromJson(Map json) => Short( + ); + + Map toJson() => { + }; +} + +class Signed { + Signed(); + + factory Signed.fromJson(Map json) => Signed( + ); + + Map toJson() => { + }; +} + +class Sizeof { + Sizeof(); + + factory Sizeof.fromJson(Map json) => Sizeof( + ); + + Map toJson() => { + }; +} + +class Stackalloc { + Stackalloc(); + + factory Stackalloc.fromJson(Map json) => Stackalloc( + ); + + Map toJson() => { + }; +} + +class StaticAssert { + StaticAssert(); + + factory StaticAssert.fromJson(Map json) => StaticAssert( + ); + + Map toJson() => { + }; +} + +class StaticCast { + StaticCast(); + + factory StaticCast.fromJson(Map json) => StaticCast( + ); + + Map toJson() => { + }; +} + +class Strictfp { + Strictfp(); + + factory Strictfp.fromJson(Map json) => Strictfp( + ); + + Map toJson() => { + }; +} + +class StringClass { + StringClass(); + + factory StringClass.fromJson(Map json) => StringClass( + ); + + Map toJson() => { + }; +} + +class Struct { + Struct(); + + factory Struct.fromJson(Map json) => Struct( + ); + + Map toJson() => { + }; +} + +class Subscript { + Subscript(); + + factory Subscript.fromJson(Map json) => Subscript( + ); + + Map toJson() => { + }; +} + +class Symbol { + Symbol(); + + factory Symbol.fromJson(Map json) => Symbol( + ); + + Map toJson() => { + }; +} + +class Synchronized { + Synchronized(); + + factory Synchronized.fromJson(Map json) => Synchronized( + ); + + Map toJson() => { + }; +} + +class System { + System(); + + factory System.fromJson(Map json) => System( + ); + + Map toJson() => { + }; +} + +class Template { + Template(); + + factory Template.fromJson(Map json) => Template( + ); + + Map toJson() => { + }; +} + +class Then { + Then(); + + factory Then.fromJson(Map json) => Then( + ); + + Map toJson() => { + }; +} + +class ThreadLocal { + ThreadLocal(); + + factory ThreadLocal.fromJson(Map json) => ThreadLocal( + ); + + Map toJson() => { + }; +} + +class Throws { + Throws(); + + factory Throws.fromJson(Map json) => Throws( + ); + + Map toJson() => { + }; +} + +class TopLevelClass { + TopLevelClass(); + + factory TopLevelClass.fromJson(Map json) => TopLevelClass( + ); + + Map toJson() => { + }; +} + +class Abstract { + Abstract(); + + factory Abstract.fromJson(Map json) => Abstract( + ); + + Map toJson() => { + }; +} + +class AnyClass { + AnyClass(); + + factory AnyClass.fromJson(Map json) => AnyClass( + ); + + Map toJson() => { + }; +} + +class As { + As(); + + factory As.fromJson(Map json) => As( + ); + + Map toJson() => { + }; +} + +class Assert { + Assert(); + + factory Assert.fromJson(Map json) => Assert( + ); + + Map toJson() => { + }; +} + +class Async { + Async(); + + factory Async.fromJson(Map json) => Async( + ); + + Map toJson() => { + }; +} + +class Await { + Await(); + + factory Await.fromJson(Map json) => Await( + ); + + Map toJson() => { + }; +} + +class Bool { + Bool(); + + factory Bool.fromJson(Map json) => Bool( + ); + + Map toJson() => { + }; +} + +class Break { + Break(); + + factory Break.fromJson(Map json) => Break( + ); + + Map toJson() => { + }; +} + +class Case { + Case(); + + factory Case.fromJson(Map json) => Case( + ); + + Map toJson() => { + }; +} + +class Catch { + Catch(); + + factory Catch.fromJson(Map json) => Catch( + ); + + Map toJson() => { + }; +} + +class Class { + Class(); + + factory Class.fromJson(Map json) => Class( + ); + + Map toJson() => { + }; +} + +class Const { + Const(); + + factory Const.fromJson(Map json) => Const( + ); + + Map toJson() => { + }; +} + +class Continue { + Continue(); + + factory Continue.fromJson(Map json) => Continue( + ); + + Map toJson() => { + }; +} + +class Default { + Default(); + + factory Default.fromJson(Map json) => Default( + ); + + Map toJson() => { + }; +} + +class Do { + Do(); + + factory Do.fromJson(Map json) => Do( + ); + + Map toJson() => { + }; +} + +class Double { + Double(); + + factory Double.fromJson(Map json) => Double( + ); + + Map toJson() => { + }; +} + +class Dynamic { + Dynamic(); + + factory Dynamic.fromJson(Map json) => Dynamic( + ); + + Map toJson() => { + }; +} + +class Else { + Else(); + + factory Else.fromJson(Map json) => Else( + ); + + Map toJson() => { + }; +} + +class Enum { + Enum(); + + factory Enum.fromJson(Map json) => Enum( + ); + + Map toJson() => { + }; +} + +class Export { + Export(); + + factory Export.fromJson(Map json) => Export( + ); + + Map toJson() => { + }; +} + +class Extends { + Extends(); + + factory Extends.fromJson(Map json) => Extends( + ); + + Map toJson() => { + }; +} + +class False { + False(); + + factory False.fromJson(Map json) => False( + ); + + Map toJson() => { + }; +} + +class Final { + Final(); + + factory Final.fromJson(Map json) => Final( + ); + + Map toJson() => { + }; +} + +class Finally { + Finally(); + + factory Finally.fromJson(Map json) => Finally( + ); + + Map toJson() => { + }; +} + +class For { + For(); + + factory For.fromJson(Map json) => For( + ); + + Map toJson() => { + }; +} + +class FromJson { + FromJson(); + + factory FromJson.fromJson(Map json) => FromJson( + ); + + Map toJson() => { + }; +} + +class Get { + Get(); + + factory Get.fromJson(Map json) => Get( + ); + + Map toJson() => { + }; +} + +class If { + If(); + + factory If.fromJson(Map json) => If( + ); + + Map toJson() => { + }; +} + +class Implements { + Implements(); + + factory Implements.fromJson(Map json) => Implements( + ); + + Map toJson() => { + }; +} + +class Import { + Import(); + + factory Import.fromJson(Map json) => Import( + ); + + Map toJson() => { + }; +} + +class In { + In(); + + factory In.fromJson(Map json) => In( + ); + + Map toJson() => { + }; +} + +class Int { + Int(); + + factory Int.fromJson(Map json) => Int( + ); + + Map toJson() => { + }; +} + +class Interface { + Interface(); + + factory Interface.fromJson(Map json) => Interface( + ); + + Map toJson() => { + }; +} + +class Is { + Is(); + + factory Is.fromJson(Map json) => Is( + ); + + Map toJson() => { + }; +} + +class New { + New(); + + factory New.fromJson(Map json) => New( + ); + + Map toJson() => { + }; +} + +class NoneClass { + NoneClass(); + + factory NoneClass.fromJson(Map json) => NoneClass( + ); + + Map toJson() => { + }; +} + +class Null { + Null(); + + factory Null.fromJson(Map json) => Null( + ); + + Map toJson() => { + }; +} + +class Operator { + Operator(); + + factory Operator.fromJson(Map json) => Operator( + ); + + Map toJson() => { + }; +} + +class ProtocolClass { + ProtocolClass(); + + factory ProtocolClass.fromJson(Map json) => ProtocolClass( + ); + + Map toJson() => { + }; +} + +class Return { + Return(); + + factory Return.fromJson(Map json) => Return( + ); + + Map toJson() => { + }; +} + +class SelfClass { + SelfClass(); + + factory SelfClass.fromJson(Map json) => SelfClass( + ); + + Map toJson() => { + }; +} + +class Set { + Set(); + + factory Set.fromJson(Map json) => Set( + ); + + Map toJson() => { + }; +} + +class Static { + Static(); + + factory Static.fromJson(Map json) => Static( + ); + + Map toJson() => { + }; +} + +class Super { + Super(); + + factory Super.fromJson(Map json) => Super( + ); + + Map toJson() => { + }; +} + +class Switch { + Switch(); + + factory Switch.fromJson(Map json) => Switch( + ); + + Map toJson() => { + }; +} + +class This { + This(); + + factory This.fromJson(Map json) => This( + ); + + Map toJson() => { + }; +} + +class Throw { + Throw(); + + factory Throw.fromJson(Map json) => Throw( + ); + + Map toJson() => { + }; +} + +class ToJson { + ToJson(); + + factory ToJson.fromJson(Map json) => ToJson( + ); + + Map toJson() => { + }; +} + +class True { + True(); + + factory True.fromJson(Map json) => True( + ); + + Map toJson() => { + }; +} + +class Try { + Try(); + + factory Try.fromJson(Map json) => Try( + ); + + Map toJson() => { + }; +} + +class TypeClass { + TypeClass(); + + factory TypeClass.fromJson(Map json) => TypeClass( + ); + + Map toJson() => { + }; +} + +class Typedef { + Typedef(); + + factory Typedef.fromJson(Map json) => Typedef( + ); + + Map toJson() => { + }; +} + +class Var { + Var(); + + factory Var.fromJson(Map json) => Var( + ); + + Map toJson() => { + }; +} + +class Void { + Void(); + + factory Void.fromJson(Map json) => Void( + ); + + Map toJson() => { + }; +} + +class While { + While(); + + factory While.fromJson(Map json) => While( + ); + + Map toJson() => { + }; +} + +class With { + With(); + + factory With.fromJson(Map json) => With( + ); + + Map toJson() => { + }; +} + +class Yield { + Yield(); + + factory Yield.fromJson(Map json) => Yield( + ); + + Map toJson() => { + }; +} + +class Transient { + Transient(); + + factory Transient.fromJson(Map json) => Transient( + ); + + Map toJson() => { + }; +} + +class Type { + Type(); + + factory Type.fromJson(Map json) => Type( + ); + + Map toJson() => { + }; +} + +class Typealias { + Typealias(); + + factory Typealias.fromJson(Map json) => Typealias( + ); + + Map toJson() => { + }; +} + +class Typeid { + Typeid(); + + factory Typeid.fromJson(Map json) => Typeid( + ); + + Map toJson() => { + }; +} + +class Typename { + Typename(); + + factory Typename.fromJson(Map json) => Typename( + ); + + Map toJson() => { + }; +} + +class Typeof { + Typeof(); + + factory Typeof.fromJson(Map json) => Typeof( + ); + + Map toJson() => { + }; +} + +class Uint { + Uint(); + + factory Uint.fromJson(Map json) => Uint( + ); + + Map toJson() => { + }; +} + +class Ulong { + Ulong(); + + factory Ulong.fromJson(Map json) => Ulong( + ); + + Map toJson() => { + }; +} + +class Unchecked { + Unchecked(); + + factory Unchecked.fromJson(Map json) => Unchecked( + ); + + Map toJson() => { + }; +} + +class Undefined { + Undefined(); + + factory Undefined.fromJson(Map json) => Undefined( + ); + + Map toJson() => { + }; +} + +class Union { + Union(); + + factory Union.fromJson(Map json) => Union( + ); + + Map toJson() => { + }; +} + +class Unowned { + Unowned(); + + factory Unowned.fromJson(Map json) => Unowned( + ); + + Map toJson() => { + }; +} + +class Unsafe { + Unsafe(); + + factory Unsafe.fromJson(Map json) => Unsafe( + ); + + Map toJson() => { + }; +} + +class Unsigned { + Unsigned(); + + factory Unsigned.fromJson(Map json) => Unsigned( + ); + + Map toJson() => { + }; +} + +class Ushort { + Ushort(); + + factory Ushort.fromJson(Map json) => Ushort( + ); + + Map toJson() => { + }; +} + +class Using { + Using(); + + factory Using.fromJson(Map json) => Using( + ); + + Map toJson() => { + }; +} + +class Virtual { + Virtual(); + + factory Virtual.fromJson(Map json) => Virtual( + ); + + Map toJson() => { + }; +} + +class Volatile { + Volatile(); + + factory Volatile.fromJson(Map json) => Volatile( + ); + + Map toJson() => { + }; +} + +class WcharT { + WcharT(); + + factory WcharT.fromJson(Map json) => WcharT( + ); + + Map toJson() => { + }; +} + +class Weak { + Weak(); + + factory Weak.fromJson(Map json) => Weak( + ); + + Map toJson() => { + }; +} + +class Where { + Where(); + + factory Where.fromJson(Map json) => Where( + ); + + Map toJson() => { + }; +} + +class WillSet { + WillSet(); + + factory WillSet.fromJson(Map json) => WillSet( + ); + + Map toJson() => { + }; +} + +class Xor { + Xor(); + + factory Xor.fromJson(Map json) => Xor( + ); + + Map toJson() => { + }; +} + +class XorEq { + XorEq(); + + factory XorEq.fromJson(Map json) => XorEq( + ); + + Map toJson() => { + }; +} + +class Yes { + Yes(); + + factory Yes.fromJson(Map json) => Yes( + ); + + Map toJson() => { + }; +}