Generated-output differences

quicktype output changed between the PR base and tested PR merge revisions.
← Back to the pull request
25test cases
27files differ
0modified
27new
0deleted
14,325changed lines
+14,325 −0insertions / deletions
Base d3014aaec4f7ed11fb83168f39211b755deeeb1d · PR merge 8f669f82cd38b53b01e0178fd41191ed8cf222ac · Head f17a105e145cb0ca4cabf8b239cd11f0515fe410 · raw patch
Test case

test/inputs/json/priority/bug427.json

1 generated file · +2,361 −0
Adartdefault / TopLevel.dart+2,361 −0
@@ -0,0 +1,2361 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final List<TopLevelChild> children;
13+ final GetSignatureFlags flags;
14+ final List<Group> groups;
15+ final int id;
16+ final int kind;
17+ final String name;
18+
19+ TopLevel({
20+ required this.children,
21+ required this.flags,
22+ required this.groups,
23+ required this.id,
24+ required this.kind,
25+ required this.name,
26+ });
27+
28+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
29+ children: List<TopLevelChild>.from(json["children"].map((x) => TopLevelChild.fromJson(x))),
30+ flags: GetSignatureFlags.fromJson(json["flags"]),
31+ groups: List<Group>.from(json["groups"].map((x) => Group.fromJson(x))),
32+ id: json["id"],
33+ kind: json["kind"],
34+ name: json["name"],
35+ );
36+
37+ Map<String, dynamic> toJson() => {
38+ "children": List<dynamic>.from(children.map((x) => x.toJson())),
39+ "flags": flags.toJson(),
40+ "groups": List<dynamic>.from(groups.map((x) => x.toJson())),
41+ "id": id,
42+ "kind": kind,
43+ "name": name,
44+ };
45+}
46+
47+class TopLevelChild {
48+ final List<PurpleChild> children;
49+ final IndecentComment? comment;
50+ final PurpleFlags flags;
51+ final List<Group> groups;
52+ final int id;
53+ final int kind;
54+ final TentacledKindString kindString;
55+ final String name;
56+ final String originalName;
57+ final List<Source> sources;
58+
59+ TopLevelChild({
60+ required this.children,
61+ this.comment,
62+ required this.flags,
63+ required this.groups,
64+ required this.id,
65+ required this.kind,
66+ required this.kindString,
67+ required this.name,
68+ required this.originalName,
69+ required this.sources,
70+ });
71+
72+ factory TopLevelChild.fromJson(Map<String, dynamic> json) => TopLevelChild(
73+ children: List<PurpleChild>.from(json["children"].map((x) => PurpleChild.fromJson(x))),
74+ comment: json["comment"] == null ? null : IndecentComment.fromJson(json["comment"]),
75+ flags: PurpleFlags.fromJson(json["flags"]),
76+ groups: List<Group>.from(json["groups"].map((x) => Group.fromJson(x))),
77+ id: json["id"],
78+ kind: json["kind"],
79+ kindString: tentacledKindStringValues.map[json["kindString"]]!,
80+ name: json["name"],
81+ originalName: json["originalName"],
82+ sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
83+ );
84+
85+ Map<String, dynamic> toJson() => {
86+ "children": List<dynamic>.from(children.map((x) => x.toJson())),
87+ "comment": comment?.toJson(),
88+ "flags": flags.toJson(),
89+ "groups": List<dynamic>.from(groups.map((x) => x.toJson())),
90+ "id": id,
91+ "kind": kind,
92+ "kindString": tentacledKindStringValues.reverse[kindString],
93+ "name": name,
94+ "originalName": originalName,
95+ "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
96+ };
97+}
98+
99+class PurpleChild {
100+ final List<FluffyChild>? children;
101+ final StickyComment? comment;
102+ final String? defaultValue;
103+ final List<ExtendedBy>? extendedBy;
104+ final List<ExtendedBy>? extendedTypes;
105+ final IndecentFlags flags;
106+ final List<Group>? groups;
107+ final int id;
108+ final List<ExtendedBy>? implementedBy;
109+ final List<ExtendedBy>? implementedTypes;
110+ final int kind;
111+ final FluffyKindString kindString;
112+ final String name;
113+ final List<StickySignature>? signatures;
114+ final List<Source> sources;
115+ final MagentaType? type;
116+ final List<TypeParameter>? typeParameter;
117+
118+ PurpleChild({
119+ this.children,
120+ this.comment,
121+ this.defaultValue,
122+ this.extendedBy,
123+ this.extendedTypes,
124+ required this.flags,
125+ this.groups,
126+ required this.id,
127+ this.implementedBy,
128+ this.implementedTypes,
129+ required this.kind,
130+ required this.kindString,
131+ required this.name,
132+ this.signatures,
133+ required this.sources,
134+ this.type,
135+ this.typeParameter,
136+ });
137+
138+ factory PurpleChild.fromJson(Map<String, dynamic> json) => PurpleChild(
139+ children: json["children"] == null ? null : List<FluffyChild>.from(json["children"]!.map((x) => FluffyChild.fromJson(x))),
140+ comment: json["comment"] == null ? null : StickyComment.fromJson(json["comment"]),
141+ defaultValue: json["defaultValue"],
142+ extendedBy: json["extendedBy"] == null ? null : List<ExtendedBy>.from(json["extendedBy"]!.map((x) => ExtendedBy.fromJson(x))),
143+ extendedTypes: json["extendedTypes"] == null ? null : List<ExtendedBy>.from(json["extendedTypes"]!.map((x) => ExtendedBy.fromJson(x))),
144+ flags: IndecentFlags.fromJson(json["flags"]),
145+ groups: json["groups"] == null ? null : List<Group>.from(json["groups"]!.map((x) => Group.fromJson(x))),
146+ id: json["id"],
147+ implementedBy: json["implementedBy"] == null ? null : List<ExtendedBy>.from(json["implementedBy"]!.map((x) => ExtendedBy.fromJson(x))),
148+ implementedTypes: json["implementedTypes"] == null ? null : List<ExtendedBy>.from(json["implementedTypes"]!.map((x) => ExtendedBy.fromJson(x))),
149+ kind: json["kind"],
150+ kindString: fluffyKindStringValues.map[json["kindString"]]!,
151+ name: json["name"],
152+ signatures: json["signatures"] == null ? null : List<StickySignature>.from(json["signatures"]!.map((x) => StickySignature.fromJson(x))),
153+ sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
154+ type: json["type"] == null ? null : MagentaType.fromJson(json["type"]),
155+ typeParameter: json["typeParameter"] == null ? null : List<TypeParameter>.from(json["typeParameter"]!.map((x) => TypeParameter.fromJson(x))),
156+ );
157+
158+ Map<String, dynamic> toJson() => {
159+ "children": children == null ? null : List<dynamic>.from(children!.map((x) => x.toJson())),
160+ "comment": comment?.toJson(),
161+ "defaultValue": defaultValue,
162+ "extendedBy": extendedBy == null ? null : List<dynamic>.from(extendedBy!.map((x) => x.toJson())),
163+ "extendedTypes": extendedTypes == null ? null : List<dynamic>.from(extendedTypes!.map((x) => x.toJson())),
164+ "flags": flags.toJson(),
165+ "groups": groups == null ? null : List<dynamic>.from(groups!.map((x) => x.toJson())),
166+ "id": id,
167+ "implementedBy": implementedBy == null ? null : List<dynamic>.from(implementedBy!.map((x) => x.toJson())),
168+ "implementedTypes": implementedTypes == null ? null : List<dynamic>.from(implementedTypes!.map((x) => x.toJson())),
169+ "kind": kind,
170+ "kindString": fluffyKindStringValues.reverse[kindString],
171+ "name": name,
172+ "signatures": signatures == null ? null : List<dynamic>.from(signatures!.map((x) => x.toJson())),
173+ "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
174+ "type": type?.toJson(),
175+ "typeParameter": typeParameter == null ? null : List<dynamic>.from(typeParameter!.map((x) => x.toJson())),
176+ };
177+}
178+
179+class FluffyChild {
180+ final List<TentacledChild>? children;
181+ final StickyComment? comment;
182+ final String? defaultValue;
183+ final StickyFlags flags;
184+ final GetSignature? getSignature;
185+ final List<Group>? groups;
186+ final int id;
187+ final ExtendedBy? implementationOf;
188+ final ExtendedBy? inheritedFrom;
189+ final int kind;
190+ final PurpleKindString kindString;
191+ final String name;
192+ final ExtendedBy? overwrites;
193+ final GetSignature? setSignature;
194+ final List<FluffySignature>? signatures;
195+ final List<Source> sources;
196+ final IndigoType? type;
197+
198+ FluffyChild({
199+ this.children,
200+ this.comment,
201+ this.defaultValue,
202+ required this.flags,
203+ this.getSignature,
204+ this.groups,
205+ required this.id,
206+ this.implementationOf,
207+ this.inheritedFrom,
208+ required this.kind,
209+ required this.kindString,
210+ required this.name,
211+ this.overwrites,
212+ this.setSignature,
213+ this.signatures,
214+ required this.sources,
215+ this.type,
216+ });
217+
218+ factory FluffyChild.fromJson(Map<String, dynamic> json) => FluffyChild(
219+ children: json["children"] == null ? null : List<TentacledChild>.from(json["children"]!.map((x) => TentacledChild.fromJson(x))),
220+ comment: json["comment"] == null ? null : StickyComment.fromJson(json["comment"]),
221+ defaultValue: json["defaultValue"],
222+ flags: StickyFlags.fromJson(json["flags"]),
223+ getSignature: json["getSignature"] == null ? null : GetSignature.fromJson(json["getSignature"]),
224+ groups: json["groups"] == null ? null : List<Group>.from(json["groups"]!.map((x) => Group.fromJson(x))),
225+ id: json["id"],
226+ implementationOf: json["implementationOf"] == null ? null : ExtendedBy.fromJson(json["implementationOf"]),
227+ inheritedFrom: json["inheritedFrom"] == null ? null : ExtendedBy.fromJson(json["inheritedFrom"]),
228+ kind: json["kind"],
229+ kindString: purpleKindStringValues.map[json["kindString"]]!,
230+ name: json["name"],
231+ overwrites: json["overwrites"] == null ? null : ExtendedBy.fromJson(json["overwrites"]),
232+ setSignature: json["setSignature"] == null ? null : GetSignature.fromJson(json["setSignature"]),
233+ signatures: json["signatures"] == null ? null : List<FluffySignature>.from(json["signatures"]!.map((x) => FluffySignature.fromJson(x))),
234+ sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
235+ type: json["type"] == null ? null : IndigoType.fromJson(json["type"]),
236+ );
237+
238+ Map<String, dynamic> toJson() => {
239+ "children": children == null ? null : List<dynamic>.from(children!.map((x) => x.toJson())),
240+ "comment": comment?.toJson(),
241+ "defaultValue": defaultValue,
242+ "flags": flags.toJson(),
243+ "getSignature": getSignature?.toJson(),
244+ "groups": groups == null ? null : List<dynamic>.from(groups!.map((x) => x.toJson())),
245+ "id": id,
246+ "implementationOf": implementationOf?.toJson(),
247+ "inheritedFrom": inheritedFrom?.toJson(),
248+ "kind": kind,
249+ "kindString": purpleKindStringValues.reverse[kindString],
250+ "name": name,
251+ "overwrites": overwrites?.toJson(),
252+ "setSignature": setSignature?.toJson(),
253+ "signatures": signatures == null ? null : List<dynamic>.from(signatures!.map((x) => x.toJson())),
254+ "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
255+ "type": type?.toJson(),
256+ };
257+}
258+
259+class TentacledChild {
260+ final PurpleComment? comment;
261+ final String? defaultValue;
262+ final PurpleFlags flags;
263+ final int id;
264+ final int kind;
265+ final PurpleKindString kindString;
266+ final String name;
267+ final List<PurpleSignature>? signatures;
268+ final List<Source> sources;
269+ final TypeElement? type;
270+
271+ TentacledChild({
272+ this.comment,
273+ this.defaultValue,
274+ required this.flags,
275+ required this.id,
276+ required this.kind,
277+ required this.kindString,
278+ required this.name,
279+ this.signatures,
280+ required this.sources,
281+ this.type,
282+ });
283+
284+ factory TentacledChild.fromJson(Map<String, dynamic> json) => TentacledChild(
285+ comment: json["comment"] == null ? null : PurpleComment.fromJson(json["comment"]),
286+ defaultValue: json["defaultValue"],
287+ flags: PurpleFlags.fromJson(json["flags"]),
288+ id: json["id"],
289+ kind: json["kind"],
290+ kindString: purpleKindStringValues.map[json["kindString"]]!,
291+ name: json["name"],
292+ signatures: json["signatures"] == null ? null : List<PurpleSignature>.from(json["signatures"]!.map((x) => PurpleSignature.fromJson(x))),
293+ sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
294+ type: json["type"] == null ? null : TypeElement.fromJson(json["type"]),
295+ );
296+
297+ Map<String, dynamic> toJson() => {
298+ "comment": comment?.toJson(),
299+ "defaultValue": defaultValue,
300+ "flags": flags.toJson(),
301+ "id": id,
302+ "kind": kind,
303+ "kindString": purpleKindStringValues.reverse[kindString],
304+ "name": name,
305+ "signatures": signatures == null ? null : List<dynamic>.from(signatures!.map((x) => x.toJson())),
306+ "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
307+ "type": type?.toJson(),
308+ };
309+}
310+
311+class PurpleComment {
312+ final String shortText;
313+
314+ PurpleComment({
315+ required this.shortText,
316+ });
317+
318+ factory PurpleComment.fromJson(Map<String, dynamic> json) => PurpleComment(
319+ shortText: json["shortText"],
320+ );
321+
322+ Map<String, dynamic> toJson() => {
323+ "shortText": shortText,
324+ };
325+}
326+
327+class PurpleFlags {
328+ final bool? isExported;
329+
330+ PurpleFlags({
331+ this.isExported,
332+ });
333+
334+ factory PurpleFlags.fromJson(Map<String, dynamic> json) => PurpleFlags(
335+ isExported: json["isExported"],
336+ );
337+
338+ Map<String, dynamic> toJson() => {
339+ "isExported": isExported,
340+ };
341+}
342+
343+enum PurpleKindString {
344+ VARIABLE,
345+ FUNCTION,
346+ PROPERTY,
347+ METHOD,
348+ CONSTRUCTOR,
349+ ACCESSOR,
350+ ENUMERATION_MEMBER,
351+ MODULE,
352+ OBJECT_LITERAL
353+}
354+
355+final purpleKindStringValues = EnumValues({
356+ "Variable": PurpleKindString.VARIABLE,
357+ "Function": PurpleKindString.FUNCTION,
358+ "Property": PurpleKindString.PROPERTY,
359+ "Method": PurpleKindString.METHOD,
360+ "Constructor": PurpleKindString.CONSTRUCTOR,
361+ "Accessor": PurpleKindString.ACCESSOR,
362+ "Enumeration member": PurpleKindString.ENUMERATION_MEMBER,
363+ "Module": PurpleKindString.MODULE,
364+ "Object literal": PurpleKindString.OBJECT_LITERAL
365+});
366+
367+class PurpleSignature {
368+ final PurpleComment? comment;
369+ final GetSignatureFlags flags;
370+ final int id;
371+ final int kind;
372+ final SignatureKindString kindString;
373+ final String name;
374+ final List<GetSignature> parameters;
375+ final TentacledType type;
376+
377+ PurpleSignature({
378+ this.comment,
379+ required this.flags,
380+ required this.id,
381+ required this.kind,
382+ required this.kindString,
383+ required this.name,
384+ required this.parameters,
385+ required this.type,
386+ });
387+
388+ factory PurpleSignature.fromJson(Map<String, dynamic> json) => PurpleSignature(
389+ comment: json["comment"] == null ? null : PurpleComment.fromJson(json["comment"]),
390+ flags: GetSignatureFlags.fromJson(json["flags"]),
391+ id: json["id"],
392+ kind: json["kind"],
393+ kindString: signatureKindStringValues.map[json["kindString"]]!,
394+ name: json["name"],
395+ parameters: List<GetSignature>.from(json["parameters"].map((x) => GetSignature.fromJson(x))),
396+ type: TentacledType.fromJson(json["type"]),
397+ );
398+
399+ Map<String, dynamic> toJson() => {
400+ "comment": comment?.toJson(),
401+ "flags": flags.toJson(),
402+ "id": id,
403+ "kind": kind,
404+ "kindString": signatureKindStringValues.reverse[kindString],
405+ "name": name,
406+ "parameters": List<dynamic>.from(parameters.map((x) => x.toJson())),
407+ "type": type.toJson(),
408+ };
409+}
410+
411+class GetSignatureFlags {
412+ GetSignatureFlags();
413+
414+ factory GetSignatureFlags.fromJson(Map<String, dynamic> json) => GetSignatureFlags(
415+ );
416+
417+ Map<String, dynamic> toJson() => {
418+ };
419+}
420+
421+enum SignatureKindString {
422+ CALL_SIGNATURE,
423+ CONSTRUCTOR_SIGNATURE
424+}
425+
426+final signatureKindStringValues = EnumValues({
427+ "Call signature": SignatureKindString.CALL_SIGNATURE,
428+ "Constructor signature": SignatureKindString.CONSTRUCTOR_SIGNATURE
429+});
430+
431+class GetSignatureType {
432+ final GetSignature? declaration;
433+ final ElementType? elementType;
434+ final Name? name;
435+ final TypeEnum type;
436+
437+ GetSignatureType({
438+ this.declaration,
439+ this.elementType,
440+ this.name,
441+ required this.type,
442+ });
443+
444+ factory GetSignatureType.fromJson(Map<String, dynamic> json) => GetSignatureType(
445+ declaration: json["declaration"] == null ? null : GetSignature.fromJson(json["declaration"]),
446+ elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]),
447+ name: nameValues.map[json["name"]],
448+ type: typeEnumValues.map[json["type"]]!,
449+ );
450+
451+ Map<String, dynamic> toJson() => {
452+ "declaration": declaration?.toJson(),
453+ "elementType": elementType?.toJson(),
454+ "name": nameValues.reverse[name],
455+ "type": typeEnumValues.reverse[type],
456+ };
457+}
458+
459+class IndexSignatureElement {
460+ final GetSignatureFlags flags;
461+ final int id;
462+ final int kind;
463+ final String kindString;
464+ final String name;
465+ final List<GetSignature>? parameters;
466+ final PurpleType type;
467+
468+ IndexSignatureElement({
469+ required this.flags,
470+ required this.id,
471+ required this.kind,
472+ required this.kindString,
473+ required this.name,
474+ this.parameters,
475+ required this.type,
476+ });
477+
478+ factory IndexSignatureElement.fromJson(Map<String, dynamic> json) => IndexSignatureElement(
479+ flags: GetSignatureFlags.fromJson(json["flags"]),
480+ id: json["id"],
481+ kind: json["kind"],
482+ kindString: json["kindString"],
483+ name: json["name"],
484+ parameters: json["parameters"] == null ? null : List<GetSignature>.from(json["parameters"]!.map((x) => GetSignature.fromJson(x))),
485+ type: PurpleType.fromJson(json["type"]),
486+ );
487+
488+ Map<String, dynamic> toJson() => {
489+ "flags": flags.toJson(),
490+ "id": id,
491+ "kind": kind,
492+ "kindString": kindString,
493+ "name": name,
494+ "parameters": parameters == null ? null : List<dynamic>.from(parameters!.map((x) => x.toJson())),
495+ "type": type.toJson(),
496+ };
497+}
498+
499+class PurpleType {
500+ final GetSignature? declaration;
501+ final Name? name;
502+ final TypeEnum type;
503+
504+ PurpleType({
505+ this.declaration,
506+ this.name,
507+ required this.type,
508+ });
509+
510+ factory PurpleType.fromJson(Map<String, dynamic> json) => PurpleType(
511+ declaration: json["declaration"] == null ? null : GetSignature.fromJson(json["declaration"]),
512+ name: nameValues.map[json["name"]],
513+ type: typeEnumValues.map[json["type"]]!,
514+ );
515+
516+ Map<String, dynamic> toJson() => {
517+ "declaration": declaration?.toJson(),
518+ "name": nameValues.reverse[name],
519+ "type": typeEnumValues.reverse[type],
520+ };
521+}
522+
523+class GetSignatureChild {
524+ final FluffyComment? comment;
525+ final FluffyFlags flags;
526+ final int id;
527+ final int kind;
528+ final PurpleKindString kindString;
529+ final String name;
530+ final List<Source> sources;
531+ final PurpleType type;
532+
533+ GetSignatureChild({
534+ this.comment,
535+ required this.flags,
536+ required this.id,
537+ required this.kind,
538+ required this.kindString,
539+ required this.name,
540+ required this.sources,
541+ required this.type,
542+ });
543+
544+ factory GetSignatureChild.fromJson(Map<String, dynamic> json) => GetSignatureChild(
545+ comment: json["comment"] == null ? null : FluffyComment.fromJson(json["comment"]),
546+ flags: FluffyFlags.fromJson(json["flags"]),
547+ id: json["id"],
548+ kind: json["kind"],
549+ kindString: purpleKindStringValues.map[json["kindString"]]!,
550+ name: json["name"],
551+ sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
552+ type: PurpleType.fromJson(json["type"]),
553+ );
554+
555+ Map<String, dynamic> toJson() => {
556+ "comment": comment?.toJson(),
557+ "flags": flags.toJson(),
558+ "id": id,
559+ "kind": kind,
560+ "kindString": purpleKindStringValues.reverse[kindString],
561+ "name": name,
562+ "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
563+ "type": type.toJson(),
564+ };
565+}
566+
567+class GetSignature {
568+ final List<GetSignatureChild>? children;
569+ final GetSignatureComment? comment;
570+ final String? defaultValue;
571+ final GetSignatureFlags flags;
572+ final List<Group>? groups;
573+ final int id;
574+ final int kind;
575+ final String kindString;
576+ final String name;
577+ final List<GetSignatureParameter>? parameters;
578+ final List<IndexSignatureElement>? signatures;
579+ final List<Source>? sources;
580+ final GetSignatureType? type;
581+ final List<GetSignature>? typeParameter;
582+
583+ GetSignature({
584+ this.children,
585+ this.comment,
586+ this.defaultValue,
587+ required this.flags,
588+ this.groups,
589+ required this.id,
590+ required this.kind,
591+ required this.kindString,
592+ required this.name,
593+ this.parameters,
594+ this.signatures,
595+ this.sources,
596+ this.type,
597+ this.typeParameter,
598+ });
599+
600+ factory GetSignature.fromJson(Map<String, dynamic> json) => GetSignature(
601+ children: json["children"] == null ? null : List<GetSignatureChild>.from(json["children"]!.map((x) => GetSignatureChild.fromJson(x))),
602+ comment: json["comment"] == null ? null : GetSignatureComment.fromJson(json["comment"]),
603+ defaultValue: json["defaultValue"],
604+ flags: GetSignatureFlags.fromJson(json["flags"]),
605+ groups: json["groups"] == null ? null : List<Group>.from(json["groups"]!.map((x) => Group.fromJson(x))),
606+ id: json["id"],
607+ kind: json["kind"],
608+ kindString: json["kindString"],
609+ name: json["name"],
610+ parameters: json["parameters"] == null ? null : List<GetSignatureParameter>.from(json["parameters"]!.map((x) => GetSignatureParameter.fromJson(x))),
611+ signatures: json["signatures"] == null ? null : List<IndexSignatureElement>.from(json["signatures"]!.map((x) => IndexSignatureElement.fromJson(x))),
612+ sources: json["sources"] == null ? null : List<Source>.from(json["sources"]!.map((x) => Source.fromJson(x))),
613+ type: json["type"] == null ? null : GetSignatureType.fromJson(json["type"]),
614+ typeParameter: json["typeParameter"] == null ? null : List<GetSignature>.from(json["typeParameter"]!.map((x) => GetSignature.fromJson(x))),
615+ );
616+
617+ Map<String, dynamic> toJson() => {
618+ "children": children == null ? null : List<dynamic>.from(children!.map((x) => x.toJson())),
619+ "comment": comment?.toJson(),
620+ "defaultValue": defaultValue,
621+ "flags": flags.toJson(),
622+ "groups": groups == null ? null : List<dynamic>.from(groups!.map((x) => x.toJson())),
623+ "id": id,
624+ "kind": kind,
625+ "kindString": kindString,
626+ "name": name,
627+ "parameters": parameters == null ? null : List<dynamic>.from(parameters!.map((x) => x.toJson())),
628+ "signatures": signatures == null ? null : List<dynamic>.from(signatures!.map((x) => x.toJson())),
629+ "sources": sources == null ? null : List<dynamic>.from(sources!.map((x) => x.toJson())),
630+ "type": type?.toJson(),
631+ "typeParameter": typeParameter == null ? null : List<dynamic>.from(typeParameter!.map((x) => x.toJson())),
632+ };
633+}
634+
635+class ElementType {
636+ final Name name;
637+ final TypeEnum type;
638+
639+ ElementType({
640+ required this.name,
641+ required this.type,
642+ });
643+
644+ factory ElementType.fromJson(Map<String, dynamic> json) => ElementType(
645+ name: nameValues.map[json["name"]]!,
646+ type: typeEnumValues.map[json["type"]]!,
647+ );
648+
649+ Map<String, dynamic> toJson() => {
650+ "name": nameValues.reverse[name],
651+ "type": typeEnumValues.reverse[type],
652+ };
653+}
654+
655+enum Name {
656+ STRING,
657+ NUMBER,
658+ VOID,
659+ T,
660+ BOOLEAN,
661+ BASE_CLASS,
662+ ANY,
663+ ARRAY,
664+ MY_NUMBER
665+}
666+
667+final nameValues = EnumValues({
668+ "string": Name.STRING,
669+ "number": Name.NUMBER,
670+ "void": Name.VOID,
671+ "T": Name.T,
672+ "boolean": Name.BOOLEAN,
673+ "BaseClass": Name.BASE_CLASS,
674+ "any": Name.ANY,
675+ "Array": Name.ARRAY,
676+ "MyNumber": Name.MY_NUMBER
677+});
678+
679+enum TypeEnum {
680+ INTRINSIC,
681+ REFLECTION,
682+ ARRAY,
683+ REFERENCE,
684+ TYPE_PARAMETER,
685+ TUPLE,
686+ UNION,
687+ STRING_LITERAL
688+}
689+
690+final typeEnumValues = EnumValues({
691+ "intrinsic": TypeEnum.INTRINSIC,
692+ "reflection": TypeEnum.REFLECTION,
693+ "array": TypeEnum.ARRAY,
694+ "reference": TypeEnum.REFERENCE,
695+ "typeParameter": TypeEnum.TYPE_PARAMETER,
696+ "tuple": TypeEnum.TUPLE,
697+ "union": TypeEnum.UNION,
698+ "stringLiteral": TypeEnum.STRING_LITERAL
699+});
700+
701+class FluffyComment {
702+ final String text;
703+
704+ FluffyComment({
705+ required this.text,
706+ });
707+
708+ factory FluffyComment.fromJson(Map<String, dynamic> json) => FluffyComment(
709+ text: json["text"],
710+ );
711+
712+ Map<String, dynamic> toJson() => {
713+ "text": text,
714+ };
715+}
716+
717+class FluffyFlags {
718+ final bool? isOptional;
719+
720+ FluffyFlags({
721+ this.isOptional,
722+ });
723+
724+ factory FluffyFlags.fromJson(Map<String, dynamic> json) => FluffyFlags(
725+ isOptional: json["isOptional"],
726+ );
727+
728+ Map<String, dynamic> toJson() => {
729+ "isOptional": isOptional,
730+ };
731+}
732+
733+class Source {
734+ final int character;
735+ final FileName fileName;
736+ final int line;
737+
738+ Source({
739+ required this.character,
740+ required this.fileName,
741+ required this.line,
742+ });
743+
744+ factory Source.fromJson(Map<String, dynamic> json) => Source(
745+ character: json["character"],
746+ fileName: fileNameValues.map[json["fileName"]]!,
747+ line: json["line"],
748+ );
749+
750+ Map<String, dynamic> toJson() => {
751+ "character": character,
752+ "fileName": fileNameValues.reverse[fileName],
753+ "line": line,
754+ };
755+}
756+
757+enum FileName {
758+ MODULES_TS,
759+ CLASSES_TS,
760+ FLATTENED_TS,
761+ ACCESS_TS,
762+ DEFAULT_EXPORT_TS,
763+ ENUMERATIONS_TS,
764+ FUNCTIONS_TS,
765+ GENERICS_TS,
766+ SINGLE_EXPORT_TS,
767+ TYPESCRIPT_13_TS,
768+ TYPESCRIPT_14_TS,
769+ TYPESCRIPT_15_TS,
770+ VARIABLES_TS
771+}
772+
773+final fileNameValues = EnumValues({
774+ "modules.ts": FileName.MODULES_TS,
775+ "classes.ts": FileName.CLASSES_TS,
776+ "flattened.ts": FileName.FLATTENED_TS,
777+ "access.ts": FileName.ACCESS_TS,
778+ "default-export.ts": FileName.DEFAULT_EXPORT_TS,
779+ "enumerations.ts": FileName.ENUMERATIONS_TS,
780+ "functions.ts": FileName.FUNCTIONS_TS,
781+ "generics.ts": FileName.GENERICS_TS,
782+ "single-export.ts": FileName.SINGLE_EXPORT_TS,
783+ "typescript-1.3.ts": FileName.TYPESCRIPT_13_TS,
784+ "typescript-1.4.ts": FileName.TYPESCRIPT_14_TS,
785+ "typescript-1.5.ts": FileName.TYPESCRIPT_15_TS,
786+ "variables.ts": FileName.VARIABLES_TS
787+});
788+
789+class GetSignatureComment {
790+ final String? returns;
791+ final String? shortText;
792+ final String? text;
793+
794+ GetSignatureComment({
795+ this.returns,
796+ this.shortText,
797+ this.text,
798+ });
799+
800+ factory GetSignatureComment.fromJson(Map<String, dynamic> json) => GetSignatureComment(
801+ returns: json["returns"],
802+ shortText: json["shortText"],
803+ text: json["text"],
804+ );
805+
806+ Map<String, dynamic> toJson() => {
807+ "returns": returns,
808+ "shortText": shortText,
809+ "text": text,
810+ };
811+}
812+
813+class Group {
814+ final List<int> children;
815+ final int kind;
816+ final String title;
817+
818+ Group({
819+ required this.children,
820+ required this.kind,
821+ required this.title,
822+ });
823+
824+ factory Group.fromJson(Map<String, dynamic> json) => Group(
825+ children: List<int>.from(json["children"].map((x) => x)),
826+ kind: json["kind"],
827+ title: json["title"],
828+ );
829+
830+ Map<String, dynamic> toJson() => {
831+ "children": List<dynamic>.from(children.map((x) => x)),
832+ "kind": kind,
833+ "title": title,
834+ };
835+}
836+
837+class GetSignatureParameter {
838+ final TentacledComment? comment;
839+ final TentacledFlags flags;
840+ final int id;
841+ final int kind;
842+ final ParameterKindString kindString;
843+ final String name;
844+ final FluffyType type;
845+
846+ GetSignatureParameter({
847+ this.comment,
848+ required this.flags,
849+ required this.id,
850+ required this.kind,
851+ required this.kindString,
852+ required this.name,
853+ required this.type,
854+ });
855+
856+ factory GetSignatureParameter.fromJson(Map<String, dynamic> json) => GetSignatureParameter(
857+ comment: json["comment"] == null ? null : TentacledComment.fromJson(json["comment"]),
858+ flags: TentacledFlags.fromJson(json["flags"]),
859+ id: json["id"],
860+ kind: json["kind"],
861+ kindString: parameterKindStringValues.map[json["kindString"]]!,
862+ name: json["name"],
863+ type: FluffyType.fromJson(json["type"]),
864+ );
865+
866+ Map<String, dynamic> toJson() => {
867+ "comment": comment?.toJson(),
868+ "flags": flags.toJson(),
869+ "id": id,
870+ "kind": kind,
871+ "kindString": parameterKindStringValues.reverse[kindString],
872+ "name": name,
873+ "type": type.toJson(),
874+ };
875+}
876+
877+class TentacledComment {
878+ final String? shortText;
879+ final String? text;
880+
881+ TentacledComment({
882+ this.shortText,
883+ this.text,
884+ });
885+
886+ factory TentacledComment.fromJson(Map<String, dynamic> json) => TentacledComment(
887+ shortText: json["shortText"],
888+ text: json["text"],
889+ );
890+
891+ Map<String, dynamic> toJson() => {
892+ "shortText": shortText,
893+ "text": text,
894+ };
895+}
896+
897+class TentacledFlags {
898+ final bool? isOptional;
899+ final bool? isRest;
900+
901+ TentacledFlags({
902+ this.isOptional,
903+ this.isRest,
904+ });
905+
906+ factory TentacledFlags.fromJson(Map<String, dynamic> json) => TentacledFlags(
907+ isOptional: json["isOptional"],
908+ isRest: json["isRest"],
909+ );
910+
911+ Map<String, dynamic> toJson() => {
912+ "isOptional": isOptional,
913+ "isRest": isRest,
914+ };
915+}
916+
917+enum ParameterKindString {
918+ PARAMETER
919+}
920+
921+final parameterKindStringValues = EnumValues({
922+ "Parameter": ParameterKindString.PARAMETER
923+});
924+
925+class FluffyType {
926+ final ElementType? elementType;
927+ final Name? name;
928+ final TypeEnum type;
929+ final List<ElementType>? typeArguments;
930+
931+ FluffyType({
932+ this.elementType,
933+ this.name,
934+ required this.type,
935+ this.typeArguments,
936+ });
937+
938+ factory FluffyType.fromJson(Map<String, dynamic> json) => FluffyType(
939+ elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]),
940+ name: nameValues.map[json["name"]],
941+ type: typeEnumValues.map[json["type"]]!,
942+ typeArguments: json["typeArguments"] == null ? null : List<ElementType>.from(json["typeArguments"]!.map((x) => ElementType.fromJson(x))),
943+ );
944+
945+ Map<String, dynamic> toJson() => {
946+ "elementType": elementType?.toJson(),
947+ "name": nameValues.reverse[name],
948+ "type": typeEnumValues.reverse[type],
949+ "typeArguments": typeArguments == null ? null : List<dynamic>.from(typeArguments!.map((x) => x.toJson())),
950+ };
951+}
952+
953+class TentacledType {
954+ final PurpleDeclaration? declaration;
955+ final Name? name;
956+ final TypeEnum type;
957+
958+ TentacledType({
959+ this.declaration,
960+ this.name,
961+ required this.type,
962+ });
963+
964+ factory TentacledType.fromJson(Map<String, dynamic> json) => TentacledType(
965+ declaration: json["declaration"] == null ? null : PurpleDeclaration.fromJson(json["declaration"]),
966+ name: nameValues.map[json["name"]],
967+ type: typeEnumValues.map[json["type"]]!,
968+ );
969+
970+ Map<String, dynamic> toJson() => {
971+ "declaration": declaration?.toJson(),
972+ "name": nameValues.reverse[name],
973+ "type": typeEnumValues.reverse[type],
974+ };
975+}
976+
977+class PurpleDeclaration {
978+ final List<GetSignature> children;
979+ final GetSignatureFlags flags;
980+ final List<Group> groups;
981+ final int id;
982+ final int kind;
983+ final String kindString;
984+ final String name;
985+
986+ PurpleDeclaration({
987+ required this.children,
988+ required this.flags,
989+ required this.groups,
990+ required this.id,
991+ required this.kind,
992+ required this.kindString,
993+ required this.name,
994+ });
995+
996+ factory PurpleDeclaration.fromJson(Map<String, dynamic> json) => PurpleDeclaration(
997+ children: List<GetSignature>.from(json["children"].map((x) => GetSignature.fromJson(x))),
998+ flags: GetSignatureFlags.fromJson(json["flags"]),
999+ groups: List<Group>.from(json["groups"].map((x) => Group.fromJson(x))),
1000+ id: json["id"],
1001+ kind: json["kind"],
1002+ kindString: json["kindString"],
1003+ name: json["name"],
1004+ );
1005+
1006+ Map<String, dynamic> toJson() => {
1007+ "children": List<dynamic>.from(children.map((x) => x.toJson())),
1008+ "flags": flags.toJson(),
1009+ "groups": List<dynamic>.from(groups.map((x) => x.toJson())),
1010+ "id": id,
1011+ "kind": kind,
1012+ "kindString": kindString,
1013+ "name": name,
1014+ };
1015+}
1016+
1017+class TypeElement {
1018+ final GetSignature? declaration;
1019+ final ElementType? elementType;
1020+ final Name? name;
1021+ final TypeEnum type;
1022+ final List<ElementType>? typeArguments;
1023+
1024+ TypeElement({
1025+ this.declaration,
1026+ this.elementType,
1027+ this.name,
1028+ required this.type,
1029+ this.typeArguments,
1030+ });
1031+
1032+ factory TypeElement.fromJson(Map<String, dynamic> json) => TypeElement(
1033+ declaration: json["declaration"] == null ? null : GetSignature.fromJson(json["declaration"]),
1034+ elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]),
1035+ name: nameValues.map[json["name"]],
1036+ type: typeEnumValues.map[json["type"]]!,
1037+ typeArguments: json["typeArguments"] == null ? null : List<ElementType>.from(json["typeArguments"]!.map((x) => ElementType.fromJson(x))),
1038+ );
1039+
1040+ Map<String, dynamic> toJson() => {
1041+ "declaration": declaration?.toJson(),
1042+ "elementType": elementType?.toJson(),
1043+ "name": nameValues.reverse[name],
1044+ "type": typeEnumValues.reverse[type],
1045+ "typeArguments": typeArguments == null ? null : List<dynamic>.from(typeArguments!.map((x) => x.toJson())),
1046+ };
1047+}
1048+
1049+class StickyComment {
1050+ final String? returns;
1051+ final String? shortText;
1052+ final List<Tag>? tags;
1053+ final String? text;
1054+
1055+ StickyComment({
1056+ this.returns,
1057+ this.shortText,
1058+ this.tags,
1059+ this.text,
1060+ });
1061+
1062+ factory StickyComment.fromJson(Map<String, dynamic> json) => StickyComment(
1063+ returns: json["returns"],
1064+ shortText: json["shortText"],
1065+ tags: json["tags"] == null ? null : List<Tag>.from(json["tags"]!.map((x) => Tag.fromJson(x))),
1066+ text: json["text"],
1067+ );
1068+
1069+ Map<String, dynamic> toJson() => {
1070+ "returns": returns,
1071+ "shortText": shortText,
1072+ "tags": tags == null ? null : List<dynamic>.from(tags!.map((x) => x.toJson())),
1073+ "text": text,
1074+ };
1075+}
1076+
1077+class Tag {
1078+ final String tag;
1079+ final String text;
1080+
1081+ Tag({
1082+ required this.tag,
1083+ required this.text,
1084+ });
1085+
1086+ factory Tag.fromJson(Map<String, dynamic> json) => Tag(
1087+ tag: json["tag"],
1088+ text: json["text"],
1089+ );
1090+
1091+ Map<String, dynamic> toJson() => {
1092+ "tag": tag,
1093+ "text": text,
1094+ };
1095+}
1096+
1097+class StickyFlags {
1098+ final bool? isAbstract;
1099+ final bool? isConstructorProperty;
1100+ final bool? isExported;
1101+ final bool? isPrivate;
1102+ final bool? isProtected;
1103+ final bool? isPublic;
1104+ final bool? isStatic;
1105+
1106+ StickyFlags({
1107+ this.isAbstract,
1108+ this.isConstructorProperty,
1109+ this.isExported,
1110+ this.isPrivate,
1111+ this.isProtected,
1112+ this.isPublic,
1113+ this.isStatic,
1114+ });
1115+
1116+ factory StickyFlags.fromJson(Map<String, dynamic> json) => StickyFlags(
1117+ isAbstract: json["isAbstract"],
1118+ isConstructorProperty: json["isConstructorProperty"],
1119+ isExported: json["isExported"],
1120+ isPrivate: json["isPrivate"],
1121+ isProtected: json["isProtected"],
1122+ isPublic: json["isPublic"],
1123+ isStatic: json["isStatic"],
1124+ );
1125+
1126+ Map<String, dynamic> toJson() => {
1127+ "isAbstract": isAbstract,
1128+ "isConstructorProperty": isConstructorProperty,
1129+ "isExported": isExported,
1130+ "isPrivate": isPrivate,
1131+ "isProtected": isProtected,
1132+ "isPublic": isPublic,
1133+ "isStatic": isStatic,
1134+ };
1135+}
1136+
1137+class ExtendedBy {
1138+ final ExtendedBy? constraint;
1139+ final int? id;
1140+ final String name;
1141+ final TypeEnum type;
1142+ final List<ExtendedBy>? typeArguments;
1143+
1144+ ExtendedBy({
1145+ this.constraint,
1146+ this.id,
1147+ required this.name,
1148+ required this.type,
1149+ this.typeArguments,
1150+ });
1151+
1152+ factory ExtendedBy.fromJson(Map<String, dynamic> json) => ExtendedBy(
1153+ constraint: json["constraint"] == null ? null : ExtendedBy.fromJson(json["constraint"]),
1154+ id: json["id"],
1155+ name: json["name"],
1156+ type: typeEnumValues.map[json["type"]]!,
1157+ typeArguments: json["typeArguments"] == null ? null : List<ExtendedBy>.from(json["typeArguments"]!.map((x) => ExtendedBy.fromJson(x))),
1158+ );
1159+
1160+ Map<String, dynamic> toJson() => {
1161+ "constraint": constraint?.toJson(),
1162+ "id": id,
1163+ "name": name,
1164+ "type": typeEnumValues.reverse[type],
1165+ "typeArguments": typeArguments == null ? null : List<dynamic>.from(typeArguments!.map((x) => x.toJson())),
1166+ };
1167+}
1168+
1169+class FluffySignature {
1170+ final StickyComment? comment;
1171+ final IndigoFlags flags;
1172+ final int id;
1173+ final ExtendedBy? implementationOf;
1174+ final ExtendedBy? inheritedFrom;
1175+ final int kind;
1176+ final SignatureKindString kindString;
1177+ final String name;
1178+ final ExtendedBy? overwrites;
1179+ final List<PurpleParameter>? parameters;
1180+ final ExtendedBy type;
1181+ final List<GetSignature>? typeParameter;
1182+
1183+ FluffySignature({
1184+ this.comment,
1185+ required this.flags,
1186+ required this.id,
1187+ this.implementationOf,
1188+ this.inheritedFrom,
1189+ required this.kind,
1190+ required this.kindString,
1191+ required this.name,
1192+ this.overwrites,
1193+ this.parameters,
1194+ required this.type,
1195+ this.typeParameter,
1196+ });
1197+
1198+ factory FluffySignature.fromJson(Map<String, dynamic> json) => FluffySignature(
1199+ comment: json["comment"] == null ? null : StickyComment.fromJson(json["comment"]),
1200+ flags: IndigoFlags.fromJson(json["flags"]),
1201+ id: json["id"],
1202+ implementationOf: json["implementationOf"] == null ? null : ExtendedBy.fromJson(json["implementationOf"]),
1203+ inheritedFrom: json["inheritedFrom"] == null ? null : ExtendedBy.fromJson(json["inheritedFrom"]),
1204+ kind: json["kind"],
1205+ kindString: signatureKindStringValues.map[json["kindString"]]!,
1206+ name: json["name"],
1207+ overwrites: json["overwrites"] == null ? null : ExtendedBy.fromJson(json["overwrites"]),
1208+ parameters: json["parameters"] == null ? null : List<PurpleParameter>.from(json["parameters"]!.map((x) => PurpleParameter.fromJson(x))),
1209+ type: ExtendedBy.fromJson(json["type"]),
1210+ typeParameter: json["typeParameter"] == null ? null : List<GetSignature>.from(json["typeParameter"]!.map((x) => GetSignature.fromJson(x))),
1211+ );
1212+
1213+ Map<String, dynamic> toJson() => {
1214+ "comment": comment?.toJson(),
1215+ "flags": flags.toJson(),
1216+ "id": id,
1217+ "implementationOf": implementationOf?.toJson(),
1218+ "inheritedFrom": inheritedFrom?.toJson(),
1219+ "kind": kind,
1220+ "kindString": signatureKindStringValues.reverse[kindString],
1221+ "name": name,
1222+ "overwrites": overwrites?.toJson(),
1223+ "parameters": parameters == null ? null : List<dynamic>.from(parameters!.map((x) => x.toJson())),
1224+ "type": type.toJson(),
1225+ "typeParameter": typeParameter == null ? null : List<dynamic>.from(typeParameter!.map((x) => x.toJson())),
1226+ };
1227+}
1228+
1229+class IndigoFlags {
1230+ final bool? isPrivate;
1231+ final bool? isProtected;
1232+
1233+ IndigoFlags({
1234+ this.isPrivate,
1235+ this.isProtected,
1236+ });
1237+
1238+ factory IndigoFlags.fromJson(Map<String, dynamic> json) => IndigoFlags(
1239+ isPrivate: json["isPrivate"],
1240+ isProtected: json["isProtected"],
1241+ );
1242+
1243+ Map<String, dynamic> toJson() => {
1244+ "isPrivate": isPrivate,
1245+ "isProtected": isProtected,
1246+ };
1247+}
1248+
1249+class PurpleParameter {
1250+ final TentacledComment? comment;
1251+ final GetSignatureFlags flags;
1252+ final int id;
1253+ final int kind;
1254+ final ParameterKindString kindString;
1255+ final String name;
1256+ final StickyType type;
1257+
1258+ PurpleParameter({
1259+ this.comment,
1260+ required this.flags,
1261+ required this.id,
1262+ required this.kind,
1263+ required this.kindString,
1264+ required this.name,
1265+ required this.type,
1266+ });
1267+
1268+ factory PurpleParameter.fromJson(Map<String, dynamic> json) => PurpleParameter(
1269+ comment: json["comment"] == null ? null : TentacledComment.fromJson(json["comment"]),
1270+ flags: GetSignatureFlags.fromJson(json["flags"]),
1271+ id: json["id"],
1272+ kind: json["kind"],
1273+ kindString: parameterKindStringValues.map[json["kindString"]]!,
1274+ name: json["name"],
1275+ type: StickyType.fromJson(json["type"]),
1276+ );
1277+
1278+ Map<String, dynamic> toJson() => {
1279+ "comment": comment?.toJson(),
1280+ "flags": flags.toJson(),
1281+ "id": id,
1282+ "kind": kind,
1283+ "kindString": parameterKindStringValues.reverse[kindString],
1284+ "name": name,
1285+ "type": type.toJson(),
1286+ };
1287+}
1288+
1289+class StickyType {
1290+ final ExtendedBy? constraint;
1291+ final GetSignature? declaration;
1292+ final ElementType? elementType;
1293+ final List<ExtendedBy>? elements;
1294+ final int? id;
1295+ final String? name;
1296+ final TypeEnum type;
1297+ final List<ElementType>? typeArguments;
1298+
1299+ StickyType({
1300+ this.constraint,
1301+ this.declaration,
1302+ this.elementType,
1303+ this.elements,
1304+ this.id,
1305+ this.name,
1306+ required this.type,
1307+ this.typeArguments,
1308+ });
1309+
1310+ factory StickyType.fromJson(Map<String, dynamic> json) => StickyType(
1311+ constraint: json["constraint"] == null ? null : ExtendedBy.fromJson(json["constraint"]),
1312+ declaration: json["declaration"] == null ? null : GetSignature.fromJson(json["declaration"]),
1313+ elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]),
1314+ elements: json["elements"] == null ? null : List<ExtendedBy>.from(json["elements"]!.map((x) => ExtendedBy.fromJson(x))),
1315+ id: json["id"],
1316+ name: json["name"],
1317+ type: typeEnumValues.map[json["type"]]!,
1318+ typeArguments: json["typeArguments"] == null ? null : List<ElementType>.from(json["typeArguments"]!.map((x) => ElementType.fromJson(x))),
1319+ );
1320+
1321+ Map<String, dynamic> toJson() => {
1322+ "constraint": constraint?.toJson(),
1323+ "declaration": declaration?.toJson(),
1324+ "elementType": elementType?.toJson(),
1325+ "elements": elements == null ? null : List<dynamic>.from(elements!.map((x) => x.toJson())),
1326+ "id": id,
1327+ "name": name,
1328+ "type": typeEnumValues.reverse[type],
1329+ "typeArguments": typeArguments == null ? null : List<dynamic>.from(typeArguments!.map((x) => x.toJson())),
1330+ };
1331+}
1332+
1333+class IndigoType {
1334+ final ExtendedBy? constraint;
1335+ final FluffyDeclaration? declaration;
1336+ final ExtendedBy? elementType;
1337+ final List<ElementType>? elements;
1338+ final int? id;
1339+ final String? name;
1340+ final TypeEnum type;
1341+ final List<PurpleTypeArgument>? typeArguments;
1342+ final List<TypeElement>? types;
1343+
1344+ IndigoType({
1345+ this.constraint,
1346+ this.declaration,
1347+ this.elementType,
1348+ this.elements,
1349+ this.id,
1350+ this.name,
1351+ required this.type,
1352+ this.typeArguments,
1353+ this.types,
1354+ });
1355+
1356+ factory IndigoType.fromJson(Map<String, dynamic> json) => IndigoType(
1357+ constraint: json["constraint"] == null ? null : ExtendedBy.fromJson(json["constraint"]),
1358+ declaration: json["declaration"] == null ? null : FluffyDeclaration.fromJson(json["declaration"]),
1359+ elementType: json["elementType"] == null ? null : ExtendedBy.fromJson(json["elementType"]),
1360+ elements: json["elements"] == null ? null : List<ElementType>.from(json["elements"]!.map((x) => ElementType.fromJson(x))),
1361+ id: json["id"],
1362+ name: json["name"],
1363+ type: typeEnumValues.map[json["type"]]!,
1364+ typeArguments: json["typeArguments"] == null ? null : List<PurpleTypeArgument>.from(json["typeArguments"]!.map((x) => PurpleTypeArgument.fromJson(x))),
1365+ types: json["types"] == null ? null : List<TypeElement>.from(json["types"]!.map((x) => TypeElement.fromJson(x))),
1366+ );
1367+
1368+ Map<String, dynamic> toJson() => {
1369+ "constraint": constraint?.toJson(),
1370+ "declaration": declaration?.toJson(),
1371+ "elementType": elementType?.toJson(),
1372+ "elements": elements == null ? null : List<dynamic>.from(elements!.map((x) => x.toJson())),
1373+ "id": id,
1374+ "name": name,
1375+ "type": typeEnumValues.reverse[type],
1376+ "typeArguments": typeArguments == null ? null : List<dynamic>.from(typeArguments!.map((x) => x.toJson())),
1377+ "types": types == null ? null : List<dynamic>.from(types!.map((x) => x.toJson())),
1378+ };
1379+}
1380+
1381+class FluffyDeclaration {
1382+ final List<StickyChild>? children;
1383+ final GetSignatureFlags flags;
1384+ final List<Group>? groups;
1385+ final int id;
1386+ final IndexSignature? indexSignature;
1387+ final int kind;
1388+ final String kindString;
1389+ final String name;
1390+ final List<TentacledSignature>? signatures;
1391+ final List<Source> sources;
1392+
1393+ FluffyDeclaration({
1394+ this.children,
1395+ required this.flags,
1396+ this.groups,
1397+ required this.id,
1398+ this.indexSignature,
1399+ required this.kind,
1400+ required this.kindString,
1401+ required this.name,
1402+ this.signatures,
1403+ required this.sources,
1404+ });
1405+
1406+ factory FluffyDeclaration.fromJson(Map<String, dynamic> json) => FluffyDeclaration(
1407+ children: json["children"] == null ? null : List<StickyChild>.from(json["children"]!.map((x) => StickyChild.fromJson(x))),
1408+ flags: GetSignatureFlags.fromJson(json["flags"]),
1409+ groups: json["groups"] == null ? null : List<Group>.from(json["groups"]!.map((x) => Group.fromJson(x))),
1410+ id: json["id"],
1411+ indexSignature: json["indexSignature"] == null ? null : IndexSignature.fromJson(json["indexSignature"]),
1412+ kind: json["kind"],
1413+ kindString: json["kindString"],
1414+ name: json["name"],
1415+ signatures: json["signatures"] == null ? null : List<TentacledSignature>.from(json["signatures"]!.map((x) => TentacledSignature.fromJson(x))),
1416+ sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
1417+ );
1418+
1419+ Map<String, dynamic> toJson() => {
1420+ "children": children == null ? null : List<dynamic>.from(children!.map((x) => x.toJson())),
1421+ "flags": flags.toJson(),
1422+ "groups": groups == null ? null : List<dynamic>.from(groups!.map((x) => x.toJson())),
1423+ "id": id,
1424+ "indexSignature": indexSignature?.toJson(),
1425+ "kind": kind,
1426+ "kindString": kindString,
1427+ "name": name,
1428+ "signatures": signatures == null ? null : List<dynamic>.from(signatures!.map((x) => x.toJson())),
1429+ "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
1430+ };
1431+}
1432+
1433+class StickyChild {
1434+ final FluffyComment? comment;
1435+ final FluffyFlags flags;
1436+ final int id;
1437+ final int kind;
1438+ final PurpleKindString kindString;
1439+ final String name;
1440+ final List<Source> sources;
1441+ final IndecentType type;
1442+
1443+ StickyChild({
1444+ this.comment,
1445+ required this.flags,
1446+ required this.id,
1447+ required this.kind,
1448+ required this.kindString,
1449+ required this.name,
1450+ required this.sources,
1451+ required this.type,
1452+ });
1453+
1454+ factory StickyChild.fromJson(Map<String, dynamic> json) => StickyChild(
1455+ comment: json["comment"] == null ? null : FluffyComment.fromJson(json["comment"]),
1456+ flags: FluffyFlags.fromJson(json["flags"]),
1457+ id: json["id"],
1458+ kind: json["kind"],
1459+ kindString: purpleKindStringValues.map[json["kindString"]]!,
1460+ name: json["name"],
1461+ sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
1462+ type: IndecentType.fromJson(json["type"]),
1463+ );
1464+
1465+ Map<String, dynamic> toJson() => {
1466+ "comment": comment?.toJson(),
1467+ "flags": flags.toJson(),
1468+ "id": id,
1469+ "kind": kind,
1470+ "kindString": purpleKindStringValues.reverse[kindString],
1471+ "name": name,
1472+ "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
1473+ "type": type.toJson(),
1474+ };
1475+}
1476+
1477+class IndecentType {
1478+ final GetSignature? declaration;
1479+ final List<ElementType>? elements;
1480+ final Name? name;
1481+ final TypeEnum type;
1482+
1483+ IndecentType({
1484+ this.declaration,
1485+ this.elements,
1486+ this.name,
1487+ required this.type,
1488+ });
1489+
1490+ factory IndecentType.fromJson(Map<String, dynamic> json) => IndecentType(
1491+ declaration: json["declaration"] == null ? null : GetSignature.fromJson(json["declaration"]),
1492+ elements: json["elements"] == null ? null : List<ElementType>.from(json["elements"]!.map((x) => ElementType.fromJson(x))),
1493+ name: nameValues.map[json["name"]],
1494+ type: typeEnumValues.map[json["type"]]!,
1495+ );
1496+
1497+ Map<String, dynamic> toJson() => {
1498+ "declaration": declaration?.toJson(),
1499+ "elements": elements == null ? null : List<dynamic>.from(elements!.map((x) => x.toJson())),
1500+ "name": nameValues.reverse[name],
1501+ "type": typeEnumValues.reverse[type],
1502+ };
1503+}
1504+
1505+class IndexSignature {
1506+ final GetSignatureFlags flags;
1507+ final int id;
1508+ final int kind;
1509+ final String kindString;
1510+ final String name;
1511+ final List<GetSignature> parameters;
1512+ final HilariousType type;
1513+
1514+ IndexSignature({
1515+ required this.flags,
1516+ required this.id,
1517+ required this.kind,
1518+ required this.kindString,
1519+ required this.name,
1520+ required this.parameters,
1521+ required this.type,
1522+ });
1523+
1524+ factory IndexSignature.fromJson(Map<String, dynamic> json) => IndexSignature(
1525+ flags: GetSignatureFlags.fromJson(json["flags"]),
1526+ id: json["id"],
1527+ kind: json["kind"],
1528+ kindString: json["kindString"],
1529+ name: json["name"],
1530+ parameters: List<GetSignature>.from(json["parameters"].map((x) => GetSignature.fromJson(x))),
1531+ type: HilariousType.fromJson(json["type"]),
1532+ );
1533+
1534+ Map<String, dynamic> toJson() => {
1535+ "flags": flags.toJson(),
1536+ "id": id,
1537+ "kind": kind,
1538+ "kindString": kindString,
1539+ "name": name,
1540+ "parameters": List<dynamic>.from(parameters.map((x) => x.toJson())),
1541+ "type": type.toJson(),
1542+ };
1543+}
1544+
1545+class HilariousType {
1546+ final GetSignature declaration;
1547+ final TypeEnum type;
1548+
1549+ HilariousType({
1550+ required this.declaration,
1551+ required this.type,
1552+ });
1553+
1554+ factory HilariousType.fromJson(Map<String, dynamic> json) => HilariousType(
1555+ declaration: GetSignature.fromJson(json["declaration"]),
1556+ type: typeEnumValues.map[json["type"]]!,
1557+ );
1558+
1559+ Map<String, dynamic> toJson() => {
1560+ "declaration": declaration.toJson(),
1561+ "type": typeEnumValues.reverse[type],
1562+ };
1563+}
1564+
1565+class TentacledSignature {
1566+ final IndigoComment? comment;
1567+ final GetSignatureFlags flags;
1568+ final int id;
1569+ final int kind;
1570+ final SignatureKindString kindString;
1571+ final String name;
1572+ final List<FluffyParameter>? parameters;
1573+ final ExtendedBy type;
1574+
1575+ TentacledSignature({
1576+ this.comment,
1577+ required this.flags,
1578+ required this.id,
1579+ required this.kind,
1580+ required this.kindString,
1581+ required this.name,
1582+ this.parameters,
1583+ required this.type,
1584+ });
1585+
1586+ factory TentacledSignature.fromJson(Map<String, dynamic> json) => TentacledSignature(
1587+ comment: json["comment"] == null ? null : IndigoComment.fromJson(json["comment"]),
1588+ flags: GetSignatureFlags.fromJson(json["flags"]),
1589+ id: json["id"],
1590+ kind: json["kind"],
1591+ kindString: signatureKindStringValues.map[json["kindString"]]!,
1592+ name: json["name"],
1593+ parameters: json["parameters"] == null ? null : List<FluffyParameter>.from(json["parameters"]!.map((x) => FluffyParameter.fromJson(x))),
1594+ type: ExtendedBy.fromJson(json["type"]),
1595+ );
1596+
1597+ Map<String, dynamic> toJson() => {
1598+ "comment": comment?.toJson(),
1599+ "flags": flags.toJson(),
1600+ "id": id,
1601+ "kind": kind,
1602+ "kindString": signatureKindStringValues.reverse[kindString],
1603+ "name": name,
1604+ "parameters": parameters == null ? null : List<dynamic>.from(parameters!.map((x) => x.toJson())),
1605+ "type": type.toJson(),
1606+ };
1607+}
1608+
1609+class IndigoComment {
1610+ final String returns;
1611+ final String shortText;
1612+
1613+ IndigoComment({
1614+ required this.returns,
1615+ required this.shortText,
1616+ });
1617+
1618+ factory IndigoComment.fromJson(Map<String, dynamic> json) => IndigoComment(
1619+ returns: json["returns"],
1620+ shortText: json["shortText"],
1621+ );
1622+
1623+ Map<String, dynamic> toJson() => {
1624+ "returns": returns,
1625+ "shortText": shortText,
1626+ };
1627+}
1628+
1629+class FluffyParameter {
1630+ final FluffyComment? comment;
1631+ final FluffyFlags flags;
1632+ final int id;
1633+ final int kind;
1634+ final String kindString;
1635+ final String name;
1636+ final List<Source>? sources;
1637+ final ElementType type;
1638+
1639+ FluffyParameter({
1640+ this.comment,
1641+ required this.flags,
1642+ required this.id,
1643+ required this.kind,
1644+ required this.kindString,
1645+ required this.name,
1646+ this.sources,
1647+ required this.type,
1648+ });
1649+
1650+ factory FluffyParameter.fromJson(Map<String, dynamic> json) => FluffyParameter(
1651+ comment: json["comment"] == null ? null : FluffyComment.fromJson(json["comment"]),
1652+ flags: FluffyFlags.fromJson(json["flags"]),
1653+ id: json["id"],
1654+ kind: json["kind"],
1655+ kindString: json["kindString"],
1656+ name: json["name"],
1657+ sources: json["sources"] == null ? null : List<Source>.from(json["sources"]!.map((x) => Source.fromJson(x))),
1658+ type: ElementType.fromJson(json["type"]),
1659+ );
1660+
1661+ Map<String, dynamic> toJson() => {
1662+ "comment": comment?.toJson(),
1663+ "flags": flags.toJson(),
1664+ "id": id,
1665+ "kind": kind,
1666+ "kindString": kindString,
1667+ "name": name,
1668+ "sources": sources == null ? null : List<dynamic>.from(sources!.map((x) => x.toJson())),
1669+ "type": type.toJson(),
1670+ };
1671+}
1672+
1673+class PurpleTypeArgument {
1674+ final ElementType target;
1675+ final String type;
1676+ final String typeArgumentOperator;
1677+
1678+ PurpleTypeArgument({
1679+ required this.target,
1680+ required this.type,
1681+ required this.typeArgumentOperator,
1682+ });
1683+
1684+ factory PurpleTypeArgument.fromJson(Map<String, dynamic> json) => PurpleTypeArgument(
1685+ target: ElementType.fromJson(json["target"]),
1686+ type: json["type"],
1687+ typeArgumentOperator: json["operator"],
1688+ );
1689+
1690+ Map<String, dynamic> toJson() => {
1691+ "target": target.toJson(),
1692+ "type": type,
1693+ "operator": typeArgumentOperator,
1694+ };
1695+}
1696+
1697+class IndecentFlags {
1698+ final bool? hasExportAssignment;
1699+ final bool? isAbstract;
1700+ final bool? isConst;
1701+ final bool? isExported;
1702+ final bool? isLet;
1703+ final bool? isPrivate;
1704+ final bool? isProtected;
1705+
1706+ IndecentFlags({
1707+ this.hasExportAssignment,
1708+ this.isAbstract,
1709+ this.isConst,
1710+ this.isExported,
1711+ this.isLet,
1712+ this.isPrivate,
1713+ this.isProtected,
1714+ });
1715+
1716+ factory IndecentFlags.fromJson(Map<String, dynamic> json) => IndecentFlags(
1717+ hasExportAssignment: json["hasExportAssignment"],
1718+ isAbstract: json["isAbstract"],
1719+ isConst: json["isConst"],
1720+ isExported: json["isExported"],
1721+ isLet: json["isLet"],
1722+ isPrivate: json["isPrivate"],
1723+ isProtected: json["isProtected"],
1724+ );
1725+
1726+ Map<String, dynamic> toJson() => {
1727+ "hasExportAssignment": hasExportAssignment,
1728+ "isAbstract": isAbstract,
1729+ "isConst": isConst,
1730+ "isExported": isExported,
1731+ "isLet": isLet,
1732+ "isPrivate": isPrivate,
1733+ "isProtected": isProtected,
1734+ };
1735+}
1736+
1737+enum FluffyKindString {
1738+ MODULE,
1739+ CLASS,
1740+ VARIABLE,
1741+ FUNCTION,
1742+ INTERFACE,
1743+ ENUMERATION,
1744+ OBJECT_LITERAL,
1745+ TYPE_ALIAS
1746+}
1747+
1748+final fluffyKindStringValues = EnumValues({
1749+ "Module": FluffyKindString.MODULE,
1750+ "Class": FluffyKindString.CLASS,
1751+ "Variable": FluffyKindString.VARIABLE,
1752+ "Function": FluffyKindString.FUNCTION,
1753+ "Interface": FluffyKindString.INTERFACE,
1754+ "Enumeration": FluffyKindString.ENUMERATION,
1755+ "Object literal": FluffyKindString.OBJECT_LITERAL,
1756+ "Type alias": FluffyKindString.TYPE_ALIAS
1757+});
1758+
1759+class StickySignature {
1760+ final StickyComment comment;
1761+ final IndigoFlags flags;
1762+ final int id;
1763+ final int kind;
1764+ final SignatureKindString kindString;
1765+ final String name;
1766+ final List<TentacledParameter>? parameters;
1767+ final CunningType type;
1768+ final List<GetSignature>? typeParameter;
1769+
1770+ StickySignature({
1771+ required this.comment,
1772+ required this.flags,
1773+ required this.id,
1774+ required this.kind,
1775+ required this.kindString,
1776+ required this.name,
1777+ this.parameters,
1778+ required this.type,
1779+ this.typeParameter,
1780+ });
1781+
1782+ factory StickySignature.fromJson(Map<String, dynamic> json) => StickySignature(
1783+ comment: StickyComment.fromJson(json["comment"]),
1784+ flags: IndigoFlags.fromJson(json["flags"]),
1785+ id: json["id"],
1786+ kind: json["kind"],
1787+ kindString: signatureKindStringValues.map[json["kindString"]]!,
1788+ name: json["name"],
1789+ parameters: json["parameters"] == null ? null : List<TentacledParameter>.from(json["parameters"]!.map((x) => TentacledParameter.fromJson(x))),
1790+ type: CunningType.fromJson(json["type"]),
1791+ typeParameter: json["typeParameter"] == null ? null : List<GetSignature>.from(json["typeParameter"]!.map((x) => GetSignature.fromJson(x))),
1792+ );
1793+
1794+ Map<String, dynamic> toJson() => {
1795+ "comment": comment.toJson(),
1796+ "flags": flags.toJson(),
1797+ "id": id,
1798+ "kind": kind,
1799+ "kindString": signatureKindStringValues.reverse[kindString],
1800+ "name": name,
1801+ "parameters": parameters == null ? null : List<dynamic>.from(parameters!.map((x) => x.toJson())),
1802+ "type": type.toJson(),
1803+ "typeParameter": typeParameter == null ? null : List<dynamic>.from(typeParameter!.map((x) => x.toJson())),
1804+ };
1805+}
1806+
1807+class TentacledParameter {
1808+ final TentacledComment? comment;
1809+ final String? defaultValue;
1810+ final TentacledFlags flags;
1811+ final int id;
1812+ final int kind;
1813+ final ParameterKindString kindString;
1814+ final String name;
1815+ final String? originalName;
1816+ final AmbitiousType type;
1817+
1818+ TentacledParameter({
1819+ this.comment,
1820+ this.defaultValue,
1821+ required this.flags,
1822+ required this.id,
1823+ required this.kind,
1824+ required this.kindString,
1825+ required this.name,
1826+ this.originalName,
1827+ required this.type,
1828+ });
1829+
1830+ factory TentacledParameter.fromJson(Map<String, dynamic> json) => TentacledParameter(
1831+ comment: json["comment"] == null ? null : TentacledComment.fromJson(json["comment"]),
1832+ defaultValue: json["defaultValue"],
1833+ flags: TentacledFlags.fromJson(json["flags"]),
1834+ id: json["id"],
1835+ kind: json["kind"],
1836+ kindString: parameterKindStringValues.map[json["kindString"]]!,
1837+ name: json["name"],
1838+ originalName: json["originalName"],
1839+ type: AmbitiousType.fromJson(json["type"]),
1840+ );
1841+
1842+ Map<String, dynamic> toJson() => {
1843+ "comment": comment?.toJson(),
1844+ "defaultValue": defaultValue,
1845+ "flags": flags.toJson(),
1846+ "id": id,
1847+ "kind": kind,
1848+ "kindString": parameterKindStringValues.reverse[kindString],
1849+ "name": name,
1850+ "originalName": originalName,
1851+ "type": type.toJson(),
1852+ };
1853+}
1854+
1855+class AmbitiousType {
1856+ final TentacledDeclaration? declaration;
1857+ final ElementType? elementType;
1858+ final int? id;
1859+ final String? name;
1860+ final TypeEnum type;
1861+ final List<ElementType>? typeArguments;
1862+
1863+ AmbitiousType({
1864+ this.declaration,
1865+ this.elementType,
1866+ this.id,
1867+ this.name,
1868+ required this.type,
1869+ this.typeArguments,
1870+ });
1871+
1872+ factory AmbitiousType.fromJson(Map<String, dynamic> json) => AmbitiousType(
1873+ declaration: json["declaration"] == null ? null : TentacledDeclaration.fromJson(json["declaration"]),
1874+ elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]),
1875+ id: json["id"],
1876+ name: json["name"],
1877+ type: typeEnumValues.map[json["type"]]!,
1878+ typeArguments: json["typeArguments"] == null ? null : List<ElementType>.from(json["typeArguments"]!.map((x) => ElementType.fromJson(x))),
1879+ );
1880+
1881+ Map<String, dynamic> toJson() => {
1882+ "declaration": declaration?.toJson(),
1883+ "elementType": elementType?.toJson(),
1884+ "id": id,
1885+ "name": name,
1886+ "type": typeEnumValues.reverse[type],
1887+ "typeArguments": typeArguments == null ? null : List<dynamic>.from(typeArguments!.map((x) => x.toJson())),
1888+ };
1889+}
1890+
1891+class TentacledDeclaration {
1892+ final List<IndigoChild>? children;
1893+ final GetSignatureFlags flags;
1894+ final List<Group>? groups;
1895+ final int id;
1896+ final IndexSignatureElement? indexSignature;
1897+ final int kind;
1898+ final String kindString;
1899+ final String name;
1900+ final List<GetSignature>? signatures;
1901+ final List<Source> sources;
1902+
1903+ TentacledDeclaration({
1904+ this.children,
1905+ required this.flags,
1906+ this.groups,
1907+ required this.id,
1908+ this.indexSignature,
1909+ required this.kind,
1910+ required this.kindString,
1911+ required this.name,
1912+ this.signatures,
1913+ required this.sources,
1914+ });
1915+
1916+ factory TentacledDeclaration.fromJson(Map<String, dynamic> json) => TentacledDeclaration(
1917+ children: json["children"] == null ? null : List<IndigoChild>.from(json["children"]!.map((x) => IndigoChild.fromJson(x))),
1918+ flags: GetSignatureFlags.fromJson(json["flags"]),
1919+ groups: json["groups"] == null ? null : List<Group>.from(json["groups"]!.map((x) => Group.fromJson(x))),
1920+ id: json["id"],
1921+ indexSignature: json["indexSignature"] == null ? null : IndexSignatureElement.fromJson(json["indexSignature"]),
1922+ kind: json["kind"],
1923+ kindString: json["kindString"],
1924+ name: json["name"],
1925+ signatures: json["signatures"] == null ? null : List<GetSignature>.from(json["signatures"]!.map((x) => GetSignature.fromJson(x))),
1926+ sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
1927+ );
1928+
1929+ Map<String, dynamic> toJson() => {
1930+ "children": children == null ? null : List<dynamic>.from(children!.map((x) => x.toJson())),
1931+ "flags": flags.toJson(),
1932+ "groups": groups == null ? null : List<dynamic>.from(groups!.map((x) => x.toJson())),
1933+ "id": id,
1934+ "indexSignature": indexSignature?.toJson(),
1935+ "kind": kind,
1936+ "kindString": kindString,
1937+ "name": name,
1938+ "signatures": signatures == null ? null : List<dynamic>.from(signatures!.map((x) => x.toJson())),
1939+ "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
1940+ };
1941+}
1942+
1943+class IndigoChild {
1944+ final FluffyComment comment;
1945+ final String? defaultValue;
1946+ final FluffyFlags flags;
1947+ final int id;
1948+ final int kind;
1949+ final PurpleKindString kindString;
1950+ final String name;
1951+ final List<Source> sources;
1952+ final IndecentType type;
1953+
1954+ IndigoChild({
1955+ required this.comment,
1956+ this.defaultValue,
1957+ required this.flags,
1958+ required this.id,
1959+ required this.kind,
1960+ required this.kindString,
1961+ required this.name,
1962+ required this.sources,
1963+ required this.type,
1964+ });
1965+
1966+ factory IndigoChild.fromJson(Map<String, dynamic> json) => IndigoChild(
1967+ comment: FluffyComment.fromJson(json["comment"]),
1968+ defaultValue: json["defaultValue"],
1969+ flags: FluffyFlags.fromJson(json["flags"]),
1970+ id: json["id"],
1971+ kind: json["kind"],
1972+ kindString: purpleKindStringValues.map[json["kindString"]]!,
1973+ name: json["name"],
1974+ sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
1975+ type: IndecentType.fromJson(json["type"]),
1976+ );
1977+
1978+ Map<String, dynamic> toJson() => {
1979+ "comment": comment.toJson(),
1980+ "defaultValue": defaultValue,
1981+ "flags": flags.toJson(),
1982+ "id": id,
1983+ "kind": kind,
1984+ "kindString": purpleKindStringValues.reverse[kindString],
1985+ "name": name,
1986+ "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
1987+ "type": type.toJson(),
1988+ };
1989+}
1990+
1991+class CunningType {
1992+ final PurpleDeclaration? declaration;
1993+ final int? id;
1994+ final Name? name;
1995+ final TypeEnum type;
1996+ final List<ElementType>? typeArguments;
1997+
1998+ CunningType({
1999+ this.declaration,
2000+ this.id,
2001+ this.name,
2002+ required this.type,
2003+ this.typeArguments,
2004+ });
2005+
2006+ factory CunningType.fromJson(Map<String, dynamic> json) => CunningType(
2007+ declaration: json["declaration"] == null ? null : PurpleDeclaration.fromJson(json["declaration"]),
2008+ id: json["id"],
2009+ name: nameValues.map[json["name"]],
2010+ type: typeEnumValues.map[json["type"]]!,
2011+ typeArguments: json["typeArguments"] == null ? null : List<ElementType>.from(json["typeArguments"]!.map((x) => ElementType.fromJson(x))),
2012+ );
2013+
2014+ Map<String, dynamic> toJson() => {
2015+ "declaration": declaration?.toJson(),
2016+ "id": id,
2017+ "name": nameValues.reverse[name],
2018+ "type": typeEnumValues.reverse[type],
2019+ "typeArguments": typeArguments == null ? null : List<dynamic>.from(typeArguments!.map((x) => x.toJson())),
2020+ };
2021+}
2022+
2023+class MagentaType {
2024+ final StickyDeclaration? declaration;
2025+ final ElementType? elementType;
2026+ final List<ExtendedBy>? elements;
2027+ final int? id;
2028+ final String? name;
2029+ final TypeEnum type;
2030+ final List<FluffyTypeArgument>? typeArguments;
2031+ final List<ExtendedBy>? types;
2032+ final String? value;
2033+
2034+ MagentaType({
2035+ this.declaration,
2036+ this.elementType,
2037+ this.elements,
2038+ this.id,
2039+ this.name,
2040+ required this.type,
2041+ this.typeArguments,
2042+ this.types,
2043+ this.value,
2044+ });
2045+
2046+ factory MagentaType.fromJson(Map<String, dynamic> json) => MagentaType(
2047+ declaration: json["declaration"] == null ? null : StickyDeclaration.fromJson(json["declaration"]),
2048+ elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]),
2049+ elements: json["elements"] == null ? null : List<ExtendedBy>.from(json["elements"]!.map((x) => ExtendedBy.fromJson(x))),
2050+ id: json["id"],
2051+ name: json["name"],
2052+ type: typeEnumValues.map[json["type"]]!,
2053+ typeArguments: json["typeArguments"] == null ? null : List<FluffyTypeArgument>.from(json["typeArguments"]!.map((x) => FluffyTypeArgument.fromJson(x))),
2054+ types: json["types"] == null ? null : List<ExtendedBy>.from(json["types"]!.map((x) => ExtendedBy.fromJson(x))),
2055+ value: json["value"],
2056+ );
2057+
2058+ Map<String, dynamic> toJson() => {
2059+ "declaration": declaration?.toJson(),
2060+ "elementType": elementType?.toJson(),
2061+ "elements": elements == null ? null : List<dynamic>.from(elements!.map((x) => x.toJson())),
2062+ "id": id,
2063+ "name": name,
2064+ "type": typeEnumValues.reverse[type],
2065+ "typeArguments": typeArguments == null ? null : List<dynamic>.from(typeArguments!.map((x) => x.toJson())),
2066+ "types": types == null ? null : List<dynamic>.from(types!.map((x) => x.toJson())),
2067+ "value": value,
2068+ };
2069+}
2070+
2071+class StickyDeclaration {
2072+ final List<IndecentChild>? children;
2073+ final GetSignatureFlags flags;
2074+ final List<Group>? groups;
2075+ final int id;
2076+ final int kind;
2077+ final String kindString;
2078+ final String name;
2079+ final List<GetSignature> signatures;
2080+ final List<Source> sources;
2081+
2082+ StickyDeclaration({
2083+ this.children,
2084+ required this.flags,
2085+ this.groups,
2086+ required this.id,
2087+ required this.kind,
2088+ required this.kindString,
2089+ required this.name,
2090+ required this.signatures,
2091+ required this.sources,
2092+ });
2093+
2094+ factory StickyDeclaration.fromJson(Map<String, dynamic> json) => StickyDeclaration(
2095+ children: json["children"] == null ? null : List<IndecentChild>.from(json["children"]!.map((x) => IndecentChild.fromJson(x))),
2096+ flags: GetSignatureFlags.fromJson(json["flags"]),
2097+ groups: json["groups"] == null ? null : List<Group>.from(json["groups"]!.map((x) => Group.fromJson(x))),
2098+ id: json["id"],
2099+ kind: json["kind"],
2100+ kindString: json["kindString"],
2101+ name: json["name"],
2102+ signatures: List<GetSignature>.from(json["signatures"].map((x) => GetSignature.fromJson(x))),
2103+ sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
2104+ );
2105+
2106+ Map<String, dynamic> toJson() => {
2107+ "children": children == null ? null : List<dynamic>.from(children!.map((x) => x.toJson())),
2108+ "flags": flags.toJson(),
2109+ "groups": groups == null ? null : List<dynamic>.from(groups!.map((x) => x.toJson())),
2110+ "id": id,
2111+ "kind": kind,
2112+ "kindString": kindString,
2113+ "name": name,
2114+ "signatures": List<dynamic>.from(signatures.map((x) => x.toJson())),
2115+ "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
2116+ };
2117+}
2118+
2119+class IndecentChild {
2120+ final FluffyFlags flags;
2121+ final int id;
2122+ final int kind;
2123+ final PurpleKindString kindString;
2124+ final String name;
2125+ final List<Source> sources;
2126+ final FriskyType type;
2127+
2128+ IndecentChild({
2129+ required this.flags,
2130+ required this.id,
2131+ required this.kind,
2132+ required this.kindString,
2133+ required this.name,
2134+ required this.sources,
2135+ required this.type,
2136+ });
2137+
2138+ factory IndecentChild.fromJson(Map<String, dynamic> json) => IndecentChild(
2139+ flags: FluffyFlags.fromJson(json["flags"]),
2140+ id: json["id"],
2141+ kind: json["kind"],
2142+ kindString: purpleKindStringValues.map[json["kindString"]]!,
2143+ name: json["name"],
2144+ sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
2145+ type: FriskyType.fromJson(json["type"]),
2146+ );
2147+
2148+ Map<String, dynamic> toJson() => {
2149+ "flags": flags.toJson(),
2150+ "id": id,
2151+ "kind": kind,
2152+ "kindString": purpleKindStringValues.reverse[kindString],
2153+ "name": name,
2154+ "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
2155+ "type": type.toJson(),
2156+ };
2157+}
2158+
2159+class FriskyType {
2160+ final IndigoDeclaration? declaration;
2161+ final Name? name;
2162+ final TypeEnum type;
2163+
2164+ FriskyType({
2165+ this.declaration,
2166+ this.name,
2167+ required this.type,
2168+ });
2169+
2170+ factory FriskyType.fromJson(Map<String, dynamic> json) => FriskyType(
2171+ declaration: json["declaration"] == null ? null : IndigoDeclaration.fromJson(json["declaration"]),
2172+ name: nameValues.map[json["name"]],
2173+ type: typeEnumValues.map[json["type"]]!,
2174+ );
2175+
2176+ Map<String, dynamic> toJson() => {
2177+ "declaration": declaration?.toJson(),
2178+ "name": nameValues.reverse[name],
2179+ "type": typeEnumValues.reverse[type],
2180+ };
2181+}
2182+
2183+class IndigoDeclaration {
2184+ final List<GetSignature>? children;
2185+ final GetSignatureFlags flags;
2186+ final List<Group>? groups;
2187+ final int id;
2188+ final int kind;
2189+ final String kindString;
2190+ final String name;
2191+ final List<GetSignature>? signatures;
2192+ final List<Source> sources;
2193+
2194+ IndigoDeclaration({
2195+ this.children,
2196+ required this.flags,
2197+ this.groups,
2198+ required this.id,
2199+ required this.kind,
2200+ required this.kindString,
2201+ required this.name,
2202+ this.signatures,
2203+ required this.sources,
2204+ });
2205+
2206+ factory IndigoDeclaration.fromJson(Map<String, dynamic> json) => IndigoDeclaration(
2207+ children: json["children"] == null ? null : List<GetSignature>.from(json["children"]!.map((x) => GetSignature.fromJson(x))),
2208+ flags: GetSignatureFlags.fromJson(json["flags"]),
2209+ groups: json["groups"] == null ? null : List<Group>.from(json["groups"]!.map((x) => Group.fromJson(x))),
2210+ id: json["id"],
2211+ kind: json["kind"],
2212+ kindString: json["kindString"],
2213+ name: json["name"],
2214+ signatures: json["signatures"] == null ? null : List<GetSignature>.from(json["signatures"]!.map((x) => GetSignature.fromJson(x))),
2215+ sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
2216+ );
2217+
2218+ Map<String, dynamic> toJson() => {
2219+ "children": children == null ? null : List<dynamic>.from(children!.map((x) => x.toJson())),
2220+ "flags": flags.toJson(),
2221+ "groups": groups == null ? null : List<dynamic>.from(groups!.map((x) => x.toJson())),
2222+ "id": id,
2223+ "kind": kind,
2224+ "kindString": kindString,
2225+ "name": name,
2226+ "signatures": signatures == null ? null : List<dynamic>.from(signatures!.map((x) => x.toJson())),
2227+ "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
2228+ };
2229+}
2230+
2231+class FluffyTypeArgument {
2232+ final TypeEnum type;
2233+ final List<ElementType> types;
2234+
2235+ FluffyTypeArgument({
2236+ required this.type,
2237+ required this.types,
2238+ });
2239+
2240+ factory FluffyTypeArgument.fromJson(Map<String, dynamic> json) => FluffyTypeArgument(
2241+ type: typeEnumValues.map[json["type"]]!,
2242+ types: List<ElementType>.from(json["types"].map((x) => ElementType.fromJson(x))),
2243+ );
2244+
2245+ Map<String, dynamic> toJson() => {
2246+ "type": typeEnumValues.reverse[type],
2247+ "types": List<dynamic>.from(types.map((x) => x.toJson())),
2248+ };
2249+}
2250+
2251+class TypeParameter {
2252+ final PurpleComment? comment;
2253+ final GetSignatureFlags flags;
2254+ final int id;
2255+ final int kind;
2256+ final String kindString;
2257+ final String name;
2258+ final MischievousType? type;
2259+
2260+ TypeParameter({
2261+ this.comment,
2262+ required this.flags,
2263+ required this.id,
2264+ required this.kind,
2265+ required this.kindString,
2266+ required this.name,
2267+ this.type,
2268+ });
2269+
2270+ factory TypeParameter.fromJson(Map<String, dynamic> json) => TypeParameter(
2271+ comment: json["comment"] == null ? null : PurpleComment.fromJson(json["comment"]),
2272+ flags: GetSignatureFlags.fromJson(json["flags"]),
2273+ id: json["id"],
2274+ kind: json["kind"],
2275+ kindString: json["kindString"],
2276+ name: json["name"],
2277+ type: json["type"] == null ? null : MischievousType.fromJson(json["type"]),
2278+ );
2279+
2280+ Map<String, dynamic> toJson() => {
2281+ "comment": comment?.toJson(),
2282+ "flags": flags.toJson(),
2283+ "id": id,
2284+ "kind": kind,
2285+ "kindString": kindString,
2286+ "name": name,
2287+ "type": type?.toJson(),
2288+ };
2289+}
2290+
2291+class MischievousType {
2292+ final int? id;
2293+ final Name? name;
2294+ final ElementType? target;
2295+ final String type;
2296+ final String? typeOperator;
2297+
2298+ MischievousType({
2299+ this.id,
2300+ this.name,
2301+ this.target,
2302+ required this.type,
2303+ this.typeOperator,
2304+ });
2305+
2306+ factory MischievousType.fromJson(Map<String, dynamic> json) => MischievousType(
2307+ id: json["id"],
2308+ name: nameValues.map[json["name"]],
2309+ target: json["target"] == null ? null : ElementType.fromJson(json["target"]),
2310+ type: json["type"],
2311+ typeOperator: json["operator"],
2312+ );
2313+
2314+ Map<String, dynamic> toJson() => {
2315+ "id": id,
2316+ "name": nameValues.reverse[name],
2317+ "target": target?.toJson(),
2318+ "type": type,
2319+ "operator": typeOperator,
2320+ };
2321+}
2322+
2323+class IndecentComment {
2324+ final String shortText;
2325+ final List<Tag>? tags;
2326+
2327+ IndecentComment({
2328+ required this.shortText,
2329+ this.tags,
2330+ });
2331+
2332+ factory IndecentComment.fromJson(Map<String, dynamic> json) => IndecentComment(
2333+ shortText: json["shortText"],
2334+ tags: json["tags"] == null ? null : List<Tag>.from(json["tags"]!.map((x) => Tag.fromJson(x))),
2335+ );
2336+
2337+ Map<String, dynamic> toJson() => {
2338+ "shortText": shortText,
2339+ "tags": tags == null ? null : List<dynamic>.from(tags!.map((x) => x.toJson())),
2340+ };
2341+}
2342+
2343+enum TentacledKindString {
2344+ EXTERNAL_MODULE
2345+}
2346+
2347+final tentacledKindStringValues = EnumValues({
2348+ "External module": TentacledKindString.EXTERNAL_MODULE
2349+});
2350+
2351+class EnumValues<T> {
2352+ Map<String, T> map;
2353+ late Map<T, String> reverseMap;
2354+
2355+ EnumValues(this.map);
2356+
2357+ Map<T, String> get reverse {
2358+ reverseMap = map.map((k, v) => MapEntry(v, k));
2359+ return reverseMap;
2360+ }
2361+}
Test case

test/inputs/json/priority/combinations3.json

2 generated files · +3,074 −0
Adartdefault / TopLevel.dart+1,537 −0
@@ -0,0 +1,1537 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final List<dynamic> juror;
13+ final List<dynamic> kongoni;
14+ final List<dynamic> ladronism;
15+ final List<dynamic> landlubberly;
16+ final List<dynamic> listener;
17+ final List<dynamic> lupus;
18+ final List<Maslin> maslin;
19+ final List<dynamic> monazite;
20+ final List<dynamic> monoliteral;
21+ final List<dynamic> monotheistically;
22+ final List<dynamic> montage;
23+ final List<dynamic> moralness;
24+ final List<MonaziteClass?> mowra;
25+ final List<dynamic> mulishly;
26+ final List<dynamic> myoscope;
27+ final List<List<int?>?> nach;
28+ final List<dynamic> neuromastic;
29+ final List<Noncontributing> noncontributing;
30+ final List<dynamic> nonnervous;
31+ final List<dynamic> nonvaluation;
32+ final List<dynamic> occupationalist;
33+ final List<dynamic> outrival;
34+ final List<dynamic> paleographically;
35+ final List<dynamic> pamphletwise;
36+ final List<dynamic> pediatrics;
37+ final List<bool> perceptive;
38+ final List<dynamic> piaculum;
39+ final List<dynamic> piccadilly;
40+ final List<dynamic> piffler;
41+ final List<dynamic> pithful;
42+ final List<dynamic> placuntitis;
43+ final List<dynamic> plectopterous;
44+ final List<Pneumocele?> pneumocele;
45+ final List<dynamic> poliorcetic;
46+ final List<dynamic> poormaster;
47+ final List<dynamic> potwhisky;
48+ final List<dynamic> practicalizer;
49+ final List<dynamic> prefreshman;
50+ final List<dynamic> prehensility;
51+ final List<dynamic> prevoidance;
52+ final List<Map<String, int?>> probant;
53+ final List<dynamic> protext;
54+
55+ TopLevel({
56+ required this.juror,
57+ required this.kongoni,
58+ required this.ladronism,
59+ required this.landlubberly,
60+ required this.listener,
61+ required this.lupus,
62+ required this.maslin,
63+ required this.monazite,
64+ required this.monoliteral,
65+ required this.monotheistically,
66+ required this.montage,
67+ required this.moralness,
68+ required this.mowra,
69+ required this.mulishly,
70+ required this.myoscope,
71+ required this.nach,
72+ required this.neuromastic,
73+ required this.noncontributing,
74+ required this.nonnervous,
75+ required this.nonvaluation,
76+ required this.occupationalist,
77+ required this.outrival,
78+ required this.paleographically,
79+ required this.pamphletwise,
80+ required this.pediatrics,
81+ required this.perceptive,
82+ required this.piaculum,
83+ required this.piccadilly,
84+ required this.piffler,
85+ required this.pithful,
86+ required this.placuntitis,
87+ required this.plectopterous,
88+ required this.pneumocele,
89+ required this.poliorcetic,
90+ required this.poormaster,
91+ required this.potwhisky,
92+ required this.practicalizer,
93+ required this.prefreshman,
94+ required this.prehensility,
95+ required this.prevoidance,
96+ required this.probant,
97+ required this.protext,
98+ });
99+
100+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
101+ juror: List<dynamic>.from(json["juror"].map((x) => x)),
102+ kongoni: List<dynamic>.from(json["kongoni"].map((x) => x)),
103+ ladronism: List<dynamic>.from(json["ladronism"].map((x) => x)),
104+ landlubberly: List<dynamic>.from(json["landlubberly"].map((x) => x)),
105+ listener: List<dynamic>.from(json["listener"].map((x) => x)),
106+ lupus: List<dynamic>.from(json["lupus"].map((x) => x)),
107+ maslin: List<Maslin>.from(json["maslin"].map((x) => Maslin.fromJson(x))),
108+ monazite: List<dynamic>.from(json["monazite"].map((x) => x)),
109+ monoliteral: List<dynamic>.from(json["monoliteral"].map((x) => x)),
110+ monotheistically: List<dynamic>.from(json["monotheistically"].map((x) => x)),
111+ montage: List<dynamic>.from(json["montage"].map((x) => x)),
112+ moralness: List<dynamic>.from(json["moralness"].map((x) => x)),
113+ mowra: List<MonaziteClass?>.from(json["mowra"].map((x) => x == null ? null : MonaziteClass.fromJson(x))),
114+ mulishly: List<dynamic>.from(json["mulishly"].map((x) => x)),
115+ myoscope: List<dynamic>.from(json["myoscope"].map((x) => x)),
116+ nach: List<List<int?>?>.from(json["nach"].map((x) => x == null ? null : List<int?>.from(x!.map((x) => x)))),
117+ neuromastic: List<dynamic>.from(json["neuromastic"].map((x) => x)),
118+ noncontributing: List<Noncontributing>.from(json["noncontributing"].map((x) => Noncontributing.fromJson(x))),
119+ nonnervous: List<dynamic>.from(json["nonnervous"].map((x) => x)),
120+ nonvaluation: List<dynamic>.from(json["nonvaluation"].map((x) => x)),
121+ occupationalist: List<dynamic>.from(json["occupationalist"].map((x) => x)),
122+ outrival: List<dynamic>.from(json["outrival"].map((x) => x)),
123+ paleographically: List<dynamic>.from(json["paleographically"].map((x) => x)),
124+ pamphletwise: List<dynamic>.from(json["pamphletwise"].map((x) => x)),
125+ pediatrics: List<dynamic>.from(json["pediatrics"].map((x) => x)),
126+ perceptive: List<bool>.from(json["perceptive"].map((x) => x)),
127+ piaculum: List<dynamic>.from(json["piaculum"].map((x) => x)),
128+ piccadilly: List<dynamic>.from(json["piccadilly"].map((x) => x)),
129+ piffler: List<dynamic>.from(json["piffler"].map((x) => x)),
130+ pithful: List<dynamic>.from(json["pithful"].map((x) => x)),
131+ placuntitis: List<dynamic>.from(json["placuntitis"].map((x) => x)),
132+ plectopterous: List<dynamic>.from(json["plectopterous"].map((x) => x)),
133+ pneumocele: List<Pneumocele?>.from(json["pneumocele"].map((x) => x == null ? null : Pneumocele.fromJson(x))),
134+ poliorcetic: List<dynamic>.from(json["poliorcetic"].map((x) => x)),
135+ poormaster: List<dynamic>.from(json["poormaster"].map((x) => x)),
136+ potwhisky: List<dynamic>.from(json["potwhisky"].map((x) => x)),
137+ practicalizer: List<dynamic>.from(json["practicalizer"].map((x) => x)),
138+ prefreshman: List<dynamic>.from(json["prefreshman"].map((x) => x)),
139+ prehensility: List<dynamic>.from(json["prehensility"].map((x) => x)),
140+ prevoidance: List<dynamic>.from(json["prevoidance"].map((x) => x)),
141+ probant: List<Map<String, int?>>.from(json["probant"].map((x) => Map.from(x).map((k, v) => MapEntry<String, int?>(k, v)))),
142+ protext: List<dynamic>.from(json["protext"].map((x) => x)),
143+ );
144+
145+ Map<String, dynamic> toJson() => {
146+ "juror": List<dynamic>.from(juror.map((x) => x)),
147+ "kongoni": List<dynamic>.from(kongoni.map((x) => x)),
148+ "ladronism": List<dynamic>.from(ladronism.map((x) => x)),
149+ "landlubberly": List<dynamic>.from(landlubberly.map((x) => x)),
150+ "listener": List<dynamic>.from(listener.map((x) => x)),
151+ "lupus": List<dynamic>.from(lupus.map((x) => x)),
152+ "maslin": List<dynamic>.from(maslin.map((x) => x.toJson())),
153+ "monazite": List<dynamic>.from(monazite.map((x) => x)),
154+ "monoliteral": List<dynamic>.from(monoliteral.map((x) => x)),
155+ "monotheistically": List<dynamic>.from(monotheistically.map((x) => x)),
156+ "montage": List<dynamic>.from(montage.map((x) => x)),
157+ "moralness": List<dynamic>.from(moralness.map((x) => x)),
158+ "mowra": List<dynamic>.from(mowra.map((x) => x?.toJson())),
159+ "mulishly": List<dynamic>.from(mulishly.map((x) => x)),
160+ "myoscope": List<dynamic>.from(myoscope.map((x) => x)),
161+ "nach": List<dynamic>.from(nach.map((x) => x == null ? null : List<dynamic>.from(x!.map((x) => x)))),
162+ "neuromastic": List<dynamic>.from(neuromastic.map((x) => x)),
163+ "noncontributing": List<dynamic>.from(noncontributing.map((x) => x.toJson())),
164+ "nonnervous": List<dynamic>.from(nonnervous.map((x) => x)),
165+ "nonvaluation": List<dynamic>.from(nonvaluation.map((x) => x)),
166+ "occupationalist": List<dynamic>.from(occupationalist.map((x) => x)),
167+ "outrival": List<dynamic>.from(outrival.map((x) => x)),
168+ "paleographically": List<dynamic>.from(paleographically.map((x) => x)),
169+ "pamphletwise": List<dynamic>.from(pamphletwise.map((x) => x)),
170+ "pediatrics": List<dynamic>.from(pediatrics.map((x) => x)),
171+ "perceptive": List<dynamic>.from(perceptive.map((x) => x)),
172+ "piaculum": List<dynamic>.from(piaculum.map((x) => x)),
173+ "piccadilly": List<dynamic>.from(piccadilly.map((x) => x)),
174+ "piffler": List<dynamic>.from(piffler.map((x) => x)),
175+ "pithful": List<dynamic>.from(pithful.map((x) => x)),
176+ "placuntitis": List<dynamic>.from(placuntitis.map((x) => x)),
177+ "plectopterous": List<dynamic>.from(plectopterous.map((x) => x)),
178+ "pneumocele": List<dynamic>.from(pneumocele.map((x) => x?.toJson())),
179+ "poliorcetic": List<dynamic>.from(poliorcetic.map((x) => x)),
180+ "poormaster": List<dynamic>.from(poormaster.map((x) => x)),
181+ "potwhisky": List<dynamic>.from(potwhisky.map((x) => x)),
182+ "practicalizer": List<dynamic>.from(practicalizer.map((x) => x)),
183+ "prefreshman": List<dynamic>.from(prefreshman.map((x) => x)),
184+ "prehensility": List<dynamic>.from(prehensility.map((x) => x)),
185+ "prevoidance": List<dynamic>.from(prevoidance.map((x) => x)),
186+ "probant": List<dynamic>.from(probant.map((x) => Map.from(x).map((k, v) => MapEntry<String, dynamic>(k, v)))),
187+ "protext": List<dynamic>.from(protext.map((x) => x)),
188+ };
189+}
190+
191+class JurorClass {
192+ final dynamic adipsy;
193+ final dynamic auxiliator;
194+ final dynamic benda;
195+ final dynamic benjamin;
196+ final dynamic brandling;
197+ final dynamic epicurishly;
198+ final dynamic eremochaetous;
199+ final dynamic marten;
200+ final dynamic monocline;
201+ final dynamic olea;
202+ final dynamic palgat;
203+ final dynamic pennyworth;
204+ final dynamic pioury;
205+ final dynamic pragmatistic;
206+ final dynamic stylelessness;
207+ final dynamic systematical;
208+ final dynamic thready;
209+ final dynamic uncontemporary;
210+ final dynamic uncouched;
211+ final dynamic uninhabitedness;
212+
213+ JurorClass({
214+ required this.adipsy,
215+ required this.auxiliator,
216+ required this.benda,
217+ required this.benjamin,
218+ required this.brandling,
219+ required this.epicurishly,
220+ required this.eremochaetous,
221+ required this.marten,
222+ required this.monocline,
223+ required this.olea,
224+ required this.palgat,
225+ required this.pennyworth,
226+ required this.pioury,
227+ required this.pragmatistic,
228+ required this.stylelessness,
229+ required this.systematical,
230+ required this.thready,
231+ required this.uncontemporary,
232+ required this.uncouched,
233+ required this.uninhabitedness,
234+ });
235+
236+ factory JurorClass.fromJson(Map<String, dynamic> json) => JurorClass(
237+ adipsy: json["adipsy"],
238+ auxiliator: json["auxiliator"],
239+ benda: json["benda"],
240+ benjamin: json["benjamin"],
241+ brandling: json["brandling"],
242+ epicurishly: json["epicurishly"],
243+ eremochaetous: json["eremochaetous"],
244+ marten: json["marten"],
245+ monocline: json["monocline"],
246+ olea: json["Olea"],
247+ palgat: json["palgat"],
248+ pennyworth: json["pennyworth"],
249+ pioury: json["pioury"],
250+ pragmatistic: json["pragmatistic"],
251+ stylelessness: json["stylelessness"],
252+ systematical: json["systematical"],
253+ thready: json["thready"],
254+ uncontemporary: json["uncontemporary"],
255+ uncouched: json["uncouched"],
256+ uninhabitedness: json["uninhabitedness"],
257+ );
258+
259+ Map<String, dynamic> toJson() => {
260+ "adipsy": adipsy,
261+ "auxiliator": auxiliator,
262+ "benda": benda,
263+ "benjamin": benjamin,
264+ "brandling": brandling,
265+ "epicurishly": epicurishly,
266+ "eremochaetous": eremochaetous,
267+ "marten": marten,
268+ "monocline": monocline,
269+ "Olea": olea,
270+ "palgat": palgat,
271+ "pennyworth": pennyworth,
272+ "pioury": pioury,
273+ "pragmatistic": pragmatistic,
274+ "stylelessness": stylelessness,
275+ "systematical": systematical,
276+ "thready": thready,
277+ "uncontemporary": uncontemporary,
278+ "uncouched": uncouched,
279+ "uninhabitedness": uninhabitedness,
280+ };
281+}
282+
283+class LadronismClass {
284+ final dynamic acclaimer;
285+ final dynamic achree;
286+ final dynamic base;
287+ final dynamic conundrumize;
288+ final dynamic degerminator;
289+ final dynamic describable;
290+ final dynamic exasperatedly;
291+ final dynamic heroine;
292+ final dynamic indazin;
293+ final dynamic luteous;
294+ final dynamic papular;
295+ final dynamic pritch;
296+ final dynamic prodenia;
297+ final dynamic seege;
298+ final dynamic shopgirl;
299+ final dynamic tragedietta;
300+ final dynamic unsparse;
301+ final dynamic uplook;
302+ final dynamic vermiformis;
303+ final dynamic whafabout;
304+
305+ LadronismClass({
306+ required this.acclaimer,
307+ required this.achree,
308+ required this.base,
309+ required this.conundrumize,
310+ required this.degerminator,
311+ required this.describable,
312+ required this.exasperatedly,
313+ required this.heroine,
314+ required this.indazin,
315+ required this.luteous,
316+ required this.papular,
317+ required this.pritch,
318+ required this.prodenia,
319+ required this.seege,
320+ required this.shopgirl,
321+ required this.tragedietta,
322+ required this.unsparse,
323+ required this.uplook,
324+ required this.vermiformis,
325+ required this.whafabout,
326+ });
327+
328+ factory LadronismClass.fromJson(Map<String, dynamic> json) => LadronismClass(
329+ acclaimer: json["acclaimer"],
330+ achree: json["achree"],
331+ base: json["base"],
332+ conundrumize: json["conundrumize"],
333+ degerminator: json["degerminator"],
334+ describable: json["describable"],
335+ exasperatedly: json["exasperatedly"],
336+ heroine: json["heroine"],
337+ indazin: json["indazin"],
338+ luteous: json["luteous"],
339+ papular: json["papular"],
340+ pritch: json["pritch"],
341+ prodenia: json["Prodenia"],
342+ seege: json["seege"],
343+ shopgirl: json["shopgirl"],
344+ tragedietta: json["tragedietta"],
345+ unsparse: json["unsparse"],
346+ uplook: json["uplook"],
347+ vermiformis: json["vermiformis"],
348+ whafabout: json["whafabout"],
349+ );
350+
351+ Map<String, dynamic> toJson() => {
352+ "acclaimer": acclaimer,
353+ "achree": achree,
354+ "base": base,
355+ "conundrumize": conundrumize,
356+ "degerminator": degerminator,
357+ "describable": describable,
358+ "exasperatedly": exasperatedly,
359+ "heroine": heroine,
360+ "indazin": indazin,
361+ "luteous": luteous,
362+ "papular": papular,
363+ "pritch": pritch,
364+ "Prodenia": prodenia,
365+ "seege": seege,
366+ "shopgirl": shopgirl,
367+ "tragedietta": tragedietta,
368+ "unsparse": unsparse,
369+ "uplook": uplook,
370+ "vermiformis": vermiformis,
371+ "whafabout": whafabout,
372+ };
373+}
374+
375+class LandlubberlyClass {
376+ final dynamic acropoleis;
377+ final dynamic aminate;
378+ final dynamic amyraldism;
379+ final dynamic bipenniform;
380+ final dynamic bugre;
381+ final dynamic calycule;
382+ final dynamic caoutchouc;
383+ final dynamic disprover;
384+ final dynamic fitroot;
385+ final dynamic fulgently;
386+ final dynamic kickup;
387+ final dynamic laevoversion;
388+ final dynamic moter;
389+ final dynamic objectivity;
390+ final dynamic posterity;
391+ final dynamic postnuptial;
392+ final dynamic precedentary;
393+ final dynamic saddling;
394+ final dynamic subcurrent;
395+ final dynamic unrecriminative;
396+
397+ LandlubberlyClass({
398+ required this.acropoleis,
399+ required this.aminate,
400+ required this.amyraldism,
401+ required this.bipenniform,
402+ required this.bugre,
403+ required this.calycule,
404+ required this.caoutchouc,
405+ required this.disprover,
406+ required this.fitroot,
407+ required this.fulgently,
408+ required this.kickup,
409+ required this.laevoversion,
410+ required this.moter,
411+ required this.objectivity,
412+ required this.posterity,
413+ required this.postnuptial,
414+ required this.precedentary,
415+ required this.saddling,
416+ required this.subcurrent,
417+ required this.unrecriminative,
418+ });
419+
420+ factory LandlubberlyClass.fromJson(Map<String, dynamic> json) => LandlubberlyClass(
421+ acropoleis: json["acropoleis"],
422+ aminate: json["aminate"],
423+ amyraldism: json["Amyraldism"],
424+ bipenniform: json["bipenniform"],
425+ bugre: json["bugre"],
426+ calycule: json["calycule"],
427+ caoutchouc: json["caoutchouc"],
428+ disprover: json["disprover"],
429+ fitroot: json["fitroot"],
430+ fulgently: json["fulgently"],
431+ kickup: json["kickup"],
432+ laevoversion: json["laevoversion"],
433+ moter: json["moter"],
434+ objectivity: json["objectivity"],
435+ posterity: json["posterity"],
436+ postnuptial: json["postnuptial"],
437+ precedentary: json["precedentary"],
438+ saddling: json["saddling"],
439+ subcurrent: json["subcurrent"],
440+ unrecriminative: json["unrecriminative"],
441+ );
442+
443+ Map<String, dynamic> toJson() => {
444+ "acropoleis": acropoleis,
445+ "aminate": aminate,
446+ "Amyraldism": amyraldism,
447+ "bipenniform": bipenniform,
448+ "bugre": bugre,
449+ "calycule": calycule,
450+ "caoutchouc": caoutchouc,
451+ "disprover": disprover,
452+ "fitroot": fitroot,
453+ "fulgently": fulgently,
454+ "kickup": kickup,
455+ "laevoversion": laevoversion,
456+ "moter": moter,
457+ "objectivity": objectivity,
458+ "posterity": posterity,
459+ "postnuptial": postnuptial,
460+ "precedentary": precedentary,
461+ "saddling": saddling,
462+ "subcurrent": subcurrent,
463+ "unrecriminative": unrecriminative,
464+ };
465+}
466+
467+class LupusClass {
468+ final double? catharticalness;
469+ final int? chirotherium;
470+ final int? chlorioninae;
471+ final int? corvinae;
472+ final int? crassina;
473+ final String? disdiapason;
474+ final int? exiguity;
475+ final int? farcist;
476+ final int? holographical;
477+ final bool? homocerc;
478+ final int? ichthyophagan;
479+ final int? implacable;
480+ final dynamic nonbookish;
481+ final int? outshiner;
482+ final int? overweather;
483+ final int? protonegroid;
484+ final int? shallowish;
485+ final int? snoke;
486+ final int? snout;
487+ final int? surveillance;
488+ final int? threshingtime;
489+ final int? thysanocarpus;
490+ final int? unsignificantly;
491+ final int? unsnap;
492+ final int? vendible;
493+
494+ LupusClass({
495+ this.catharticalness,
496+ this.chirotherium,
497+ this.chlorioninae,
498+ this.corvinae,
499+ this.crassina,
500+ this.disdiapason,
501+ this.exiguity,
502+ this.farcist,
503+ this.holographical,
504+ this.homocerc,
505+ this.ichthyophagan,
506+ this.implacable,
507+ this.nonbookish,
508+ this.outshiner,
509+ this.overweather,
510+ this.protonegroid,
511+ this.shallowish,
512+ this.snoke,
513+ this.snout,
514+ this.surveillance,
515+ this.threshingtime,
516+ this.thysanocarpus,
517+ this.unsignificantly,
518+ this.unsnap,
519+ this.vendible,
520+ });
521+
522+ factory LupusClass.fromJson(Map<String, dynamic> json) => LupusClass(
523+ catharticalness: json["catharticalness"]?.toDouble(),
524+ chirotherium: json["Chirotherium"],
525+ chlorioninae: json["Chlorioninae"],
526+ corvinae: json["Corvinae"],
527+ crassina: json["Crassina"],
528+ disdiapason: json["disdiapason"],
529+ exiguity: json["exiguity"],
530+ farcist: json["farcist"],
531+ holographical: json["holographical"],
532+ homocerc: json["homocerc"],
533+ ichthyophagan: json["ichthyophagan"],
534+ implacable: json["implacable"],
535+ nonbookish: json["nonbookish"],
536+ outshiner: json["outshiner"],
537+ overweather: json["overweather"],
538+ protonegroid: json["protonegroid"],
539+ shallowish: json["shallowish"],
540+ snoke: json["snoke"],
541+ snout: json["snout"],
542+ surveillance: json["surveillance"],
543+ threshingtime: json["threshingtime"],
544+ thysanocarpus: json["Thysanocarpus"],
545+ unsignificantly: json["unsignificantly"],
546+ unsnap: json["unsnap"],
547+ vendible: json["vendible"],
548+ );
549+
550+ Map<String, dynamic> toJson() => {
551+ "catharticalness": catharticalness,
552+ "Chirotherium": chirotherium,
553+ "Chlorioninae": chlorioninae,
554+ "Corvinae": corvinae,
555+ "Crassina": crassina,
556+ "disdiapason": disdiapason,
557+ "exiguity": exiguity,
558+ "farcist": farcist,
559+ "holographical": holographical,
560+ "homocerc": homocerc,
561+ "ichthyophagan": ichthyophagan,
562+ "implacable": implacable,
563+ "nonbookish": nonbookish,
564+ "outshiner": outshiner,
565+ "overweather": overweather,
566+ "protonegroid": protonegroid,
567+ "shallowish": shallowish,
568+ "snoke": snoke,
569+ "snout": snout,
570+ "surveillance": surveillance,
571+ "threshingtime": threshingtime,
572+ "Thysanocarpus": thysanocarpus,
573+ "unsignificantly": unsignificantly,
574+ "unsnap": unsnap,
575+ "vendible": vendible,
576+ };
577+}
578+
579+class Maslin {
580+ final int? alicant;
581+ final dynamic antiatonement;
582+ final int? anticorrosive;
583+ final dynamic aphidozer;
584+ final dynamic bakuninist;
585+ final int? be;
586+ final double? catharticalness;
587+ final int? chirotherium;
588+ final int? chub;
589+ final int? cuprosilicon;
590+ final int? curtailedly;
591+ final int? dellenite;
592+ final int? dimitry;
593+ final String? disdiapason;
594+ final dynamic edifying;
595+ final int? ethmoiditis;
596+ final dynamic gastralgy;
597+ final int? goatherd;
598+ final int? hammerdress;
599+ final dynamic hangfire;
600+ final bool? homocerc;
601+ final int? lacunosity;
602+ final dynamic longiloquence;
603+ final int? mameliere;
604+ final dynamic motherless;
605+ final dynamic nonbookish;
606+ final dynamic noncorrodible;
607+ final dynamic nonsensicality;
608+ final int? oafishly;
609+ final dynamic pfund;
610+ final dynamic preadvisory;
611+ final dynamic retroflexed;
612+ final int? saccharulmic;
613+ final int? scowlful;
614+ final dynamic secluded;
615+ final dynamic slackage;
616+ final int? sphaeridial;
617+ final dynamic spondulics;
618+ final int? subsecive;
619+ final dynamic swellmobsman;
620+ final int? trachyglossate;
621+ final dynamic trialogue;
622+ final int? unassuaged;
623+ final dynamic ungross;
624+ final dynamic unjudiciously;
625+
626+ Maslin({
627+ this.alicant,
628+ this.antiatonement,
629+ this.anticorrosive,
630+ this.aphidozer,
631+ this.bakuninist,
632+ this.be,
633+ this.catharticalness,
634+ this.chirotherium,
635+ this.chub,
636+ this.cuprosilicon,
637+ this.curtailedly,
638+ this.dellenite,
639+ this.dimitry,
640+ this.disdiapason,
641+ this.edifying,
642+ this.ethmoiditis,
643+ this.gastralgy,
644+ this.goatherd,
645+ this.hammerdress,
646+ this.hangfire,
647+ this.homocerc,
648+ this.lacunosity,
649+ this.longiloquence,
650+ this.mameliere,
651+ this.motherless,
652+ this.nonbookish,
653+ this.noncorrodible,
654+ this.nonsensicality,
655+ this.oafishly,
656+ this.pfund,
657+ this.preadvisory,
658+ this.retroflexed,
659+ this.saccharulmic,
660+ this.scowlful,
661+ this.secluded,
662+ this.slackage,
663+ this.sphaeridial,
664+ this.spondulics,
665+ this.subsecive,
666+ this.swellmobsman,
667+ this.trachyglossate,
668+ this.trialogue,
669+ this.unassuaged,
670+ this.ungross,
671+ this.unjudiciously,
672+ });
673+
674+ factory Maslin.fromJson(Map<String, dynamic> json) => Maslin(
675+ alicant: json["Alicant"],
676+ antiatonement: json["antiatonement"],
677+ anticorrosive: json["anticorrosive"],
678+ aphidozer: json["aphidozer"],
679+ bakuninist: json["Bakuninist"],
680+ be: json["be"],
681+ catharticalness: json["catharticalness"]?.toDouble(),
682+ chirotherium: json["Chirotherium"],
683+ chub: json["chub"],
684+ cuprosilicon: json["cuprosilicon"],
685+ curtailedly: json["curtailedly"],
686+ dellenite: json["dellenite"],
687+ dimitry: json["Dimitry"],
688+ disdiapason: json["disdiapason"],
689+ edifying: json["edifying"],
690+ ethmoiditis: json["ethmoiditis"],
691+ gastralgy: json["gastralgy"],
692+ goatherd: json["goatherd"],
693+ hammerdress: json["hammerdress"],
694+ hangfire: json["hangfire"],
695+ homocerc: json["homocerc"],
696+ lacunosity: json["lacunosity"],
697+ longiloquence: json["longiloquence"],
698+ mameliere: json["mameliere"],
699+ motherless: json["motherless"],
700+ nonbookish: json["nonbookish"],
701+ noncorrodible: json["noncorrodible"],
702+ nonsensicality: json["nonsensicality"],
703+ oafishly: json["oafishly"],
704+ pfund: json["pfund"],
705+ preadvisory: json["preadvisory"],
706+ retroflexed: json["retroflexed"],
707+ saccharulmic: json["saccharulmic"],
708+ scowlful: json["scowlful"],
709+ secluded: json["secluded"],
710+ slackage: json["slackage"],
711+ sphaeridial: json["sphaeridial"],
712+ spondulics: json["spondulics"],
713+ subsecive: json["subsecive"],
714+ swellmobsman: json["swellmobsman"],
715+ trachyglossate: json["trachyglossate"],
716+ trialogue: json["trialogue"],
717+ unassuaged: json["unassuaged"],
718+ ungross: json["ungross"],
719+ unjudiciously: json["unjudiciously"],
720+ );
721+
722+ Map<String, dynamic> toJson() => {
723+ "Alicant": alicant,
724+ "antiatonement": antiatonement,
725+ "anticorrosive": anticorrosive,
726+ "aphidozer": aphidozer,
727+ "Bakuninist": bakuninist,
728+ "be": be,
729+ "catharticalness": catharticalness,
730+ "Chirotherium": chirotherium,
731+ "chub": chub,
732+ "cuprosilicon": cuprosilicon,
733+ "curtailedly": curtailedly,
734+ "dellenite": dellenite,
735+ "Dimitry": dimitry,
736+ "disdiapason": disdiapason,
737+ "edifying": edifying,
738+ "ethmoiditis": ethmoiditis,
739+ "gastralgy": gastralgy,
740+ "goatherd": goatherd,
741+ "hammerdress": hammerdress,
742+ "hangfire": hangfire,
743+ "homocerc": homocerc,
744+ "lacunosity": lacunosity,
745+ "longiloquence": longiloquence,
746+ "mameliere": mameliere,
747+ "motherless": motherless,
748+ "nonbookish": nonbookish,
749+ "noncorrodible": noncorrodible,
750+ "nonsensicality": nonsensicality,
751+ "oafishly": oafishly,
752+ "pfund": pfund,
753+ "preadvisory": preadvisory,
754+ "retroflexed": retroflexed,
755+ "saccharulmic": saccharulmic,
756+ "scowlful": scowlful,
757+ "secluded": secluded,
758+ "slackage": slackage,
759+ "sphaeridial": sphaeridial,
760+ "spondulics": spondulics,
761+ "subsecive": subsecive,
762+ "swellmobsman": swellmobsman,
763+ "trachyglossate": trachyglossate,
764+ "trialogue": trialogue,
765+ "unassuaged": unassuaged,
766+ "ungross": ungross,
767+ "unjudiciously": unjudiciously,
768+ };
769+}
770+
771+class MonaziteClass {
772+ final double catharticalness;
773+ final int chirotherium;
774+ final String disdiapason;
775+ final bool homocerc;
776+ final dynamic nonbookish;
777+
778+ MonaziteClass({
779+ required this.catharticalness,
780+ required this.chirotherium,
781+ required this.disdiapason,
782+ required this.homocerc,
783+ required this.nonbookish,
784+ });
785+
786+ factory MonaziteClass.fromJson(Map<String, dynamic> json) => MonaziteClass(
787+ catharticalness: json["catharticalness"]?.toDouble(),
788+ chirotherium: json["Chirotherium"],
789+ disdiapason: json["disdiapason"],
790+ homocerc: json["homocerc"],
791+ nonbookish: json["nonbookish"],
792+ );
793+
794+ Map<String, dynamic> toJson() => {
795+ "catharticalness": catharticalness,
796+ "Chirotherium": chirotherium,
797+ "disdiapason": disdiapason,
798+ "homocerc": homocerc,
799+ "nonbookish": nonbookish,
800+ };
801+}
802+
803+class MonotheisticallyClass {
804+ final dynamic blaspheme;
805+ final double? catharticalness;
806+ final dynamic celiosalpingectomy;
807+ final int? chirotherium;
808+ final dynamic consummativeness;
809+ final String? disdiapason;
810+ final dynamic egestive;
811+ final dynamic enchylema;
812+ final dynamic gasconade;
813+ final dynamic holidayer;
814+ final bool? homocerc;
815+ final dynamic intuitionalism;
816+ final dynamic lophiostomate;
817+ final dynamic nonbookish;
818+ final dynamic nonvolition;
819+ final dynamic palatableness;
820+ final dynamic pimpery;
821+ final dynamic previolation;
822+ final dynamic reconveyance;
823+ final dynamic registership;
824+ final dynamic rhyacolite;
825+ final dynamic smithereens;
826+ final dynamic superedification;
827+ final dynamic trust;
828+ final dynamic whitestone;
829+
830+ MonotheisticallyClass({
831+ this.blaspheme,
832+ this.catharticalness,
833+ this.celiosalpingectomy,
834+ this.chirotherium,
835+ this.consummativeness,
836+ this.disdiapason,
837+ this.egestive,
838+ this.enchylema,
839+ this.gasconade,
840+ this.holidayer,
841+ this.homocerc,
842+ this.intuitionalism,
843+ this.lophiostomate,
844+ this.nonbookish,
845+ this.nonvolition,
846+ this.palatableness,
847+ this.pimpery,
848+ this.previolation,
849+ this.reconveyance,
850+ this.registership,
851+ this.rhyacolite,
852+ this.smithereens,
853+ this.superedification,
854+ this.trust,
855+ this.whitestone,
856+ });
857+
858+ factory MonotheisticallyClass.fromJson(Map<String, dynamic> json) => MonotheisticallyClass(
859+ blaspheme: json["blaspheme"],
860+ catharticalness: json["catharticalness"]?.toDouble(),
861+ celiosalpingectomy: json["celiosalpingectomy"],
862+ chirotherium: json["Chirotherium"],
863+ consummativeness: json["consummativeness"],
864+ disdiapason: json["disdiapason"],
865+ egestive: json["egestive"],
866+ enchylema: json["enchylema"],
867+ gasconade: json["gasconade"],
868+ holidayer: json["holidayer"],
869+ homocerc: json["homocerc"],
870+ intuitionalism: json["intuitionalism"],
871+ lophiostomate: json["lophiostomate"],
872+ nonbookish: json["nonbookish"],
873+ nonvolition: json["nonvolition"],
874+ palatableness: json["palatableness"],
875+ pimpery: json["pimpery"],
876+ previolation: json["previolation"],
877+ reconveyance: json["reconveyance"],
878+ registership: json["registership"],
879+ rhyacolite: json["rhyacolite"],
880+ smithereens: json["smithereens"],
881+ superedification: json["superedification"],
882+ trust: json["trust"],
883+ whitestone: json["whitestone"],
884+ );
885+
886+ Map<String, dynamic> toJson() => {
887+ "blaspheme": blaspheme,
888+ "catharticalness": catharticalness,
889+ "celiosalpingectomy": celiosalpingectomy,
890+ "Chirotherium": chirotherium,
891+ "consummativeness": consummativeness,
892+ "disdiapason": disdiapason,
893+ "egestive": egestive,
894+ "enchylema": enchylema,
895+ "gasconade": gasconade,
896+ "holidayer": holidayer,
897+ "homocerc": homocerc,
898+ "intuitionalism": intuitionalism,
899+ "lophiostomate": lophiostomate,
900+ "nonbookish": nonbookish,
901+ "nonvolition": nonvolition,
902+ "palatableness": palatableness,
903+ "pimpery": pimpery,
904+ "previolation": previolation,
905+ "reconveyance": reconveyance,
906+ "registership": registership,
907+ "rhyacolite": rhyacolite,
908+ "smithereens": smithereens,
909+ "superedification": superedification,
910+ "trust": trust,
911+ "whitestone": whitestone,
912+ };
913+}
914+
915+class Noncontributing {
916+ final String estevin;
917+ final double jolterhead;
918+ final int sauternes;
919+ final bool sparsely;
920+ final dynamic unrequested;
921+
922+ Noncontributing({
923+ required this.estevin,
924+ required this.jolterhead,
925+ required this.sauternes,
926+ required this.sparsely,
927+ required this.unrequested,
928+ });
929+
930+ factory Noncontributing.fromJson(Map<String, dynamic> json) => Noncontributing(
931+ estevin: json["estevin"],
932+ jolterhead: json["jolterhead"]?.toDouble(),
933+ sauternes: json["sauternes"],
934+ sparsely: json["sparsely"],
935+ unrequested: json["unrequested"],
936+ );
937+
938+ Map<String, dynamic> toJson() => {
939+ "estevin": estevin,
940+ "jolterhead": jolterhead,
941+ "sauternes": sauternes,
942+ "sparsely": sparsely,
943+ "unrequested": unrequested,
944+ };
945+}
946+
947+class OccupationalistClass {
948+ final dynamic beholdable;
949+ final dynamic brotuliform;
950+ final dynamic chimakum;
951+ final dynamic doodler;
952+ final dynamic emulsin;
953+ final dynamic fin;
954+ final dynamic flourishing;
955+ final dynamic flueless;
956+ final dynamic furtively;
957+ final dynamic gritter;
958+ final dynamic interwish;
959+ final dynamic monoxylic;
960+ final dynamic myristic;
961+ final dynamic nightwear;
962+ final dynamic peruser;
963+ final dynamic theoastrological;
964+ final dynamic thumby;
965+ final dynamic tingitid;
966+ final dynamic trailless;
967+ final dynamic unpocketed;
968+
969+ OccupationalistClass({
970+ required this.beholdable,
971+ required this.brotuliform,
972+ required this.chimakum,
973+ required this.doodler,
974+ required this.emulsin,
975+ required this.fin,
976+ required this.flourishing,
977+ required this.flueless,
978+ required this.furtively,
979+ required this.gritter,
980+ required this.interwish,
981+ required this.monoxylic,
982+ required this.myristic,
983+ required this.nightwear,
984+ required this.peruser,
985+ required this.theoastrological,
986+ required this.thumby,
987+ required this.tingitid,
988+ required this.trailless,
989+ required this.unpocketed,
990+ });
991+
992+ factory OccupationalistClass.fromJson(Map<String, dynamic> json) => OccupationalistClass(
993+ beholdable: json["beholdable"],
994+ brotuliform: json["brotuliform"],
995+ chimakum: json["Chimakum"],
996+ doodler: json["doodler"],
997+ emulsin: json["emulsin"],
998+ fin: json["Fin"],
999+ flourishing: json["flourishing"],
1000+ flueless: json["flueless"],
1001+ furtively: json["furtively"],
1002+ gritter: json["gritter"],
1003+ interwish: json["interwish"],
1004+ monoxylic: json["monoxylic"],
1005+ myristic: json["myristic"],
1006+ nightwear: json["nightwear"],
1007+ peruser: json["peruser"],
1008+ theoastrological: json["theoastrological"],
1009+ thumby: json["thumby"],
1010+ tingitid: json["tingitid"],
1011+ trailless: json["trailless"],
1012+ unpocketed: json["unpocketed"],
1013+ );
1014+
1015+ Map<String, dynamic> toJson() => {
1016+ "beholdable": beholdable,
1017+ "brotuliform": brotuliform,
1018+ "Chimakum": chimakum,
1019+ "doodler": doodler,
1020+ "emulsin": emulsin,
1021+ "Fin": fin,
1022+ "flourishing": flourishing,
1023+ "flueless": flueless,
1024+ "furtively": furtively,
1025+ "gritter": gritter,
1026+ "interwish": interwish,
1027+ "monoxylic": monoxylic,
1028+ "myristic": myristic,
1029+ "nightwear": nightwear,
1030+ "peruser": peruser,
1031+ "theoastrological": theoastrological,
1032+ "thumby": thumby,
1033+ "tingitid": tingitid,
1034+ "trailless": trailless,
1035+ "unpocketed": unpocketed,
1036+ };
1037+}
1038+
1039+class OutrivalClass {
1040+ final dynamic adroitly;
1041+ final dynamic bridehood;
1042+ final dynamic castoroides;
1043+ final dynamic czechoslovak;
1044+ final dynamic diagenesis;
1045+ final dynamic dihexahedron;
1046+ final dynamic dopester;
1047+ final dynamic eumerism;
1048+ final dynamic flyness;
1049+ final dynamic fouler;
1050+ final dynamic laudanosine;
1051+ final dynamic lingulidae;
1052+ final dynamic minutary;
1053+ final dynamic mitra;
1054+ final dynamic opisthorchiasis;
1055+ final dynamic pensively;
1056+ final dynamic pubigerous;
1057+ final dynamic rebellious;
1058+ final dynamic recodify;
1059+ final dynamic unpaced;
1060+
1061+ OutrivalClass({
1062+ required this.adroitly,
1063+ required this.bridehood,
1064+ required this.castoroides,
1065+ required this.czechoslovak,
1066+ required this.diagenesis,
1067+ required this.dihexahedron,
1068+ required this.dopester,
1069+ required this.eumerism,
1070+ required this.flyness,
1071+ required this.fouler,
1072+ required this.laudanosine,
1073+ required this.lingulidae,
1074+ required this.minutary,
1075+ required this.mitra,
1076+ required this.opisthorchiasis,
1077+ required this.pensively,
1078+ required this.pubigerous,
1079+ required this.rebellious,
1080+ required this.recodify,
1081+ required this.unpaced,
1082+ });
1083+
1084+ factory OutrivalClass.fromJson(Map<String, dynamic> json) => OutrivalClass(
1085+ adroitly: json["adroitly"],
1086+ bridehood: json["bridehood"],
1087+ castoroides: json["Castoroides"],
1088+ czechoslovak: json["Czechoslovak"],
1089+ diagenesis: json["diagenesis"],
1090+ dihexahedron: json["dihexahedron"],
1091+ dopester: json["dopester"],
1092+ eumerism: json["eumerism"],
1093+ flyness: json["flyness"],
1094+ fouler: json["fouler"],
1095+ laudanosine: json["laudanosine"],
1096+ lingulidae: json["Lingulidae"],
1097+ minutary: json["minutary"],
1098+ mitra: json["mitra"],
1099+ opisthorchiasis: json["opisthorchiasis"],
1100+ pensively: json["pensively"],
1101+ pubigerous: json["pubigerous"],
1102+ rebellious: json["rebellious"],
1103+ recodify: json["recodify"],
1104+ unpaced: json["unpaced"],
1105+ );
1106+
1107+ Map<String, dynamic> toJson() => {
1108+ "adroitly": adroitly,
1109+ "bridehood": bridehood,
1110+ "Castoroides": castoroides,
1111+ "Czechoslovak": czechoslovak,
1112+ "diagenesis": diagenesis,
1113+ "dihexahedron": dihexahedron,
1114+ "dopester": dopester,
1115+ "eumerism": eumerism,
1116+ "flyness": flyness,
1117+ "fouler": fouler,
1118+ "laudanosine": laudanosine,
1119+ "Lingulidae": lingulidae,
1120+ "minutary": minutary,
1121+ "mitra": mitra,
1122+ "opisthorchiasis": opisthorchiasis,
1123+ "pensively": pensively,
1124+ "pubigerous": pubigerous,
1125+ "rebellious": rebellious,
1126+ "recodify": recodify,
1127+ "unpaced": unpaced,
1128+ };
1129+}
1130+
1131+class PiaculumClass {
1132+ final int? alada;
1133+ final int? amphistomous;
1134+ final int? boysenberry;
1135+ final double? catharticalness;
1136+ final int? chirotherium;
1137+ final int? decardinalize;
1138+ final int? discouragement;
1139+ final String? disdiapason;
1140+ final int? doitrified;
1141+ final int? hexaspermous;
1142+ final bool? homocerc;
1143+ final int? insinking;
1144+ final int? loathfulness;
1145+ final int? miasmatical;
1146+ final int? neurofibril;
1147+ final dynamic nonbookish;
1148+ final int? phonendoscope;
1149+ final int? pilferment;
1150+ final int? predismissory;
1151+ final int? preinscription;
1152+ final int? quotative;
1153+ final int? sienna;
1154+ final int? thorax;
1155+ final int? yachting;
1156+ final int? zipper;
1157+
1158+ PiaculumClass({
1159+ this.alada,
1160+ this.amphistomous,
1161+ this.boysenberry,
1162+ this.catharticalness,
1163+ this.chirotherium,
1164+ this.decardinalize,
1165+ this.discouragement,
1166+ this.disdiapason,
1167+ this.doitrified,
1168+ this.hexaspermous,
1169+ this.homocerc,
1170+ this.insinking,
1171+ this.loathfulness,
1172+ this.miasmatical,
1173+ this.neurofibril,
1174+ this.nonbookish,
1175+ this.phonendoscope,
1176+ this.pilferment,
1177+ this.predismissory,
1178+ this.preinscription,
1179+ this.quotative,
1180+ this.sienna,
1181+ this.thorax,
1182+ this.yachting,
1183+ this.zipper,
1184+ });
1185+
1186+ factory PiaculumClass.fromJson(Map<String, dynamic> json) => PiaculumClass(
1187+ alada: json["alada"],
1188+ amphistomous: json["amphistomous"],
1189+ boysenberry: json["boysenberry"],
1190+ catharticalness: json["catharticalness"]?.toDouble(),
1191+ chirotherium: json["Chirotherium"],
1192+ decardinalize: json["decardinalize"],
1193+ discouragement: json["discouragement"],
1194+ disdiapason: json["disdiapason"],
1195+ doitrified: json["doitrified"],
1196+ hexaspermous: json["hexaspermous"],
1197+ homocerc: json["homocerc"],
1198+ insinking: json["insinking"],
1199+ loathfulness: json["loathfulness"],
1200+ miasmatical: json["miasmatical"],
1201+ neurofibril: json["neurofibril"],
1202+ nonbookish: json["nonbookish"],
1203+ phonendoscope: json["phonendoscope"],
1204+ pilferment: json["pilferment"],
1205+ predismissory: json["predismissory"],
1206+ preinscription: json["preinscription"],
1207+ quotative: json["quotative"],
1208+ sienna: json["sienna"],
1209+ thorax: json["thorax"],
1210+ yachting: json["yachting"],
1211+ zipper: json["Zipper"],
1212+ );
1213+
1214+ Map<String, dynamic> toJson() => {
1215+ "alada": alada,
1216+ "amphistomous": amphistomous,
1217+ "boysenberry": boysenberry,
1218+ "catharticalness": catharticalness,
1219+ "Chirotherium": chirotherium,
1220+ "decardinalize": decardinalize,
1221+ "discouragement": discouragement,
1222+ "disdiapason": disdiapason,
1223+ "doitrified": doitrified,
1224+ "hexaspermous": hexaspermous,
1225+ "homocerc": homocerc,
1226+ "insinking": insinking,
1227+ "loathfulness": loathfulness,
1228+ "miasmatical": miasmatical,
1229+ "neurofibril": neurofibril,
1230+ "nonbookish": nonbookish,
1231+ "phonendoscope": phonendoscope,
1232+ "pilferment": pilferment,
1233+ "predismissory": predismissory,
1234+ "preinscription": preinscription,
1235+ "quotative": quotative,
1236+ "sienna": sienna,
1237+ "thorax": thorax,
1238+ "yachting": yachting,
1239+ "Zipper": zipper,
1240+ };
1241+}
1242+
1243+class Pneumocele {
1244+ final dynamic carbonarism;
1245+ final double? catharticalness;
1246+ final int? chirotherium;
1247+ final dynamic cineolic;
1248+ final dynamic cobbly;
1249+ final dynamic conchyliferous;
1250+ final dynamic congregation;
1251+ final String? disdiapason;
1252+ final dynamic enterotomy;
1253+ final dynamic entophytal;
1254+ final dynamic fewtrils;
1255+ final dynamic herem;
1256+ final bool? homocerc;
1257+ final dynamic koniga;
1258+ final dynamic meticulosity;
1259+ final dynamic micky;
1260+ final dynamic mismarriage;
1261+ final dynamic neurotrophic;
1262+ final dynamic nonbookish;
1263+ final dynamic persuasively;
1264+ final dynamic replaceable;
1265+ final dynamic silex;
1266+ final dynamic taillight;
1267+ final dynamic unjealous;
1268+ final dynamic visitorial;
1269+
1270+ Pneumocele({
1271+ this.carbonarism,
1272+ this.catharticalness,
1273+ this.chirotherium,
1274+ this.cineolic,
1275+ this.cobbly,
1276+ this.conchyliferous,
1277+ this.congregation,
1278+ this.disdiapason,
1279+ this.enterotomy,
1280+ this.entophytal,
1281+ this.fewtrils,
1282+ this.herem,
1283+ this.homocerc,
1284+ this.koniga,
1285+ this.meticulosity,
1286+ this.micky,
1287+ this.mismarriage,
1288+ this.neurotrophic,
1289+ this.nonbookish,
1290+ this.persuasively,
1291+ this.replaceable,
1292+ this.silex,
1293+ this.taillight,
1294+ this.unjealous,
1295+ this.visitorial,
1296+ });
1297+
1298+ factory Pneumocele.fromJson(Map<String, dynamic> json) => Pneumocele(
1299+ carbonarism: json["Carbonarism"],
1300+ catharticalness: json["catharticalness"]?.toDouble(),
1301+ chirotherium: json["Chirotherium"],
1302+ cineolic: json["cineolic"],
1303+ cobbly: json["cobbly"],
1304+ conchyliferous: json["conchyliferous"],
1305+ congregation: json["congregation"],
1306+ disdiapason: json["disdiapason"],
1307+ enterotomy: json["enterotomy"],
1308+ entophytal: json["entophytal"],
1309+ fewtrils: json["fewtrils"],
1310+ herem: json["herem"],
1311+ homocerc: json["homocerc"],
1312+ koniga: json["Koniga"],
1313+ meticulosity: json["meticulosity"],
1314+ micky: json["Micky"],
1315+ mismarriage: json["mismarriage"],
1316+ neurotrophic: json["neurotrophic"],
1317+ nonbookish: json["nonbookish"],
1318+ persuasively: json["persuasively"],
1319+ replaceable: json["replaceable"],
1320+ silex: json["silex"],
1321+ taillight: json["taillight"],
1322+ unjealous: json["unjealous"],
1323+ visitorial: json["visitorial"],
1324+ );
1325+
1326+ Map<String, dynamic> toJson() => {
1327+ "Carbonarism": carbonarism,
1328+ "catharticalness": catharticalness,
1329+ "Chirotherium": chirotherium,
1330+ "cineolic": cineolic,
1331+ "cobbly": cobbly,
1332+ "conchyliferous": conchyliferous,
1333+ "congregation": congregation,
1334+ "disdiapason": disdiapason,
1335+ "enterotomy": enterotomy,
1336+ "entophytal": entophytal,
1337+ "fewtrils": fewtrils,
1338+ "herem": herem,
1339+ "homocerc": homocerc,
1340+ "Koniga": koniga,
1341+ "meticulosity": meticulosity,
1342+ "Micky": micky,
1343+ "mismarriage": mismarriage,
1344+ "neurotrophic": neurotrophic,
1345+ "nonbookish": nonbookish,
1346+ "persuasively": persuasively,
1347+ "replaceable": replaceable,
1348+ "silex": silex,
1349+ "taillight": taillight,
1350+ "unjealous": unjealous,
1351+ "visitorial": visitorial,
1352+ };
1353+}
1354+
1355+class PotwhiskyClass {
1356+ final dynamic arciform;
1357+ final dynamic cresolin;
1358+ final dynamic disheartener;
1359+ final dynamic disproportionable;
1360+ final dynamic euchorda;
1361+ final dynamic ferryway;
1362+ final dynamic filamentiferous;
1363+ final dynamic flemish;
1364+ final dynamic forgainst;
1365+ final dynamic grainering;
1366+ final dynamic irrevoluble;
1367+ final dynamic kindredship;
1368+ final dynamic pinguitudinous;
1369+ final dynamic simpletonic;
1370+ final dynamic singsong;
1371+ final dynamic submergement;
1372+ final dynamic supraoesophagal;
1373+ final dynamic thrashel;
1374+ final dynamic tyremesis;
1375+ final dynamic yoruba;
1376+
1377+ PotwhiskyClass({
1378+ required this.arciform,
1379+ required this.cresolin,
1380+ required this.disheartener,
1381+ required this.disproportionable,
1382+ required this.euchorda,
1383+ required this.ferryway,
1384+ required this.filamentiferous,
1385+ required this.flemish,
1386+ required this.forgainst,
1387+ required this.grainering,
1388+ required this.irrevoluble,
1389+ required this.kindredship,
1390+ required this.pinguitudinous,
1391+ required this.simpletonic,
1392+ required this.singsong,
1393+ required this.submergement,
1394+ required this.supraoesophagal,
1395+ required this.thrashel,
1396+ required this.tyremesis,
1397+ required this.yoruba,
1398+ });
1399+
1400+ factory PotwhiskyClass.fromJson(Map<String, dynamic> json) => PotwhiskyClass(
1401+ arciform: json["arciform"],
1402+ cresolin: json["cresolin"],
1403+ disheartener: json["disheartener"],
1404+ disproportionable: json["disproportionable"],
1405+ euchorda: json["Euchorda"],
1406+ ferryway: json["ferryway"],
1407+ filamentiferous: json["filamentiferous"],
1408+ flemish: json["flemish"],
1409+ forgainst: json["forgainst"],
1410+ grainering: json["grainering"],
1411+ irrevoluble: json["irrevoluble"],
1412+ kindredship: json["kindredship"],
1413+ pinguitudinous: json["pinguitudinous"],
1414+ simpletonic: json["simpletonic"],
1415+ singsong: json["singsong"],
1416+ submergement: json["submergement"],
1417+ supraoesophagal: json["supraoesophagal"],
1418+ thrashel: json["thrashel"],
1419+ tyremesis: json["tyremesis"],
1420+ yoruba: json["Yoruba"],
1421+ );
1422+
1423+ Map<String, dynamic> toJson() => {
1424+ "arciform": arciform,
1425+ "cresolin": cresolin,
1426+ "disheartener": disheartener,
1427+ "disproportionable": disproportionable,
1428+ "Euchorda": euchorda,
1429+ "ferryway": ferryway,
1430+ "filamentiferous": filamentiferous,
1431+ "flemish": flemish,
1432+ "forgainst": forgainst,
1433+ "grainering": grainering,
1434+ "irrevoluble": irrevoluble,
1435+ "kindredship": kindredship,
1436+ "pinguitudinous": pinguitudinous,
1437+ "simpletonic": simpletonic,
1438+ "singsong": singsong,
1439+ "submergement": submergement,
1440+ "supraoesophagal": supraoesophagal,
1441+ "thrashel": thrashel,
1442+ "tyremesis": tyremesis,
1443+ "Yoruba": yoruba,
1444+ };
1445+}
1446+
1447+class PrefreshmanClass {
1448+ final dynamic azorubine;
1449+ final dynamic choroiditis;
1450+ final dynamic coagulatory;
1451+ final dynamic cyclorama;
1452+ final dynamic dolphus;
1453+ final dynamic duckhearted;
1454+ final dynamic ficus;
1455+ final dynamic gemaric;
1456+ final dynamic jugation;
1457+ final dynamic myoliposis;
1458+ final dynamic nonnomination;
1459+ final dynamic palay;
1460+ final dynamic pentactinal;
1461+ final dynamic phaet;
1462+ final dynamic piquant;
1463+ final dynamic registration;
1464+ final dynamic remancipation;
1465+ final dynamic scutatiform;
1466+ final dynamic theodolite;
1467+ final dynamic underward;
1468+
1469+ PrefreshmanClass({
1470+ required this.azorubine,
1471+ required this.choroiditis,
1472+ required this.coagulatory,
1473+ required this.cyclorama,
1474+ required this.dolphus,
1475+ required this.duckhearted,
1476+ required this.ficus,
1477+ required this.gemaric,
1478+ required this.jugation,
1479+ required this.myoliposis,
1480+ required this.nonnomination,
1481+ required this.palay,
1482+ required this.pentactinal,
1483+ required this.phaet,
1484+ required this.piquant,
1485+ required this.registration,
1486+ required this.remancipation,
1487+ required this.scutatiform,
1488+ required this.theodolite,
1489+ required this.underward,
1490+ });
1491+
1492+ factory PrefreshmanClass.fromJson(Map<String, dynamic> json) => PrefreshmanClass(
1493+ azorubine: json["azorubine"],
1494+ choroiditis: json["choroiditis"],
1495+ coagulatory: json["coagulatory"],
1496+ cyclorama: json["cyclorama"],
1497+ dolphus: json["Dolphus"],
1498+ duckhearted: json["duckhearted"],
1499+ ficus: json["Ficus"],
1500+ gemaric: json["Gemaric"],
1501+ jugation: json["jugation"],
1502+ myoliposis: json["myoliposis"],
1503+ nonnomination: json["nonnomination"],
1504+ palay: json["palay"],
1505+ pentactinal: json["pentactinal"],
1506+ phaet: json["Phaet"],
1507+ piquant: json["piquant"],
1508+ registration: json["registration"],
1509+ remancipation: json["remancipation"],
1510+ scutatiform: json["scutatiform"],
1511+ theodolite: json["theodolite"],
1512+ underward: json["underward"],
1513+ );
1514+
1515+ Map<String, dynamic> toJson() => {
1516+ "azorubine": azorubine,
1517+ "choroiditis": choroiditis,
1518+ "coagulatory": coagulatory,
1519+ "cyclorama": cyclorama,
1520+ "Dolphus": dolphus,
1521+ "duckhearted": duckhearted,
1522+ "Ficus": ficus,
1523+ "Gemaric": gemaric,
1524+ "jugation": jugation,
1525+ "myoliposis": myoliposis,
1526+ "nonnomination": nonnomination,
1527+ "palay": palay,
1528+ "pentactinal": pentactinal,
1529+ "Phaet": phaet,
1530+ "piquant": piquant,
1531+ "registration": registration,
1532+ "remancipation": remancipation,
1533+ "scutatiform": scutatiform,
1534+ "theodolite": theodolite,
1535+ "underward": underward,
1536+ };
1537+}
Adartfinal-props-false--58a791807e0c / TopLevel.dart+1,537 −0
@@ -0,0 +1,1537 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ List<dynamic> juror;
13+ List<dynamic> kongoni;
14+ List<dynamic> ladronism;
15+ List<dynamic> landlubberly;
16+ List<dynamic> listener;
17+ List<dynamic> lupus;
18+ List<Maslin> maslin;
19+ List<dynamic> monazite;
20+ List<dynamic> monoliteral;
21+ List<dynamic> monotheistically;
22+ List<dynamic> montage;
23+ List<dynamic> moralness;
24+ List<MonaziteClass?> mowra;
25+ List<dynamic> mulishly;
26+ List<dynamic> myoscope;
27+ List<List<int?>?> nach;
28+ List<dynamic> neuromastic;
29+ List<Noncontributing> noncontributing;
30+ List<dynamic> nonnervous;
31+ List<dynamic> nonvaluation;
32+ List<dynamic> occupationalist;
33+ List<dynamic> outrival;
34+ List<dynamic> paleographically;
35+ List<dynamic> pamphletwise;
36+ List<dynamic> pediatrics;
37+ List<bool> perceptive;
38+ List<dynamic> piaculum;
39+ List<dynamic> piccadilly;
40+ List<dynamic> piffler;
41+ List<dynamic> pithful;
42+ List<dynamic> placuntitis;
43+ List<dynamic> plectopterous;
44+ List<Pneumocele?> pneumocele;
45+ List<dynamic> poliorcetic;
46+ List<dynamic> poormaster;
47+ List<dynamic> potwhisky;
48+ List<dynamic> practicalizer;
49+ List<dynamic> prefreshman;
50+ List<dynamic> prehensility;
51+ List<dynamic> prevoidance;
52+ List<Map<String, int?>> probant;
53+ List<dynamic> protext;
54+
55+ TopLevel({
56+ required this.juror,
57+ required this.kongoni,
58+ required this.ladronism,
59+ required this.landlubberly,
60+ required this.listener,
61+ required this.lupus,
62+ required this.maslin,
63+ required this.monazite,
64+ required this.monoliteral,
65+ required this.monotheistically,
66+ required this.montage,
67+ required this.moralness,
68+ required this.mowra,
69+ required this.mulishly,
70+ required this.myoscope,
71+ required this.nach,
72+ required this.neuromastic,
73+ required this.noncontributing,
74+ required this.nonnervous,
75+ required this.nonvaluation,
76+ required this.occupationalist,
77+ required this.outrival,
78+ required this.paleographically,
79+ required this.pamphletwise,
80+ required this.pediatrics,
81+ required this.perceptive,
82+ required this.piaculum,
83+ required this.piccadilly,
84+ required this.piffler,
85+ required this.pithful,
86+ required this.placuntitis,
87+ required this.plectopterous,
88+ required this.pneumocele,
89+ required this.poliorcetic,
90+ required this.poormaster,
91+ required this.potwhisky,
92+ required this.practicalizer,
93+ required this.prefreshman,
94+ required this.prehensility,
95+ required this.prevoidance,
96+ required this.probant,
97+ required this.protext,
98+ });
99+
100+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
101+ juror: List<dynamic>.from(json["juror"].map((x) => x)),
102+ kongoni: List<dynamic>.from(json["kongoni"].map((x) => x)),
103+ ladronism: List<dynamic>.from(json["ladronism"].map((x) => x)),
104+ landlubberly: List<dynamic>.from(json["landlubberly"].map((x) => x)),
105+ listener: List<dynamic>.from(json["listener"].map((x) => x)),
106+ lupus: List<dynamic>.from(json["lupus"].map((x) => x)),
107+ maslin: List<Maslin>.from(json["maslin"].map((x) => Maslin.fromJson(x))),
108+ monazite: List<dynamic>.from(json["monazite"].map((x) => x)),
109+ monoliteral: List<dynamic>.from(json["monoliteral"].map((x) => x)),
110+ monotheistically: List<dynamic>.from(json["monotheistically"].map((x) => x)),
111+ montage: List<dynamic>.from(json["montage"].map((x) => x)),
112+ moralness: List<dynamic>.from(json["moralness"].map((x) => x)),
113+ mowra: List<MonaziteClass?>.from(json["mowra"].map((x) => x == null ? null : MonaziteClass.fromJson(x))),
114+ mulishly: List<dynamic>.from(json["mulishly"].map((x) => x)),
115+ myoscope: List<dynamic>.from(json["myoscope"].map((x) => x)),
116+ nach: List<List<int?>?>.from(json["nach"].map((x) => x == null ? null : List<int?>.from(x!.map((x) => x)))),
117+ neuromastic: List<dynamic>.from(json["neuromastic"].map((x) => x)),
118+ noncontributing: List<Noncontributing>.from(json["noncontributing"].map((x) => Noncontributing.fromJson(x))),
119+ nonnervous: List<dynamic>.from(json["nonnervous"].map((x) => x)),
120+ nonvaluation: List<dynamic>.from(json["nonvaluation"].map((x) => x)),
121+ occupationalist: List<dynamic>.from(json["occupationalist"].map((x) => x)),
122+ outrival: List<dynamic>.from(json["outrival"].map((x) => x)),
123+ paleographically: List<dynamic>.from(json["paleographically"].map((x) => x)),
124+ pamphletwise: List<dynamic>.from(json["pamphletwise"].map((x) => x)),
125+ pediatrics: List<dynamic>.from(json["pediatrics"].map((x) => x)),
126+ perceptive: List<bool>.from(json["perceptive"].map((x) => x)),
127+ piaculum: List<dynamic>.from(json["piaculum"].map((x) => x)),
128+ piccadilly: List<dynamic>.from(json["piccadilly"].map((x) => x)),
129+ piffler: List<dynamic>.from(json["piffler"].map((x) => x)),
130+ pithful: List<dynamic>.from(json["pithful"].map((x) => x)),
131+ placuntitis: List<dynamic>.from(json["placuntitis"].map((x) => x)),
132+ plectopterous: List<dynamic>.from(json["plectopterous"].map((x) => x)),
133+ pneumocele: List<Pneumocele?>.from(json["pneumocele"].map((x) => x == null ? null : Pneumocele.fromJson(x))),
134+ poliorcetic: List<dynamic>.from(json["poliorcetic"].map((x) => x)),
135+ poormaster: List<dynamic>.from(json["poormaster"].map((x) => x)),
136+ potwhisky: List<dynamic>.from(json["potwhisky"].map((x) => x)),
137+ practicalizer: List<dynamic>.from(json["practicalizer"].map((x) => x)),
138+ prefreshman: List<dynamic>.from(json["prefreshman"].map((x) => x)),
139+ prehensility: List<dynamic>.from(json["prehensility"].map((x) => x)),
140+ prevoidance: List<dynamic>.from(json["prevoidance"].map((x) => x)),
141+ probant: List<Map<String, int?>>.from(json["probant"].map((x) => Map.from(x).map((k, v) => MapEntry<String, int?>(k, v)))),
142+ protext: List<dynamic>.from(json["protext"].map((x) => x)),
143+ );
144+
145+ Map<String, dynamic> toJson() => {
146+ "juror": List<dynamic>.from(juror.map((x) => x)),
147+ "kongoni": List<dynamic>.from(kongoni.map((x) => x)),
148+ "ladronism": List<dynamic>.from(ladronism.map((x) => x)),
149+ "landlubberly": List<dynamic>.from(landlubberly.map((x) => x)),
150+ "listener": List<dynamic>.from(listener.map((x) => x)),
151+ "lupus": List<dynamic>.from(lupus.map((x) => x)),
152+ "maslin": List<dynamic>.from(maslin.map((x) => x.toJson())),
153+ "monazite": List<dynamic>.from(monazite.map((x) => x)),
154+ "monoliteral": List<dynamic>.from(monoliteral.map((x) => x)),
155+ "monotheistically": List<dynamic>.from(monotheistically.map((x) => x)),
156+ "montage": List<dynamic>.from(montage.map((x) => x)),
157+ "moralness": List<dynamic>.from(moralness.map((x) => x)),
158+ "mowra": List<dynamic>.from(mowra.map((x) => x?.toJson())),
159+ "mulishly": List<dynamic>.from(mulishly.map((x) => x)),
160+ "myoscope": List<dynamic>.from(myoscope.map((x) => x)),
161+ "nach": List<dynamic>.from(nach.map((x) => x == null ? null : List<dynamic>.from(x!.map((x) => x)))),
162+ "neuromastic": List<dynamic>.from(neuromastic.map((x) => x)),
163+ "noncontributing": List<dynamic>.from(noncontributing.map((x) => x.toJson())),
164+ "nonnervous": List<dynamic>.from(nonnervous.map((x) => x)),
165+ "nonvaluation": List<dynamic>.from(nonvaluation.map((x) => x)),
166+ "occupationalist": List<dynamic>.from(occupationalist.map((x) => x)),
167+ "outrival": List<dynamic>.from(outrival.map((x) => x)),
168+ "paleographically": List<dynamic>.from(paleographically.map((x) => x)),
169+ "pamphletwise": List<dynamic>.from(pamphletwise.map((x) => x)),
170+ "pediatrics": List<dynamic>.from(pediatrics.map((x) => x)),
171+ "perceptive": List<dynamic>.from(perceptive.map((x) => x)),
172+ "piaculum": List<dynamic>.from(piaculum.map((x) => x)),
173+ "piccadilly": List<dynamic>.from(piccadilly.map((x) => x)),
174+ "piffler": List<dynamic>.from(piffler.map((x) => x)),
175+ "pithful": List<dynamic>.from(pithful.map((x) => x)),
176+ "placuntitis": List<dynamic>.from(placuntitis.map((x) => x)),
177+ "plectopterous": List<dynamic>.from(plectopterous.map((x) => x)),
178+ "pneumocele": List<dynamic>.from(pneumocele.map((x) => x?.toJson())),
179+ "poliorcetic": List<dynamic>.from(poliorcetic.map((x) => x)),
180+ "poormaster": List<dynamic>.from(poormaster.map((x) => x)),
181+ "potwhisky": List<dynamic>.from(potwhisky.map((x) => x)),
182+ "practicalizer": List<dynamic>.from(practicalizer.map((x) => x)),
183+ "prefreshman": List<dynamic>.from(prefreshman.map((x) => x)),
184+ "prehensility": List<dynamic>.from(prehensility.map((x) => x)),
185+ "prevoidance": List<dynamic>.from(prevoidance.map((x) => x)),
186+ "probant": List<dynamic>.from(probant.map((x) => Map.from(x).map((k, v) => MapEntry<String, dynamic>(k, v)))),
187+ "protext": List<dynamic>.from(protext.map((x) => x)),
188+ };
189+}
190+
191+class JurorClass {
192+ dynamic adipsy;
193+ dynamic auxiliator;
194+ dynamic benda;
195+ dynamic benjamin;
196+ dynamic brandling;
197+ dynamic epicurishly;
198+ dynamic eremochaetous;
199+ dynamic marten;
200+ dynamic monocline;
201+ dynamic olea;
202+ dynamic palgat;
203+ dynamic pennyworth;
204+ dynamic pioury;
205+ dynamic pragmatistic;
206+ dynamic stylelessness;
207+ dynamic systematical;
208+ dynamic thready;
209+ dynamic uncontemporary;
210+ dynamic uncouched;
211+ dynamic uninhabitedness;
212+
213+ JurorClass({
214+ required this.adipsy,
215+ required this.auxiliator,
216+ required this.benda,
217+ required this.benjamin,
218+ required this.brandling,
219+ required this.epicurishly,
220+ required this.eremochaetous,
221+ required this.marten,
222+ required this.monocline,
223+ required this.olea,
224+ required this.palgat,
225+ required this.pennyworth,
226+ required this.pioury,
227+ required this.pragmatistic,
228+ required this.stylelessness,
229+ required this.systematical,
230+ required this.thready,
231+ required this.uncontemporary,
232+ required this.uncouched,
233+ required this.uninhabitedness,
234+ });
235+
236+ factory JurorClass.fromJson(Map<String, dynamic> json) => JurorClass(
237+ adipsy: json["adipsy"],
238+ auxiliator: json["auxiliator"],
239+ benda: json["benda"],
240+ benjamin: json["benjamin"],
241+ brandling: json["brandling"],
242+ epicurishly: json["epicurishly"],
243+ eremochaetous: json["eremochaetous"],
244+ marten: json["marten"],
245+ monocline: json["monocline"],
246+ olea: json["Olea"],
247+ palgat: json["palgat"],
248+ pennyworth: json["pennyworth"],
249+ pioury: json["pioury"],
250+ pragmatistic: json["pragmatistic"],
251+ stylelessness: json["stylelessness"],
252+ systematical: json["systematical"],
253+ thready: json["thready"],
254+ uncontemporary: json["uncontemporary"],
255+ uncouched: json["uncouched"],
256+ uninhabitedness: json["uninhabitedness"],
257+ );
258+
259+ Map<String, dynamic> toJson() => {
260+ "adipsy": adipsy,
261+ "auxiliator": auxiliator,
262+ "benda": benda,
263+ "benjamin": benjamin,
264+ "brandling": brandling,
265+ "epicurishly": epicurishly,
266+ "eremochaetous": eremochaetous,
267+ "marten": marten,
268+ "monocline": monocline,
269+ "Olea": olea,
270+ "palgat": palgat,
271+ "pennyworth": pennyworth,
272+ "pioury": pioury,
273+ "pragmatistic": pragmatistic,
274+ "stylelessness": stylelessness,
275+ "systematical": systematical,
276+ "thready": thready,
277+ "uncontemporary": uncontemporary,
278+ "uncouched": uncouched,
279+ "uninhabitedness": uninhabitedness,
280+ };
281+}
282+
283+class LadronismClass {
284+ dynamic acclaimer;
285+ dynamic achree;
286+ dynamic base;
287+ dynamic conundrumize;
288+ dynamic degerminator;
289+ dynamic describable;
290+ dynamic exasperatedly;
291+ dynamic heroine;
292+ dynamic indazin;
293+ dynamic luteous;
294+ dynamic papular;
295+ dynamic pritch;
296+ dynamic prodenia;
297+ dynamic seege;
298+ dynamic shopgirl;
299+ dynamic tragedietta;
300+ dynamic unsparse;
301+ dynamic uplook;
302+ dynamic vermiformis;
303+ dynamic whafabout;
304+
305+ LadronismClass({
306+ required this.acclaimer,
307+ required this.achree,
308+ required this.base,
309+ required this.conundrumize,
310+ required this.degerminator,
311+ required this.describable,
312+ required this.exasperatedly,
313+ required this.heroine,
314+ required this.indazin,
315+ required this.luteous,
316+ required this.papular,
317+ required this.pritch,
318+ required this.prodenia,
319+ required this.seege,
320+ required this.shopgirl,
321+ required this.tragedietta,
322+ required this.unsparse,
323+ required this.uplook,
324+ required this.vermiformis,
325+ required this.whafabout,
326+ });
327+
328+ factory LadronismClass.fromJson(Map<String, dynamic> json) => LadronismClass(
329+ acclaimer: json["acclaimer"],
330+ achree: json["achree"],
331+ base: json["base"],
332+ conundrumize: json["conundrumize"],
333+ degerminator: json["degerminator"],
334+ describable: json["describable"],
335+ exasperatedly: json["exasperatedly"],
336+ heroine: json["heroine"],
337+ indazin: json["indazin"],
338+ luteous: json["luteous"],
339+ papular: json["papular"],
340+ pritch: json["pritch"],
341+ prodenia: json["Prodenia"],
342+ seege: json["seege"],
343+ shopgirl: json["shopgirl"],
344+ tragedietta: json["tragedietta"],
345+ unsparse: json["unsparse"],
346+ uplook: json["uplook"],
347+ vermiformis: json["vermiformis"],
348+ whafabout: json["whafabout"],
349+ );
350+
351+ Map<String, dynamic> toJson() => {
352+ "acclaimer": acclaimer,
353+ "achree": achree,
354+ "base": base,
355+ "conundrumize": conundrumize,
356+ "degerminator": degerminator,
357+ "describable": describable,
358+ "exasperatedly": exasperatedly,
359+ "heroine": heroine,
360+ "indazin": indazin,
361+ "luteous": luteous,
362+ "papular": papular,
363+ "pritch": pritch,
364+ "Prodenia": prodenia,
365+ "seege": seege,
366+ "shopgirl": shopgirl,
367+ "tragedietta": tragedietta,
368+ "unsparse": unsparse,
369+ "uplook": uplook,
370+ "vermiformis": vermiformis,
371+ "whafabout": whafabout,
372+ };
373+}
374+
375+class LandlubberlyClass {
376+ dynamic acropoleis;
377+ dynamic aminate;
378+ dynamic amyraldism;
379+ dynamic bipenniform;
380+ dynamic bugre;
381+ dynamic calycule;
382+ dynamic caoutchouc;
383+ dynamic disprover;
384+ dynamic fitroot;
385+ dynamic fulgently;
386+ dynamic kickup;
387+ dynamic laevoversion;
388+ dynamic moter;
389+ dynamic objectivity;
390+ dynamic posterity;
391+ dynamic postnuptial;
392+ dynamic precedentary;
393+ dynamic saddling;
394+ dynamic subcurrent;
395+ dynamic unrecriminative;
396+
397+ LandlubberlyClass({
398+ required this.acropoleis,
399+ required this.aminate,
400+ required this.amyraldism,
401+ required this.bipenniform,
402+ required this.bugre,
403+ required this.calycule,
404+ required this.caoutchouc,
405+ required this.disprover,
406+ required this.fitroot,
407+ required this.fulgently,
408+ required this.kickup,
409+ required this.laevoversion,
410+ required this.moter,
411+ required this.objectivity,
412+ required this.posterity,
413+ required this.postnuptial,
414+ required this.precedentary,
415+ required this.saddling,
416+ required this.subcurrent,
417+ required this.unrecriminative,
418+ });
419+
420+ factory LandlubberlyClass.fromJson(Map<String, dynamic> json) => LandlubberlyClass(
421+ acropoleis: json["acropoleis"],
422+ aminate: json["aminate"],
423+ amyraldism: json["Amyraldism"],
424+ bipenniform: json["bipenniform"],
425+ bugre: json["bugre"],
426+ calycule: json["calycule"],
427+ caoutchouc: json["caoutchouc"],
428+ disprover: json["disprover"],
429+ fitroot: json["fitroot"],
430+ fulgently: json["fulgently"],
431+ kickup: json["kickup"],
432+ laevoversion: json["laevoversion"],
433+ moter: json["moter"],
434+ objectivity: json["objectivity"],
435+ posterity: json["posterity"],
436+ postnuptial: json["postnuptial"],
437+ precedentary: json["precedentary"],
438+ saddling: json["saddling"],
439+ subcurrent: json["subcurrent"],
440+ unrecriminative: json["unrecriminative"],
441+ );
442+
443+ Map<String, dynamic> toJson() => {
444+ "acropoleis": acropoleis,
445+ "aminate": aminate,
446+ "Amyraldism": amyraldism,
447+ "bipenniform": bipenniform,
448+ "bugre": bugre,
449+ "calycule": calycule,
450+ "caoutchouc": caoutchouc,
451+ "disprover": disprover,
452+ "fitroot": fitroot,
453+ "fulgently": fulgently,
454+ "kickup": kickup,
455+ "laevoversion": laevoversion,
456+ "moter": moter,
457+ "objectivity": objectivity,
458+ "posterity": posterity,
459+ "postnuptial": postnuptial,
460+ "precedentary": precedentary,
461+ "saddling": saddling,
462+ "subcurrent": subcurrent,
463+ "unrecriminative": unrecriminative,
464+ };
465+}
466+
467+class LupusClass {
468+ double? catharticalness;
469+ int? chirotherium;
470+ int? chlorioninae;
471+ int? corvinae;
472+ int? crassina;
473+ String? disdiapason;
474+ int? exiguity;
475+ int? farcist;
476+ int? holographical;
477+ bool? homocerc;
478+ int? ichthyophagan;
479+ int? implacable;
480+ dynamic nonbookish;
481+ int? outshiner;
482+ int? overweather;
483+ int? protonegroid;
484+ int? shallowish;
485+ int? snoke;
486+ int? snout;
487+ int? surveillance;
488+ int? threshingtime;
489+ int? thysanocarpus;
490+ int? unsignificantly;
491+ int? unsnap;
492+ int? vendible;
493+
494+ LupusClass({
495+ this.catharticalness,
496+ this.chirotherium,
497+ this.chlorioninae,
498+ this.corvinae,
499+ this.crassina,
500+ this.disdiapason,
501+ this.exiguity,
502+ this.farcist,
503+ this.holographical,
504+ this.homocerc,
505+ this.ichthyophagan,
506+ this.implacable,
507+ this.nonbookish,
508+ this.outshiner,
509+ this.overweather,
510+ this.protonegroid,
511+ this.shallowish,
512+ this.snoke,
513+ this.snout,
514+ this.surveillance,
515+ this.threshingtime,
516+ this.thysanocarpus,
517+ this.unsignificantly,
518+ this.unsnap,
519+ this.vendible,
520+ });
521+
522+ factory LupusClass.fromJson(Map<String, dynamic> json) => LupusClass(
523+ catharticalness: json["catharticalness"]?.toDouble(),
524+ chirotherium: json["Chirotherium"],
525+ chlorioninae: json["Chlorioninae"],
526+ corvinae: json["Corvinae"],
527+ crassina: json["Crassina"],
528+ disdiapason: json["disdiapason"],
529+ exiguity: json["exiguity"],
530+ farcist: json["farcist"],
531+ holographical: json["holographical"],
532+ homocerc: json["homocerc"],
533+ ichthyophagan: json["ichthyophagan"],
534+ implacable: json["implacable"],
535+ nonbookish: json["nonbookish"],
536+ outshiner: json["outshiner"],
537+ overweather: json["overweather"],
538+ protonegroid: json["protonegroid"],
539+ shallowish: json["shallowish"],
540+ snoke: json["snoke"],
541+ snout: json["snout"],
542+ surveillance: json["surveillance"],
543+ threshingtime: json["threshingtime"],
544+ thysanocarpus: json["Thysanocarpus"],
545+ unsignificantly: json["unsignificantly"],
546+ unsnap: json["unsnap"],
547+ vendible: json["vendible"],
548+ );
549+
550+ Map<String, dynamic> toJson() => {
551+ "catharticalness": catharticalness,
552+ "Chirotherium": chirotherium,
553+ "Chlorioninae": chlorioninae,
554+ "Corvinae": corvinae,
555+ "Crassina": crassina,
556+ "disdiapason": disdiapason,
557+ "exiguity": exiguity,
558+ "farcist": farcist,
559+ "holographical": holographical,
560+ "homocerc": homocerc,
561+ "ichthyophagan": ichthyophagan,
562+ "implacable": implacable,
563+ "nonbookish": nonbookish,
564+ "outshiner": outshiner,
565+ "overweather": overweather,
566+ "protonegroid": protonegroid,
567+ "shallowish": shallowish,
568+ "snoke": snoke,
569+ "snout": snout,
570+ "surveillance": surveillance,
571+ "threshingtime": threshingtime,
572+ "Thysanocarpus": thysanocarpus,
573+ "unsignificantly": unsignificantly,
574+ "unsnap": unsnap,
575+ "vendible": vendible,
576+ };
577+}
578+
579+class Maslin {
580+ int? alicant;
581+ dynamic antiatonement;
582+ int? anticorrosive;
583+ dynamic aphidozer;
584+ dynamic bakuninist;
585+ int? be;
586+ double? catharticalness;
587+ int? chirotherium;
588+ int? chub;
589+ int? cuprosilicon;
590+ int? curtailedly;
591+ int? dellenite;
592+ int? dimitry;
593+ String? disdiapason;
594+ dynamic edifying;
595+ int? ethmoiditis;
596+ dynamic gastralgy;
597+ int? goatherd;
598+ int? hammerdress;
599+ dynamic hangfire;
600+ bool? homocerc;
601+ int? lacunosity;
602+ dynamic longiloquence;
603+ int? mameliere;
604+ dynamic motherless;
605+ dynamic nonbookish;
606+ dynamic noncorrodible;
607+ dynamic nonsensicality;
608+ int? oafishly;
609+ dynamic pfund;
610+ dynamic preadvisory;
611+ dynamic retroflexed;
612+ int? saccharulmic;
613+ int? scowlful;
614+ dynamic secluded;
615+ dynamic slackage;
616+ int? sphaeridial;
617+ dynamic spondulics;
618+ int? subsecive;
619+ dynamic swellmobsman;
620+ int? trachyglossate;
621+ dynamic trialogue;
622+ int? unassuaged;
623+ dynamic ungross;
624+ dynamic unjudiciously;
625+
626+ Maslin({
627+ this.alicant,
628+ this.antiatonement,
629+ this.anticorrosive,
630+ this.aphidozer,
631+ this.bakuninist,
632+ this.be,
633+ this.catharticalness,
634+ this.chirotherium,
635+ this.chub,
636+ this.cuprosilicon,
637+ this.curtailedly,
638+ this.dellenite,
639+ this.dimitry,
640+ this.disdiapason,
641+ this.edifying,
642+ this.ethmoiditis,
643+ this.gastralgy,
644+ this.goatherd,
645+ this.hammerdress,
646+ this.hangfire,
647+ this.homocerc,
648+ this.lacunosity,
649+ this.longiloquence,
650+ this.mameliere,
651+ this.motherless,
652+ this.nonbookish,
653+ this.noncorrodible,
654+ this.nonsensicality,
655+ this.oafishly,
656+ this.pfund,
657+ this.preadvisory,
658+ this.retroflexed,
659+ this.saccharulmic,
660+ this.scowlful,
661+ this.secluded,
662+ this.slackage,
663+ this.sphaeridial,
664+ this.spondulics,
665+ this.subsecive,
666+ this.swellmobsman,
667+ this.trachyglossate,
668+ this.trialogue,
669+ this.unassuaged,
670+ this.ungross,
671+ this.unjudiciously,
672+ });
673+
674+ factory Maslin.fromJson(Map<String, dynamic> json) => Maslin(
675+ alicant: json["Alicant"],
676+ antiatonement: json["antiatonement"],
677+ anticorrosive: json["anticorrosive"],
678+ aphidozer: json["aphidozer"],
679+ bakuninist: json["Bakuninist"],
680+ be: json["be"],
681+ catharticalness: json["catharticalness"]?.toDouble(),
682+ chirotherium: json["Chirotherium"],
683+ chub: json["chub"],
684+ cuprosilicon: json["cuprosilicon"],
685+ curtailedly: json["curtailedly"],
686+ dellenite: json["dellenite"],
687+ dimitry: json["Dimitry"],
688+ disdiapason: json["disdiapason"],
689+ edifying: json["edifying"],
690+ ethmoiditis: json["ethmoiditis"],
691+ gastralgy: json["gastralgy"],
692+ goatherd: json["goatherd"],
693+ hammerdress: json["hammerdress"],
694+ hangfire: json["hangfire"],
695+ homocerc: json["homocerc"],
696+ lacunosity: json["lacunosity"],
697+ longiloquence: json["longiloquence"],
698+ mameliere: json["mameliere"],
699+ motherless: json["motherless"],
700+ nonbookish: json["nonbookish"],
701+ noncorrodible: json["noncorrodible"],
702+ nonsensicality: json["nonsensicality"],
703+ oafishly: json["oafishly"],
704+ pfund: json["pfund"],
705+ preadvisory: json["preadvisory"],
706+ retroflexed: json["retroflexed"],
707+ saccharulmic: json["saccharulmic"],
708+ scowlful: json["scowlful"],
709+ secluded: json["secluded"],
710+ slackage: json["slackage"],
711+ sphaeridial: json["sphaeridial"],
712+ spondulics: json["spondulics"],
713+ subsecive: json["subsecive"],
714+ swellmobsman: json["swellmobsman"],
715+ trachyglossate: json["trachyglossate"],
716+ trialogue: json["trialogue"],
717+ unassuaged: json["unassuaged"],
718+ ungross: json["ungross"],
719+ unjudiciously: json["unjudiciously"],
720+ );
721+
722+ Map<String, dynamic> toJson() => {
723+ "Alicant": alicant,
724+ "antiatonement": antiatonement,
725+ "anticorrosive": anticorrosive,
726+ "aphidozer": aphidozer,
727+ "Bakuninist": bakuninist,
728+ "be": be,
729+ "catharticalness": catharticalness,
730+ "Chirotherium": chirotherium,
731+ "chub": chub,
732+ "cuprosilicon": cuprosilicon,
733+ "curtailedly": curtailedly,
734+ "dellenite": dellenite,
735+ "Dimitry": dimitry,
736+ "disdiapason": disdiapason,
737+ "edifying": edifying,
738+ "ethmoiditis": ethmoiditis,
739+ "gastralgy": gastralgy,
740+ "goatherd": goatherd,
741+ "hammerdress": hammerdress,
742+ "hangfire": hangfire,
743+ "homocerc": homocerc,
744+ "lacunosity": lacunosity,
745+ "longiloquence": longiloquence,
746+ "mameliere": mameliere,
747+ "motherless": motherless,
748+ "nonbookish": nonbookish,
749+ "noncorrodible": noncorrodible,
750+ "nonsensicality": nonsensicality,
751+ "oafishly": oafishly,
752+ "pfund": pfund,
753+ "preadvisory": preadvisory,
754+ "retroflexed": retroflexed,
755+ "saccharulmic": saccharulmic,
756+ "scowlful": scowlful,
757+ "secluded": secluded,
758+ "slackage": slackage,
759+ "sphaeridial": sphaeridial,
760+ "spondulics": spondulics,
761+ "subsecive": subsecive,
762+ "swellmobsman": swellmobsman,
763+ "trachyglossate": trachyglossate,
764+ "trialogue": trialogue,
765+ "unassuaged": unassuaged,
766+ "ungross": ungross,
767+ "unjudiciously": unjudiciously,
768+ };
769+}
770+
771+class MonaziteClass {
772+ double catharticalness;
773+ int chirotherium;
774+ String disdiapason;
775+ bool homocerc;
776+ dynamic nonbookish;
777+
778+ MonaziteClass({
779+ required this.catharticalness,
780+ required this.chirotherium,
781+ required this.disdiapason,
782+ required this.homocerc,
783+ required this.nonbookish,
784+ });
785+
786+ factory MonaziteClass.fromJson(Map<String, dynamic> json) => MonaziteClass(
787+ catharticalness: json["catharticalness"]?.toDouble(),
788+ chirotherium: json["Chirotherium"],
789+ disdiapason: json["disdiapason"],
790+ homocerc: json["homocerc"],
791+ nonbookish: json["nonbookish"],
792+ );
793+
794+ Map<String, dynamic> toJson() => {
795+ "catharticalness": catharticalness,
796+ "Chirotherium": chirotherium,
797+ "disdiapason": disdiapason,
798+ "homocerc": homocerc,
799+ "nonbookish": nonbookish,
800+ };
801+}
802+
803+class MonotheisticallyClass {
804+ dynamic blaspheme;
805+ double? catharticalness;
806+ dynamic celiosalpingectomy;
807+ int? chirotherium;
808+ dynamic consummativeness;
809+ String? disdiapason;
810+ dynamic egestive;
811+ dynamic enchylema;
812+ dynamic gasconade;
813+ dynamic holidayer;
814+ bool? homocerc;
815+ dynamic intuitionalism;
816+ dynamic lophiostomate;
817+ dynamic nonbookish;
818+ dynamic nonvolition;
819+ dynamic palatableness;
820+ dynamic pimpery;
821+ dynamic previolation;
822+ dynamic reconveyance;
823+ dynamic registership;
824+ dynamic rhyacolite;
825+ dynamic smithereens;
826+ dynamic superedification;
827+ dynamic trust;
828+ dynamic whitestone;
829+
830+ MonotheisticallyClass({
831+ this.blaspheme,
832+ this.catharticalness,
833+ this.celiosalpingectomy,
834+ this.chirotherium,
835+ this.consummativeness,
836+ this.disdiapason,
837+ this.egestive,
838+ this.enchylema,
839+ this.gasconade,
840+ this.holidayer,
841+ this.homocerc,
842+ this.intuitionalism,
843+ this.lophiostomate,
844+ this.nonbookish,
845+ this.nonvolition,
846+ this.palatableness,
847+ this.pimpery,
848+ this.previolation,
849+ this.reconveyance,
850+ this.registership,
851+ this.rhyacolite,
852+ this.smithereens,
853+ this.superedification,
854+ this.trust,
855+ this.whitestone,
856+ });
857+
858+ factory MonotheisticallyClass.fromJson(Map<String, dynamic> json) => MonotheisticallyClass(
859+ blaspheme: json["blaspheme"],
860+ catharticalness: json["catharticalness"]?.toDouble(),
861+ celiosalpingectomy: json["celiosalpingectomy"],
862+ chirotherium: json["Chirotherium"],
863+ consummativeness: json["consummativeness"],
864+ disdiapason: json["disdiapason"],
865+ egestive: json["egestive"],
866+ enchylema: json["enchylema"],
867+ gasconade: json["gasconade"],
868+ holidayer: json["holidayer"],
869+ homocerc: json["homocerc"],
870+ intuitionalism: json["intuitionalism"],
871+ lophiostomate: json["lophiostomate"],
872+ nonbookish: json["nonbookish"],
873+ nonvolition: json["nonvolition"],
874+ palatableness: json["palatableness"],
875+ pimpery: json["pimpery"],
876+ previolation: json["previolation"],
877+ reconveyance: json["reconveyance"],
878+ registership: json["registership"],
879+ rhyacolite: json["rhyacolite"],
880+ smithereens: json["smithereens"],
881+ superedification: json["superedification"],
882+ trust: json["trust"],
883+ whitestone: json["whitestone"],
884+ );
885+
886+ Map<String, dynamic> toJson() => {
887+ "blaspheme": blaspheme,
888+ "catharticalness": catharticalness,
889+ "celiosalpingectomy": celiosalpingectomy,
890+ "Chirotherium": chirotherium,
891+ "consummativeness": consummativeness,
892+ "disdiapason": disdiapason,
893+ "egestive": egestive,
894+ "enchylema": enchylema,
895+ "gasconade": gasconade,
896+ "holidayer": holidayer,
897+ "homocerc": homocerc,
898+ "intuitionalism": intuitionalism,
899+ "lophiostomate": lophiostomate,
900+ "nonbookish": nonbookish,
901+ "nonvolition": nonvolition,
902+ "palatableness": palatableness,
903+ "pimpery": pimpery,
904+ "previolation": previolation,
905+ "reconveyance": reconveyance,
906+ "registership": registership,
907+ "rhyacolite": rhyacolite,
908+ "smithereens": smithereens,
909+ "superedification": superedification,
910+ "trust": trust,
911+ "whitestone": whitestone,
912+ };
913+}
914+
915+class Noncontributing {
916+ String estevin;
917+ double jolterhead;
918+ int sauternes;
919+ bool sparsely;
920+ dynamic unrequested;
921+
922+ Noncontributing({
923+ required this.estevin,
924+ required this.jolterhead,
925+ required this.sauternes,
926+ required this.sparsely,
927+ required this.unrequested,
928+ });
929+
930+ factory Noncontributing.fromJson(Map<String, dynamic> json) => Noncontributing(
931+ estevin: json["estevin"],
932+ jolterhead: json["jolterhead"]?.toDouble(),
933+ sauternes: json["sauternes"],
934+ sparsely: json["sparsely"],
935+ unrequested: json["unrequested"],
936+ );
937+
938+ Map<String, dynamic> toJson() => {
939+ "estevin": estevin,
940+ "jolterhead": jolterhead,
941+ "sauternes": sauternes,
942+ "sparsely": sparsely,
943+ "unrequested": unrequested,
944+ };
945+}
946+
947+class OccupationalistClass {
948+ dynamic beholdable;
949+ dynamic brotuliform;
950+ dynamic chimakum;
951+ dynamic doodler;
952+ dynamic emulsin;
953+ dynamic fin;
954+ dynamic flourishing;
955+ dynamic flueless;
956+ dynamic furtively;
957+ dynamic gritter;
958+ dynamic interwish;
959+ dynamic monoxylic;
960+ dynamic myristic;
961+ dynamic nightwear;
962+ dynamic peruser;
963+ dynamic theoastrological;
964+ dynamic thumby;
965+ dynamic tingitid;
966+ dynamic trailless;
967+ dynamic unpocketed;
968+
969+ OccupationalistClass({
970+ required this.beholdable,
971+ required this.brotuliform,
972+ required this.chimakum,
973+ required this.doodler,
974+ required this.emulsin,
975+ required this.fin,
976+ required this.flourishing,
977+ required this.flueless,
978+ required this.furtively,
979+ required this.gritter,
980+ required this.interwish,
981+ required this.monoxylic,
982+ required this.myristic,
983+ required this.nightwear,
984+ required this.peruser,
985+ required this.theoastrological,
986+ required this.thumby,
987+ required this.tingitid,
988+ required this.trailless,
989+ required this.unpocketed,
990+ });
991+
992+ factory OccupationalistClass.fromJson(Map<String, dynamic> json) => OccupationalistClass(
993+ beholdable: json["beholdable"],
994+ brotuliform: json["brotuliform"],
995+ chimakum: json["Chimakum"],
996+ doodler: json["doodler"],
997+ emulsin: json["emulsin"],
998+ fin: json["Fin"],
999+ flourishing: json["flourishing"],
1000+ flueless: json["flueless"],
1001+ furtively: json["furtively"],
1002+ gritter: json["gritter"],
1003+ interwish: json["interwish"],
1004+ monoxylic: json["monoxylic"],
1005+ myristic: json["myristic"],
1006+ nightwear: json["nightwear"],
1007+ peruser: json["peruser"],
1008+ theoastrological: json["theoastrological"],
1009+ thumby: json["thumby"],
1010+ tingitid: json["tingitid"],
1011+ trailless: json["trailless"],
1012+ unpocketed: json["unpocketed"],
1013+ );
1014+
1015+ Map<String, dynamic> toJson() => {
1016+ "beholdable": beholdable,
1017+ "brotuliform": brotuliform,
1018+ "Chimakum": chimakum,
1019+ "doodler": doodler,
1020+ "emulsin": emulsin,
1021+ "Fin": fin,
1022+ "flourishing": flourishing,
1023+ "flueless": flueless,
1024+ "furtively": furtively,
1025+ "gritter": gritter,
1026+ "interwish": interwish,
1027+ "monoxylic": monoxylic,
1028+ "myristic": myristic,
1029+ "nightwear": nightwear,
1030+ "peruser": peruser,
1031+ "theoastrological": theoastrological,
1032+ "thumby": thumby,
1033+ "tingitid": tingitid,
1034+ "trailless": trailless,
1035+ "unpocketed": unpocketed,
1036+ };
1037+}
1038+
1039+class OutrivalClass {
1040+ dynamic adroitly;
1041+ dynamic bridehood;
1042+ dynamic castoroides;
1043+ dynamic czechoslovak;
1044+ dynamic diagenesis;
1045+ dynamic dihexahedron;
1046+ dynamic dopester;
1047+ dynamic eumerism;
1048+ dynamic flyness;
1049+ dynamic fouler;
1050+ dynamic laudanosine;
1051+ dynamic lingulidae;
1052+ dynamic minutary;
1053+ dynamic mitra;
1054+ dynamic opisthorchiasis;
1055+ dynamic pensively;
1056+ dynamic pubigerous;
1057+ dynamic rebellious;
1058+ dynamic recodify;
1059+ dynamic unpaced;
1060+
1061+ OutrivalClass({
1062+ required this.adroitly,
1063+ required this.bridehood,
1064+ required this.castoroides,
1065+ required this.czechoslovak,
1066+ required this.diagenesis,
1067+ required this.dihexahedron,
1068+ required this.dopester,
1069+ required this.eumerism,
1070+ required this.flyness,
1071+ required this.fouler,
1072+ required this.laudanosine,
1073+ required this.lingulidae,
1074+ required this.minutary,
1075+ required this.mitra,
1076+ required this.opisthorchiasis,
1077+ required this.pensively,
1078+ required this.pubigerous,
1079+ required this.rebellious,
1080+ required this.recodify,
1081+ required this.unpaced,
1082+ });
1083+
1084+ factory OutrivalClass.fromJson(Map<String, dynamic> json) => OutrivalClass(
1085+ adroitly: json["adroitly"],
1086+ bridehood: json["bridehood"],
1087+ castoroides: json["Castoroides"],
1088+ czechoslovak: json["Czechoslovak"],
1089+ diagenesis: json["diagenesis"],
1090+ dihexahedron: json["dihexahedron"],
1091+ dopester: json["dopester"],
1092+ eumerism: json["eumerism"],
1093+ flyness: json["flyness"],
1094+ fouler: json["fouler"],
1095+ laudanosine: json["laudanosine"],
1096+ lingulidae: json["Lingulidae"],
1097+ minutary: json["minutary"],
1098+ mitra: json["mitra"],
1099+ opisthorchiasis: json["opisthorchiasis"],
1100+ pensively: json["pensively"],
1101+ pubigerous: json["pubigerous"],
1102+ rebellious: json["rebellious"],
1103+ recodify: json["recodify"],
1104+ unpaced: json["unpaced"],
1105+ );
1106+
1107+ Map<String, dynamic> toJson() => {
1108+ "adroitly": adroitly,
1109+ "bridehood": bridehood,
1110+ "Castoroides": castoroides,
1111+ "Czechoslovak": czechoslovak,
1112+ "diagenesis": diagenesis,
1113+ "dihexahedron": dihexahedron,
1114+ "dopester": dopester,
1115+ "eumerism": eumerism,
1116+ "flyness": flyness,
1117+ "fouler": fouler,
1118+ "laudanosine": laudanosine,
1119+ "Lingulidae": lingulidae,
1120+ "minutary": minutary,
1121+ "mitra": mitra,
1122+ "opisthorchiasis": opisthorchiasis,
1123+ "pensively": pensively,
1124+ "pubigerous": pubigerous,
1125+ "rebellious": rebellious,
1126+ "recodify": recodify,
1127+ "unpaced": unpaced,
1128+ };
1129+}
1130+
1131+class PiaculumClass {
1132+ int? alada;
1133+ int? amphistomous;
1134+ int? boysenberry;
1135+ double? catharticalness;
1136+ int? chirotherium;
1137+ int? decardinalize;
1138+ int? discouragement;
1139+ String? disdiapason;
1140+ int? doitrified;
1141+ int? hexaspermous;
1142+ bool? homocerc;
1143+ int? insinking;
1144+ int? loathfulness;
1145+ int? miasmatical;
1146+ int? neurofibril;
1147+ dynamic nonbookish;
1148+ int? phonendoscope;
1149+ int? pilferment;
1150+ int? predismissory;
1151+ int? preinscription;
1152+ int? quotative;
1153+ int? sienna;
1154+ int? thorax;
1155+ int? yachting;
1156+ int? zipper;
1157+
1158+ PiaculumClass({
1159+ this.alada,
1160+ this.amphistomous,
1161+ this.boysenberry,
1162+ this.catharticalness,
1163+ this.chirotherium,
1164+ this.decardinalize,
1165+ this.discouragement,
1166+ this.disdiapason,
1167+ this.doitrified,
1168+ this.hexaspermous,
1169+ this.homocerc,
1170+ this.insinking,
1171+ this.loathfulness,
1172+ this.miasmatical,
1173+ this.neurofibril,
1174+ this.nonbookish,
1175+ this.phonendoscope,
1176+ this.pilferment,
1177+ this.predismissory,
1178+ this.preinscription,
1179+ this.quotative,
1180+ this.sienna,
1181+ this.thorax,
1182+ this.yachting,
1183+ this.zipper,
1184+ });
1185+
1186+ factory PiaculumClass.fromJson(Map<String, dynamic> json) => PiaculumClass(
1187+ alada: json["alada"],
1188+ amphistomous: json["amphistomous"],
1189+ boysenberry: json["boysenberry"],
1190+ catharticalness: json["catharticalness"]?.toDouble(),
1191+ chirotherium: json["Chirotherium"],
1192+ decardinalize: json["decardinalize"],
1193+ discouragement: json["discouragement"],
1194+ disdiapason: json["disdiapason"],
1195+ doitrified: json["doitrified"],
1196+ hexaspermous: json["hexaspermous"],
1197+ homocerc: json["homocerc"],
1198+ insinking: json["insinking"],
1199+ loathfulness: json["loathfulness"],
1200+ miasmatical: json["miasmatical"],
1201+ neurofibril: json["neurofibril"],
1202+ nonbookish: json["nonbookish"],
1203+ phonendoscope: json["phonendoscope"],
1204+ pilferment: json["pilferment"],
1205+ predismissory: json["predismissory"],
1206+ preinscription: json["preinscription"],
1207+ quotative: json["quotative"],
1208+ sienna: json["sienna"],
1209+ thorax: json["thorax"],
1210+ yachting: json["yachting"],
1211+ zipper: json["Zipper"],
1212+ );
1213+
1214+ Map<String, dynamic> toJson() => {
1215+ "alada": alada,
1216+ "amphistomous": amphistomous,
1217+ "boysenberry": boysenberry,
1218+ "catharticalness": catharticalness,
1219+ "Chirotherium": chirotherium,
1220+ "decardinalize": decardinalize,
1221+ "discouragement": discouragement,
1222+ "disdiapason": disdiapason,
1223+ "doitrified": doitrified,
1224+ "hexaspermous": hexaspermous,
1225+ "homocerc": homocerc,
1226+ "insinking": insinking,
1227+ "loathfulness": loathfulness,
1228+ "miasmatical": miasmatical,
1229+ "neurofibril": neurofibril,
1230+ "nonbookish": nonbookish,
1231+ "phonendoscope": phonendoscope,
1232+ "pilferment": pilferment,
1233+ "predismissory": predismissory,
1234+ "preinscription": preinscription,
1235+ "quotative": quotative,
1236+ "sienna": sienna,
1237+ "thorax": thorax,
1238+ "yachting": yachting,
1239+ "Zipper": zipper,
1240+ };
1241+}
1242+
1243+class Pneumocele {
1244+ dynamic carbonarism;
1245+ double? catharticalness;
1246+ int? chirotherium;
1247+ dynamic cineolic;
1248+ dynamic cobbly;
1249+ dynamic conchyliferous;
1250+ dynamic congregation;
1251+ String? disdiapason;
1252+ dynamic enterotomy;
1253+ dynamic entophytal;
1254+ dynamic fewtrils;
1255+ dynamic herem;
1256+ bool? homocerc;
1257+ dynamic koniga;
1258+ dynamic meticulosity;
1259+ dynamic micky;
1260+ dynamic mismarriage;
1261+ dynamic neurotrophic;
1262+ dynamic nonbookish;
1263+ dynamic persuasively;
1264+ dynamic replaceable;
1265+ dynamic silex;
1266+ dynamic taillight;
1267+ dynamic unjealous;
1268+ dynamic visitorial;
1269+
1270+ Pneumocele({
1271+ this.carbonarism,
1272+ this.catharticalness,
1273+ this.chirotherium,
1274+ this.cineolic,
1275+ this.cobbly,
1276+ this.conchyliferous,
1277+ this.congregation,
1278+ this.disdiapason,
1279+ this.enterotomy,
1280+ this.entophytal,
1281+ this.fewtrils,
1282+ this.herem,
1283+ this.homocerc,
1284+ this.koniga,
1285+ this.meticulosity,
1286+ this.micky,
1287+ this.mismarriage,
1288+ this.neurotrophic,
1289+ this.nonbookish,
1290+ this.persuasively,
1291+ this.replaceable,
1292+ this.silex,
1293+ this.taillight,
1294+ this.unjealous,
1295+ this.visitorial,
1296+ });
1297+
1298+ factory Pneumocele.fromJson(Map<String, dynamic> json) => Pneumocele(
1299+ carbonarism: json["Carbonarism"],
1300+ catharticalness: json["catharticalness"]?.toDouble(),
1301+ chirotherium: json["Chirotherium"],
1302+ cineolic: json["cineolic"],
1303+ cobbly: json["cobbly"],
1304+ conchyliferous: json["conchyliferous"],
1305+ congregation: json["congregation"],
1306+ disdiapason: json["disdiapason"],
1307+ enterotomy: json["enterotomy"],
1308+ entophytal: json["entophytal"],
1309+ fewtrils: json["fewtrils"],
1310+ herem: json["herem"],
1311+ homocerc: json["homocerc"],
1312+ koniga: json["Koniga"],
1313+ meticulosity: json["meticulosity"],
1314+ micky: json["Micky"],
1315+ mismarriage: json["mismarriage"],
1316+ neurotrophic: json["neurotrophic"],
1317+ nonbookish: json["nonbookish"],
1318+ persuasively: json["persuasively"],
1319+ replaceable: json["replaceable"],
1320+ silex: json["silex"],
1321+ taillight: json["taillight"],
1322+ unjealous: json["unjealous"],
1323+ visitorial: json["visitorial"],
1324+ );
1325+
1326+ Map<String, dynamic> toJson() => {
1327+ "Carbonarism": carbonarism,
1328+ "catharticalness": catharticalness,
1329+ "Chirotherium": chirotherium,
1330+ "cineolic": cineolic,
1331+ "cobbly": cobbly,
1332+ "conchyliferous": conchyliferous,
1333+ "congregation": congregation,
1334+ "disdiapason": disdiapason,
1335+ "enterotomy": enterotomy,
1336+ "entophytal": entophytal,
1337+ "fewtrils": fewtrils,
1338+ "herem": herem,
1339+ "homocerc": homocerc,
1340+ "Koniga": koniga,
1341+ "meticulosity": meticulosity,
1342+ "Micky": micky,
1343+ "mismarriage": mismarriage,
1344+ "neurotrophic": neurotrophic,
1345+ "nonbookish": nonbookish,
1346+ "persuasively": persuasively,
1347+ "replaceable": replaceable,
1348+ "silex": silex,
1349+ "taillight": taillight,
1350+ "unjealous": unjealous,
1351+ "visitorial": visitorial,
1352+ };
1353+}
1354+
1355+class PotwhiskyClass {
1356+ dynamic arciform;
1357+ dynamic cresolin;
1358+ dynamic disheartener;
1359+ dynamic disproportionable;
1360+ dynamic euchorda;
1361+ dynamic ferryway;
1362+ dynamic filamentiferous;
1363+ dynamic flemish;
1364+ dynamic forgainst;
1365+ dynamic grainering;
1366+ dynamic irrevoluble;
1367+ dynamic kindredship;
1368+ dynamic pinguitudinous;
1369+ dynamic simpletonic;
1370+ dynamic singsong;
1371+ dynamic submergement;
1372+ dynamic supraoesophagal;
1373+ dynamic thrashel;
1374+ dynamic tyremesis;
1375+ dynamic yoruba;
1376+
1377+ PotwhiskyClass({
1378+ required this.arciform,
1379+ required this.cresolin,
1380+ required this.disheartener,
1381+ required this.disproportionable,
1382+ required this.euchorda,
1383+ required this.ferryway,
1384+ required this.filamentiferous,
1385+ required this.flemish,
1386+ required this.forgainst,
1387+ required this.grainering,
1388+ required this.irrevoluble,
1389+ required this.kindredship,
1390+ required this.pinguitudinous,
1391+ required this.simpletonic,
1392+ required this.singsong,
1393+ required this.submergement,
1394+ required this.supraoesophagal,
1395+ required this.thrashel,
1396+ required this.tyremesis,
1397+ required this.yoruba,
1398+ });
1399+
1400+ factory PotwhiskyClass.fromJson(Map<String, dynamic> json) => PotwhiskyClass(
1401+ arciform: json["arciform"],
1402+ cresolin: json["cresolin"],
1403+ disheartener: json["disheartener"],
1404+ disproportionable: json["disproportionable"],
1405+ euchorda: json["Euchorda"],
1406+ ferryway: json["ferryway"],
1407+ filamentiferous: json["filamentiferous"],
1408+ flemish: json["flemish"],
1409+ forgainst: json["forgainst"],
1410+ grainering: json["grainering"],
1411+ irrevoluble: json["irrevoluble"],
1412+ kindredship: json["kindredship"],
1413+ pinguitudinous: json["pinguitudinous"],
1414+ simpletonic: json["simpletonic"],
1415+ singsong: json["singsong"],
1416+ submergement: json["submergement"],
1417+ supraoesophagal: json["supraoesophagal"],
1418+ thrashel: json["thrashel"],
1419+ tyremesis: json["tyremesis"],
1420+ yoruba: json["Yoruba"],
1421+ );
1422+
1423+ Map<String, dynamic> toJson() => {
1424+ "arciform": arciform,
1425+ "cresolin": cresolin,
1426+ "disheartener": disheartener,
1427+ "disproportionable": disproportionable,
1428+ "Euchorda": euchorda,
1429+ "ferryway": ferryway,
1430+ "filamentiferous": filamentiferous,
1431+ "flemish": flemish,
1432+ "forgainst": forgainst,
1433+ "grainering": grainering,
1434+ "irrevoluble": irrevoluble,
1435+ "kindredship": kindredship,
1436+ "pinguitudinous": pinguitudinous,
1437+ "simpletonic": simpletonic,
1438+ "singsong": singsong,
1439+ "submergement": submergement,
1440+ "supraoesophagal": supraoesophagal,
1441+ "thrashel": thrashel,
1442+ "tyremesis": tyremesis,
1443+ "Yoruba": yoruba,
1444+ };
1445+}
1446+
1447+class PrefreshmanClass {
1448+ dynamic azorubine;
1449+ dynamic choroiditis;
1450+ dynamic coagulatory;
1451+ dynamic cyclorama;
1452+ dynamic dolphus;
1453+ dynamic duckhearted;
1454+ dynamic ficus;
1455+ dynamic gemaric;
1456+ dynamic jugation;
1457+ dynamic myoliposis;
1458+ dynamic nonnomination;
1459+ dynamic palay;
1460+ dynamic pentactinal;
1461+ dynamic phaet;
1462+ dynamic piquant;
1463+ dynamic registration;
1464+ dynamic remancipation;
1465+ dynamic scutatiform;
1466+ dynamic theodolite;
1467+ dynamic underward;
1468+
1469+ PrefreshmanClass({
1470+ required this.azorubine,
1471+ required this.choroiditis,
1472+ required this.coagulatory,
1473+ required this.cyclorama,
1474+ required this.dolphus,
1475+ required this.duckhearted,
1476+ required this.ficus,
1477+ required this.gemaric,
1478+ required this.jugation,
1479+ required this.myoliposis,
1480+ required this.nonnomination,
1481+ required this.palay,
1482+ required this.pentactinal,
1483+ required this.phaet,
1484+ required this.piquant,
1485+ required this.registration,
1486+ required this.remancipation,
1487+ required this.scutatiform,
1488+ required this.theodolite,
1489+ required this.underward,
1490+ });
1491+
1492+ factory PrefreshmanClass.fromJson(Map<String, dynamic> json) => PrefreshmanClass(
1493+ azorubine: json["azorubine"],
1494+ choroiditis: json["choroiditis"],
1495+ coagulatory: json["coagulatory"],
1496+ cyclorama: json["cyclorama"],
1497+ dolphus: json["Dolphus"],
1498+ duckhearted: json["duckhearted"],
1499+ ficus: json["Ficus"],
1500+ gemaric: json["Gemaric"],
1501+ jugation: json["jugation"],
1502+ myoliposis: json["myoliposis"],
1503+ nonnomination: json["nonnomination"],
1504+ palay: json["palay"],
1505+ pentactinal: json["pentactinal"],
1506+ phaet: json["Phaet"],
1507+ piquant: json["piquant"],
1508+ registration: json["registration"],
1509+ remancipation: json["remancipation"],
1510+ scutatiform: json["scutatiform"],
1511+ theodolite: json["theodolite"],
1512+ underward: json["underward"],
1513+ );
1514+
1515+ Map<String, dynamic> toJson() => {
1516+ "azorubine": azorubine,
1517+ "choroiditis": choroiditis,
1518+ "coagulatory": coagulatory,
1519+ "cyclorama": cyclorama,
1520+ "Dolphus": dolphus,
1521+ "duckhearted": duckhearted,
1522+ "Ficus": ficus,
1523+ "Gemaric": gemaric,
1524+ "jugation": jugation,
1525+ "myoliposis": myoliposis,
1526+ "nonnomination": nonnomination,
1527+ "palay": palay,
1528+ "pentactinal": pentactinal,
1529+ "Phaet": phaet,
1530+ "piquant": piquant,
1531+ "registration": registration,
1532+ "remancipation": remancipation,
1533+ "scutatiform": scutatiform,
1534+ "theodolite": theodolite,
1535+ "underward": underward,
1536+ };
1537+}
Test case

test/inputs/json/priority/combinations4.json

2 generated files · +3,522 −0
Adartdefault / TopLevel.dart+1,761 −0
@@ -0,0 +1,1761 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final List<dynamic> protrusive;
13+ final List<dynamic> pulpitism;
14+ final List<dynamic> pyodermia;
15+ final List<dynamic> quebrachine;
16+ final List<dynamic> querier;
17+ final List<dynamic> rebarbative;
18+ final List<Reimagine> reimagine;
19+ final Ressaut ressaut;
20+ final List<dynamic> retrocervical;
21+ final List<dynamic> revert;
22+ final List<dynamic> rewrite;
23+ final List<dynamic> saccoderm;
24+ final List<dynamic> santir;
25+ final List<dynamic> saprophilous;
26+ final List<dynamic> saxten;
27+ final List<Scatty?> scatty;
28+ final List<dynamic> scoffer;
29+ final List<dynamic> scrampum;
30+ final double semantic;
31+ final List<dynamic> serpentinic;
32+ final List<dynamic> shadowable;
33+ final List<dynamic> sistering;
34+ final List<Staghunting> staghunting;
35+ final List<dynamic> stagmometer;
36+ final List<dynamic> stimulability;
37+ final List<dynamic> strangleable;
38+ final List<dynamic> strenuosity;
39+ final List<dynamic> tabaxir;
40+ final List<dynamic> talpiform;
41+ final List<dynamic> thwack;
42+ final List<double?> to;
43+ final List<dynamic> tortricine;
44+ final List<dynamic> truantcy;
45+ final List<String> turgesce;
46+ final List<dynamic> unbeginning;
47+ final List<double> underdunged;
48+ final List<dynamic> undesirability;
49+ final List<dynamic> unerasing;
50+ final List<dynamic> unguentarium;
51+ final List<dynamic> unimpeachably;
52+ final List<dynamic> unmortgaged;
53+ final List<dynamic> unobstructed;
54+ final List<dynamic> unreceptivity;
55+ final List<dynamic> unsatisfactoriness;
56+ final List<int> unsecurity;
57+ final List<dynamic> unstressed;
58+ final List<dynamic> untasked;
59+ final List<dynamic> unvarying;
60+ final List<dynamic> vehemently;
61+ final Map<String, bool> warriorship;
62+ final List<dynamic> whitepot;
63+ final List<dynamic> wrothy;
64+
65+ TopLevel({
66+ required this.protrusive,
67+ required this.pulpitism,
68+ required this.pyodermia,
69+ required this.quebrachine,
70+ required this.querier,
71+ required this.rebarbative,
72+ required this.reimagine,
73+ required this.ressaut,
74+ required this.retrocervical,
75+ required this.revert,
76+ required this.rewrite,
77+ required this.saccoderm,
78+ required this.santir,
79+ required this.saprophilous,
80+ required this.saxten,
81+ required this.scatty,
82+ required this.scoffer,
83+ required this.scrampum,
84+ required this.semantic,
85+ required this.serpentinic,
86+ required this.shadowable,
87+ required this.sistering,
88+ required this.staghunting,
89+ required this.stagmometer,
90+ required this.stimulability,
91+ required this.strangleable,
92+ required this.strenuosity,
93+ required this.tabaxir,
94+ required this.talpiform,
95+ required this.thwack,
96+ required this.to,
97+ required this.tortricine,
98+ required this.truantcy,
99+ required this.turgesce,
100+ required this.unbeginning,
101+ required this.underdunged,
102+ required this.undesirability,
103+ required this.unerasing,
104+ required this.unguentarium,
105+ required this.unimpeachably,
106+ required this.unmortgaged,
107+ required this.unobstructed,
108+ required this.unreceptivity,
109+ required this.unsatisfactoriness,
110+ required this.unsecurity,
111+ required this.unstressed,
112+ required this.untasked,
113+ required this.unvarying,
114+ required this.vehemently,
115+ required this.warriorship,
116+ required this.whitepot,
117+ required this.wrothy,
118+ });
119+
120+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
121+ protrusive: List<dynamic>.from(json["protrusive"].map((x) => x)),
122+ pulpitism: List<dynamic>.from(json["pulpitism"].map((x) => x)),
123+ pyodermia: List<dynamic>.from(json["pyodermia"].map((x) => x)),
124+ quebrachine: List<dynamic>.from(json["quebrachine"].map((x) => x)),
125+ querier: List<dynamic>.from(json["querier"].map((x) => x)),
126+ rebarbative: List<dynamic>.from(json["rebarbative"].map((x) => x)),
127+ reimagine: List<Reimagine>.from(json["reimagine"].map((x) => Reimagine.fromJson(x))),
128+ ressaut: Ressaut.fromJson(json["ressaut"]),
129+ retrocervical: List<dynamic>.from(json["retrocervical"].map((x) => x)),
130+ revert: List<dynamic>.from(json["revert"].map((x) => x)),
131+ rewrite: List<dynamic>.from(json["rewrite"].map((x) => x)),
132+ saccoderm: List<dynamic>.from(json["saccoderm"].map((x) => x)),
133+ santir: List<dynamic>.from(json["santir"].map((x) => x)),
134+ saprophilous: List<dynamic>.from(json["saprophilous"].map((x) => x)),
135+ saxten: List<dynamic>.from(json["saxten"].map((x) => x)),
136+ scatty: List<Scatty?>.from(json["scatty"].map((x) => x == null ? null : Scatty.fromJson(x))),
137+ scoffer: List<dynamic>.from(json["scoffer"].map((x) => x)),
138+ scrampum: List<dynamic>.from(json["scrampum"].map((x) => x)),
139+ semantic: json["semantic"]?.toDouble(),
140+ serpentinic: List<dynamic>.from(json["serpentinic"].map((x) => x)),
141+ shadowable: List<dynamic>.from(json["shadowable"].map((x) => x)),
142+ sistering: List<dynamic>.from(json["sistering"].map((x) => x)),
143+ staghunting: List<Staghunting>.from(json["staghunting"].map((x) => Staghunting.fromJson(x))),
144+ stagmometer: List<dynamic>.from(json["stagmometer"].map((x) => x)),
145+ stimulability: List<dynamic>.from(json["stimulability"].map((x) => x)),
146+ strangleable: List<dynamic>.from(json["strangleable"].map((x) => x)),
147+ strenuosity: List<dynamic>.from(json["strenuosity"].map((x) => x)),
148+ tabaxir: List<dynamic>.from(json["tabaxir"].map((x) => x)),
149+ talpiform: List<dynamic>.from(json["talpiform"].map((x) => x)),
150+ thwack: List<dynamic>.from(json["thwack"].map((x) => x)),
151+ to: List<double?>.from(json["to"].map((x) => x?.toDouble())),
152+ tortricine: List<dynamic>.from(json["tortricine"].map((x) => x)),
153+ truantcy: List<dynamic>.from(json["truantcy"].map((x) => x)),
154+ turgesce: List<String>.from(json["turgesce"].map((x) => x)),
155+ unbeginning: List<dynamic>.from(json["unbeginning"].map((x) => x)),
156+ underdunged: List<double>.from(json["underdunged"].map((x) => x?.toDouble())),
157+ undesirability: List<dynamic>.from(json["undesirability"].map((x) => x)),
158+ unerasing: List<dynamic>.from(json["unerasing"].map((x) => x)),
159+ unguentarium: List<dynamic>.from(json["unguentarium"].map((x) => x)),
160+ unimpeachably: List<dynamic>.from(json["unimpeachably"].map((x) => x)),
161+ unmortgaged: List<dynamic>.from(json["unmortgaged"].map((x) => x)),
162+ unobstructed: List<dynamic>.from(json["unobstructed"].map((x) => x)),
163+ unreceptivity: List<dynamic>.from(json["unreceptivity"].map((x) => x)),
164+ unsatisfactoriness: List<dynamic>.from(json["unsatisfactoriness"].map((x) => x)),
165+ unsecurity: List<int>.from(json["unsecurity"].map((x) => x)),
166+ unstressed: List<dynamic>.from(json["unstressed"].map((x) => x)),
167+ untasked: List<dynamic>.from(json["untasked"].map((x) => x)),
168+ unvarying: List<dynamic>.from(json["unvarying"].map((x) => x)),
169+ vehemently: List<dynamic>.from(json["vehemently"].map((x) => x)),
170+ warriorship: Map.from(json["warriorship"]).map((k, v) => MapEntry<String, bool>(k, v)),
171+ whitepot: List<dynamic>.from(json["whitepot"].map((x) => x)),
172+ wrothy: List<dynamic>.from(json["wrothy"].map((x) => x)),
173+ );
174+
175+ Map<String, dynamic> toJson() => {
176+ "protrusive": List<dynamic>.from(protrusive.map((x) => x)),
177+ "pulpitism": List<dynamic>.from(pulpitism.map((x) => x)),
178+ "pyodermia": List<dynamic>.from(pyodermia.map((x) => x)),
179+ "quebrachine": List<dynamic>.from(quebrachine.map((x) => x)),
180+ "querier": List<dynamic>.from(querier.map((x) => x)),
181+ "rebarbative": List<dynamic>.from(rebarbative.map((x) => x)),
182+ "reimagine": List<dynamic>.from(reimagine.map((x) => x.toJson())),
183+ "ressaut": ressaut.toJson(),
184+ "retrocervical": List<dynamic>.from(retrocervical.map((x) => x)),
185+ "revert": List<dynamic>.from(revert.map((x) => x)),
186+ "rewrite": List<dynamic>.from(rewrite.map((x) => x)),
187+ "saccoderm": List<dynamic>.from(saccoderm.map((x) => x)),
188+ "santir": List<dynamic>.from(santir.map((x) => x)),
189+ "saprophilous": List<dynamic>.from(saprophilous.map((x) => x)),
190+ "saxten": List<dynamic>.from(saxten.map((x) => x)),
191+ "scatty": List<dynamic>.from(scatty.map((x) => x?.toJson())),
192+ "scoffer": List<dynamic>.from(scoffer.map((x) => x)),
193+ "scrampum": List<dynamic>.from(scrampum.map((x) => x)),
194+ "semantic": semantic,
195+ "serpentinic": List<dynamic>.from(serpentinic.map((x) => x)),
196+ "shadowable": List<dynamic>.from(shadowable.map((x) => x)),
197+ "sistering": List<dynamic>.from(sistering.map((x) => x)),
198+ "staghunting": List<dynamic>.from(staghunting.map((x) => x.toJson())),
199+ "stagmometer": List<dynamic>.from(stagmometer.map((x) => x)),
200+ "stimulability": List<dynamic>.from(stimulability.map((x) => x)),
201+ "strangleable": List<dynamic>.from(strangleable.map((x) => x)),
202+ "strenuosity": List<dynamic>.from(strenuosity.map((x) => x)),
203+ "tabaxir": List<dynamic>.from(tabaxir.map((x) => x)),
204+ "talpiform": List<dynamic>.from(talpiform.map((x) => x)),
205+ "thwack": List<dynamic>.from(thwack.map((x) => x)),
206+ "to": List<dynamic>.from(to.map((x) => x)),
207+ "tortricine": List<dynamic>.from(tortricine.map((x) => x)),
208+ "truantcy": List<dynamic>.from(truantcy.map((x) => x)),
209+ "turgesce": List<dynamic>.from(turgesce.map((x) => x)),
210+ "unbeginning": List<dynamic>.from(unbeginning.map((x) => x)),
211+ "underdunged": List<dynamic>.from(underdunged.map((x) => x)),
212+ "undesirability": List<dynamic>.from(undesirability.map((x) => x)),
213+ "unerasing": List<dynamic>.from(unerasing.map((x) => x)),
214+ "unguentarium": List<dynamic>.from(unguentarium.map((x) => x)),
215+ "unimpeachably": List<dynamic>.from(unimpeachably.map((x) => x)),
216+ "unmortgaged": List<dynamic>.from(unmortgaged.map((x) => x)),
217+ "unobstructed": List<dynamic>.from(unobstructed.map((x) => x)),
218+ "unreceptivity": List<dynamic>.from(unreceptivity.map((x) => x)),
219+ "unsatisfactoriness": List<dynamic>.from(unsatisfactoriness.map((x) => x)),
220+ "unsecurity": List<dynamic>.from(unsecurity.map((x) => x)),
221+ "unstressed": List<dynamic>.from(unstressed.map((x) => x)),
222+ "untasked": List<dynamic>.from(untasked.map((x) => x)),
223+ "unvarying": List<dynamic>.from(unvarying.map((x) => x)),
224+ "vehemently": List<dynamic>.from(vehemently.map((x) => x)),
225+ "warriorship": Map.from(warriorship).map((k, v) => MapEntry<String, dynamic>(k, v)),
226+ "whitepot": List<dynamic>.from(whitepot.map((x) => x)),
227+ "wrothy": List<dynamic>.from(wrothy.map((x) => x)),
228+ };
229+}
230+
231+class PulpitismClass {
232+ final dynamic abnet;
233+ final dynamic buckhorn;
234+ final dynamic calciform;
235+ final dynamic chelophore;
236+ final dynamic cogitation;
237+ final dynamic decreeable;
238+ final dynamic despicable;
239+ final dynamic isodiazo;
240+ final dynamic jadedly;
241+ final dynamic leptochlorite;
242+ final dynamic nursling;
243+ final dynamic palamedean;
244+ final dynamic photoheliograph;
245+ final dynamic pipewood;
246+ final dynamic roberd;
247+ final dynamic statable;
248+ final dynamic superassume;
249+ final dynamic syllabe;
250+ final dynamic toughhead;
251+ final dynamic underburn;
252+
253+ PulpitismClass({
254+ required this.abnet,
255+ required this.buckhorn,
256+ required this.calciform,
257+ required this.chelophore,
258+ required this.cogitation,
259+ required this.decreeable,
260+ required this.despicable,
261+ required this.isodiazo,
262+ required this.jadedly,
263+ required this.leptochlorite,
264+ required this.nursling,
265+ required this.palamedean,
266+ required this.photoheliograph,
267+ required this.pipewood,
268+ required this.roberd,
269+ required this.statable,
270+ required this.superassume,
271+ required this.syllabe,
272+ required this.toughhead,
273+ required this.underburn,
274+ });
275+
276+ factory PulpitismClass.fromJson(Map<String, dynamic> json) => PulpitismClass(
277+ abnet: json["abnet"],
278+ buckhorn: json["buckhorn"],
279+ calciform: json["calciform"],
280+ chelophore: json["chelophore"],
281+ cogitation: json["cogitation"],
282+ decreeable: json["decreeable"],
283+ despicable: json["despicable"],
284+ isodiazo: json["isodiazo"],
285+ jadedly: json["jadedly"],
286+ leptochlorite: json["leptochlorite"],
287+ nursling: json["nursling"],
288+ palamedean: json["palamedean"],
289+ photoheliograph: json["photoheliograph"],
290+ pipewood: json["pipewood"],
291+ roberd: json["roberd"],
292+ statable: json["statable"],
293+ superassume: json["superassume"],
294+ syllabe: json["syllabe"],
295+ toughhead: json["toughhead"],
296+ underburn: json["underburn"],
297+ );
298+
299+ Map<String, dynamic> toJson() => {
300+ "abnet": abnet,
301+ "buckhorn": buckhorn,
302+ "calciform": calciform,
303+ "chelophore": chelophore,
304+ "cogitation": cogitation,
305+ "decreeable": decreeable,
306+ "despicable": despicable,
307+ "isodiazo": isodiazo,
308+ "jadedly": jadedly,
309+ "leptochlorite": leptochlorite,
310+ "nursling": nursling,
311+ "palamedean": palamedean,
312+ "photoheliograph": photoheliograph,
313+ "pipewood": pipewood,
314+ "roberd": roberd,
315+ "statable": statable,
316+ "superassume": superassume,
317+ "syllabe": syllabe,
318+ "toughhead": toughhead,
319+ "underburn": underburn,
320+ };
321+}
322+
323+class PyodermiaClass {
324+ final dynamic aphoristically;
325+ final dynamic apophyllous;
326+ final dynamic cognize;
327+ final dynamic dermonosology;
328+ final dynamic gyppo;
329+ final dynamic ither;
330+ final dynamic juglandaceous;
331+ final dynamic litho;
332+ final dynamic macropterous;
333+ final dynamic photographer;
334+ final dynamic romancing;
335+ final dynamic rumness;
336+ final dynamic somniloquist;
337+ final dynamic stressfully;
338+ final dynamic tactically;
339+ final dynamic tracheophony;
340+ final dynamic unappositely;
341+ final dynamic unclothedly;
342+ final dynamic unimplied;
343+ final dynamic unsyncopated;
344+
345+ PyodermiaClass({
346+ required this.aphoristically,
347+ required this.apophyllous,
348+ required this.cognize,
349+ required this.dermonosology,
350+ required this.gyppo,
351+ required this.ither,
352+ required this.juglandaceous,
353+ required this.litho,
354+ required this.macropterous,
355+ required this.photographer,
356+ required this.romancing,
357+ required this.rumness,
358+ required this.somniloquist,
359+ required this.stressfully,
360+ required this.tactically,
361+ required this.tracheophony,
362+ required this.unappositely,
363+ required this.unclothedly,
364+ required this.unimplied,
365+ required this.unsyncopated,
366+ });
367+
368+ factory PyodermiaClass.fromJson(Map<String, dynamic> json) => PyodermiaClass(
369+ aphoristically: json["aphoristically"],
370+ apophyllous: json["apophyllous"],
371+ cognize: json["cognize"],
372+ dermonosology: json["dermonosology"],
373+ gyppo: json["Gyppo"],
374+ ither: json["ither"],
375+ juglandaceous: json["juglandaceous"],
376+ litho: json["litho"],
377+ macropterous: json["macropterous"],
378+ photographer: json["photographer"],
379+ romancing: json["romancing"],
380+ rumness: json["rumness"],
381+ somniloquist: json["somniloquist"],
382+ stressfully: json["stressfully"],
383+ tactically: json["tactically"],
384+ tracheophony: json["tracheophony"],
385+ unappositely: json["unappositely"],
386+ unclothedly: json["unclothedly"],
387+ unimplied: json["unimplied"],
388+ unsyncopated: json["unsyncopated"],
389+ );
390+
391+ Map<String, dynamic> toJson() => {
392+ "aphoristically": aphoristically,
393+ "apophyllous": apophyllous,
394+ "cognize": cognize,
395+ "dermonosology": dermonosology,
396+ "Gyppo": gyppo,
397+ "ither": ither,
398+ "juglandaceous": juglandaceous,
399+ "litho": litho,
400+ "macropterous": macropterous,
401+ "photographer": photographer,
402+ "romancing": romancing,
403+ "rumness": rumness,
404+ "somniloquist": somniloquist,
405+ "stressfully": stressfully,
406+ "tactically": tactically,
407+ "tracheophony": tracheophony,
408+ "unappositely": unappositely,
409+ "unclothedly": unclothedly,
410+ "unimplied": unimplied,
411+ "unsyncopated": unsyncopated,
412+ };
413+}
414+
415+class QuebrachineClass {
416+ final double catharticalness;
417+ final int chirotherium;
418+ final String disdiapason;
419+ final bool homocerc;
420+ final dynamic nonbookish;
421+
422+ QuebrachineClass({
423+ required this.catharticalness,
424+ required this.chirotherium,
425+ required this.disdiapason,
426+ required this.homocerc,
427+ required this.nonbookish,
428+ });
429+
430+ factory QuebrachineClass.fromJson(Map<String, dynamic> json) => QuebrachineClass(
431+ catharticalness: json["catharticalness"]?.toDouble(),
432+ chirotherium: json["Chirotherium"],
433+ disdiapason: json["disdiapason"],
434+ homocerc: json["homocerc"],
435+ nonbookish: json["nonbookish"],
436+ );
437+
438+ Map<String, dynamic> toJson() => {
439+ "catharticalness": catharticalness,
440+ "Chirotherium": chirotherium,
441+ "disdiapason": disdiapason,
442+ "homocerc": homocerc,
443+ "nonbookish": nonbookish,
444+ };
445+}
446+
447+class Reimagine {
448+ final dynamic adducible;
449+ final dynamic anabolin;
450+ final dynamic brainy;
451+ final double? catharticalness;
452+ final int? chirotherium;
453+ final dynamic chrysamine;
454+ final String? disdiapason;
455+ final dynamic fluxweed;
456+ final dynamic glaucine;
457+ final dynamic grobianism;
458+ final dynamic hermo;
459+ final dynamic hieroglyphist;
460+ final bool? homocerc;
461+ final dynamic icteroid;
462+ final dynamic immortal;
463+ final dynamic impetulant;
464+ final dynamic irrigate;
465+ final dynamic myxedema;
466+ final dynamic nonbookish;
467+ final dynamic onyx;
468+ final dynamic repasser;
469+ final dynamic septomarginal;
470+ final dynamic subdie;
471+ final dynamic tibiometatarsal;
472+ final dynamic waltzlike;
473+
474+ Reimagine({
475+ this.adducible,
476+ this.anabolin,
477+ this.brainy,
478+ this.catharticalness,
479+ this.chirotherium,
480+ this.chrysamine,
481+ this.disdiapason,
482+ this.fluxweed,
483+ this.glaucine,
484+ this.grobianism,
485+ this.hermo,
486+ this.hieroglyphist,
487+ this.homocerc,
488+ this.icteroid,
489+ this.immortal,
490+ this.impetulant,
491+ this.irrigate,
492+ this.myxedema,
493+ this.nonbookish,
494+ this.onyx,
495+ this.repasser,
496+ this.septomarginal,
497+ this.subdie,
498+ this.tibiometatarsal,
499+ this.waltzlike,
500+ });
501+
502+ factory Reimagine.fromJson(Map<String, dynamic> json) => Reimagine(
503+ adducible: json["adducible"],
504+ anabolin: json["anabolin"],
505+ brainy: json["brainy"],
506+ catharticalness: json["catharticalness"]?.toDouble(),
507+ chirotherium: json["Chirotherium"],
508+ chrysamine: json["chrysamine"],
509+ disdiapason: json["disdiapason"],
510+ fluxweed: json["fluxweed"],
511+ glaucine: json["glaucine"],
512+ grobianism: json["grobianism"],
513+ hermo: json["Hermo"],
514+ hieroglyphist: json["hieroglyphist"],
515+ homocerc: json["homocerc"],
516+ icteroid: json["icteroid"],
517+ immortal: json["immortal"],
518+ impetulant: json["impetulant"],
519+ irrigate: json["irrigate"],
520+ myxedema: json["myxedema"],
521+ nonbookish: json["nonbookish"],
522+ onyx: json["onyx"],
523+ repasser: json["repasser"],
524+ septomarginal: json["septomarginal"],
525+ subdie: json["subdie"],
526+ tibiometatarsal: json["tibiometatarsal"],
527+ waltzlike: json["waltzlike"],
528+ );
529+
530+ Map<String, dynamic> toJson() => {
531+ "adducible": adducible,
532+ "anabolin": anabolin,
533+ "brainy": brainy,
534+ "catharticalness": catharticalness,
535+ "Chirotherium": chirotherium,
536+ "chrysamine": chrysamine,
537+ "disdiapason": disdiapason,
538+ "fluxweed": fluxweed,
539+ "glaucine": glaucine,
540+ "grobianism": grobianism,
541+ "Hermo": hermo,
542+ "hieroglyphist": hieroglyphist,
543+ "homocerc": homocerc,
544+ "icteroid": icteroid,
545+ "immortal": immortal,
546+ "impetulant": impetulant,
547+ "irrigate": irrigate,
548+ "myxedema": myxedema,
549+ "nonbookish": nonbookish,
550+ "onyx": onyx,
551+ "repasser": repasser,
552+ "septomarginal": septomarginal,
553+ "subdie": subdie,
554+ "tibiometatarsal": tibiometatarsal,
555+ "waltzlike": waltzlike,
556+ };
557+}
558+
559+class Ressaut {
560+ final String apperceptive;
561+ final String cuttoo;
562+ final String douser;
563+ final String drinkproof;
564+ final String forementioned;
565+ final String freesia;
566+ final String genevieve;
567+ final String hyperdiabolical;
568+ final String hypocone;
569+ final String irreverentially;
570+ final String jumart;
571+ final String mimosaceae;
572+ final String mollicrush;
573+ final String nedder;
574+ final String retinasphalt;
575+ final String sough;
576+ final String steading;
577+ final String theopaschitism;
578+ final String undurableness;
579+ final String unmingleable;
580+
581+ Ressaut({
582+ required this.apperceptive,
583+ required this.cuttoo,
584+ required this.douser,
585+ required this.drinkproof,
586+ required this.forementioned,
587+ required this.freesia,
588+ required this.genevieve,
589+ required this.hyperdiabolical,
590+ required this.hypocone,
591+ required this.irreverentially,
592+ required this.jumart,
593+ required this.mimosaceae,
594+ required this.mollicrush,
595+ required this.nedder,
596+ required this.retinasphalt,
597+ required this.sough,
598+ required this.steading,
599+ required this.theopaschitism,
600+ required this.undurableness,
601+ required this.unmingleable,
602+ });
603+
604+ factory Ressaut.fromJson(Map<String, dynamic> json) => Ressaut(
605+ apperceptive: json["apperceptive"],
606+ cuttoo: json["cuttoo"],
607+ douser: json["douser"],
608+ drinkproof: json["drinkproof"],
609+ forementioned: json["forementioned"],
610+ freesia: json["Freesia"],
611+ genevieve: json["Genevieve"],
612+ hyperdiabolical: json["hyperdiabolical"],
613+ hypocone: json["hypocone"],
614+ irreverentially: json["irreverentially"],
615+ jumart: json["jumart"],
616+ mimosaceae: json["Mimosaceae"],
617+ mollicrush: json["mollicrush"],
618+ nedder: json["nedder"],
619+ retinasphalt: json["retinasphalt"],
620+ sough: json["sough"],
621+ steading: json["steading"],
622+ theopaschitism: json["Theopaschitism"],
623+ undurableness: json["undurableness"],
624+ unmingleable: json["unmingleable"],
625+ );
626+
627+ Map<String, dynamic> toJson() => {
628+ "apperceptive": apperceptive,
629+ "cuttoo": cuttoo,
630+ "douser": douser,
631+ "drinkproof": drinkproof,
632+ "forementioned": forementioned,
633+ "Freesia": freesia,
634+ "Genevieve": genevieve,
635+ "hyperdiabolical": hyperdiabolical,
636+ "hypocone": hypocone,
637+ "irreverentially": irreverentially,
638+ "jumart": jumart,
639+ "Mimosaceae": mimosaceae,
640+ "mollicrush": mollicrush,
641+ "nedder": nedder,
642+ "retinasphalt": retinasphalt,
643+ "sough": sough,
644+ "steading": steading,
645+ "Theopaschitism": theopaschitism,
646+ "undurableness": undurableness,
647+ "unmingleable": unmingleable,
648+ };
649+}
650+
651+class RewriteClass {
652+ final dynamic accountancy;
653+ final dynamic cacotrophic;
654+ final dynamic contest;
655+ final dynamic couthily;
656+ final dynamic falculate;
657+ final dynamic foreseize;
658+ final dynamic hyades;
659+ final dynamic lemnad;
660+ final dynamic monotheistically;
661+ final dynamic nonflying;
662+ final dynamic ptenoglossa;
663+ final dynamic repatch;
664+ final dynamic rodman;
665+ final dynamic strung;
666+ final dynamic titmal;
667+ final dynamic twalpennyworth;
668+ final dynamic unblamable;
669+ final dynamic vertical;
670+ final dynamic whiggification;
671+ final dynamic yardman;
672+
673+ RewriteClass({
674+ required this.accountancy,
675+ required this.cacotrophic,
676+ required this.contest,
677+ required this.couthily,
678+ required this.falculate,
679+ required this.foreseize,
680+ required this.hyades,
681+ required this.lemnad,
682+ required this.monotheistically,
683+ required this.nonflying,
684+ required this.ptenoglossa,
685+ required this.repatch,
686+ required this.rodman,
687+ required this.strung,
688+ required this.titmal,
689+ required this.twalpennyworth,
690+ required this.unblamable,
691+ required this.vertical,
692+ required this.whiggification,
693+ required this.yardman,
694+ });
695+
696+ factory RewriteClass.fromJson(Map<String, dynamic> json) => RewriteClass(
697+ accountancy: json["accountancy"],
698+ cacotrophic: json["cacotrophic"],
699+ contest: json["contest"],
700+ couthily: json["couthily"],
701+ falculate: json["falculate"],
702+ foreseize: json["foreseize"],
703+ hyades: json["Hyades"],
704+ lemnad: json["lemnad"],
705+ monotheistically: json["monotheistically"],
706+ nonflying: json["nonflying"],
707+ ptenoglossa: json["Ptenoglossa"],
708+ repatch: json["repatch"],
709+ rodman: json["rodman"],
710+ strung: json["strung"],
711+ titmal: json["titmal"],
712+ twalpennyworth: json["twalpennyworth"],
713+ unblamable: json["unblamable"],
714+ vertical: json["vertical"],
715+ whiggification: json["Whiggification"],
716+ yardman: json["yardman"],
717+ );
718+
719+ Map<String, dynamic> toJson() => {
720+ "accountancy": accountancy,
721+ "cacotrophic": cacotrophic,
722+ "contest": contest,
723+ "couthily": couthily,
724+ "falculate": falculate,
725+ "foreseize": foreseize,
726+ "Hyades": hyades,
727+ "lemnad": lemnad,
728+ "monotheistically": monotheistically,
729+ "nonflying": nonflying,
730+ "Ptenoglossa": ptenoglossa,
731+ "repatch": repatch,
732+ "rodman": rodman,
733+ "strung": strung,
734+ "titmal": titmal,
735+ "twalpennyworth": twalpennyworth,
736+ "unblamable": unblamable,
737+ "vertical": vertical,
738+ "Whiggification": whiggification,
739+ "yardman": yardman,
740+ };
741+}
742+
743+class SantirClass {
744+ final dynamic admiredly;
745+ final dynamic demicaponier;
746+ final dynamic epitympanic;
747+ final dynamic investitor;
748+ final dynamic lupiform;
749+ final dynamic monoflagellate;
750+ final dynamic paleoethnic;
751+ final dynamic prediscountable;
752+ final dynamic rhetoricals;
753+ final dynamic roomth;
754+ final dynamic saccharose;
755+ final dynamic septonasal;
756+ final dynamic serpenticide;
757+ final dynamic setarious;
758+ final dynamic spaework;
759+ final dynamic stylite;
760+ final dynamic suessiones;
761+ final dynamic timelily;
762+ final dynamic unprofaned;
763+ final dynamic vorticular;
764+
765+ SantirClass({
766+ required this.admiredly,
767+ required this.demicaponier,
768+ required this.epitympanic,
769+ required this.investitor,
770+ required this.lupiform,
771+ required this.monoflagellate,
772+ required this.paleoethnic,
773+ required this.prediscountable,
774+ required this.rhetoricals,
775+ required this.roomth,
776+ required this.saccharose,
777+ required this.septonasal,
778+ required this.serpenticide,
779+ required this.setarious,
780+ required this.spaework,
781+ required this.stylite,
782+ required this.suessiones,
783+ required this.timelily,
784+ required this.unprofaned,
785+ required this.vorticular,
786+ });
787+
788+ factory SantirClass.fromJson(Map<String, dynamic> json) => SantirClass(
789+ admiredly: json["admiredly"],
790+ demicaponier: json["demicaponier"],
791+ epitympanic: json["epitympanic"],
792+ investitor: json["investitor"],
793+ lupiform: json["lupiform"],
794+ monoflagellate: json["monoflagellate"],
795+ paleoethnic: json["paleoethnic"],
796+ prediscountable: json["prediscountable"],
797+ rhetoricals: json["rhetoricals"],
798+ roomth: json["roomth"],
799+ saccharose: json["saccharose"],
800+ septonasal: json["septonasal"],
801+ serpenticide: json["serpenticide"],
802+ setarious: json["setarious"],
803+ spaework: json["spaework"],
804+ stylite: json["stylite"],
805+ suessiones: json["Suessiones"],
806+ timelily: json["timelily"],
807+ unprofaned: json["unprofaned"],
808+ vorticular: json["vorticular"],
809+ );
810+
811+ Map<String, dynamic> toJson() => {
812+ "admiredly": admiredly,
813+ "demicaponier": demicaponier,
814+ "epitympanic": epitympanic,
815+ "investitor": investitor,
816+ "lupiform": lupiform,
817+ "monoflagellate": monoflagellate,
818+ "paleoethnic": paleoethnic,
819+ "prediscountable": prediscountable,
820+ "rhetoricals": rhetoricals,
821+ "roomth": roomth,
822+ "saccharose": saccharose,
823+ "septonasal": septonasal,
824+ "serpenticide": serpenticide,
825+ "setarious": setarious,
826+ "spaework": spaework,
827+ "stylite": stylite,
828+ "Suessiones": suessiones,
829+ "timelily": timelily,
830+ "unprofaned": unprofaned,
831+ "vorticular": vorticular,
832+ };
833+}
834+
835+class SaxtenClass {
836+ final dynamic algarrobilla;
837+ final dynamic bowgrace;
838+ final double? catharticalness;
839+ final dynamic centaurid;
840+ final int? chirotherium;
841+ final String? disdiapason;
842+ final dynamic flix;
843+ final dynamic germanely;
844+ final bool? homocerc;
845+ final dynamic inhume;
846+ final dynamic lepidote;
847+ final dynamic megalochirous;
848+ final dynamic ninepenny;
849+ final dynamic nonbookish;
850+ final dynamic nondeist;
851+ final dynamic nymphaeaceous;
852+ final dynamic parietofrontal;
853+ final dynamic sancyite;
854+ final dynamic subjectivist;
855+ final dynamic tibiad;
856+ final dynamic transonic;
857+ final dynamic tripetalous;
858+ final dynamic trunchman;
859+ final dynamic urger;
860+ final dynamic withdrawnness;
861+
862+ SaxtenClass({
863+ this.algarrobilla,
864+ this.bowgrace,
865+ this.catharticalness,
866+ this.centaurid,
867+ this.chirotherium,
868+ this.disdiapason,
869+ this.flix,
870+ this.germanely,
871+ this.homocerc,
872+ this.inhume,
873+ this.lepidote,
874+ this.megalochirous,
875+ this.ninepenny,
876+ this.nonbookish,
877+ this.nondeist,
878+ this.nymphaeaceous,
879+ this.parietofrontal,
880+ this.sancyite,
881+ this.subjectivist,
882+ this.tibiad,
883+ this.transonic,
884+ this.tripetalous,
885+ this.trunchman,
886+ this.urger,
887+ this.withdrawnness,
888+ });
889+
890+ factory SaxtenClass.fromJson(Map<String, dynamic> json) => SaxtenClass(
891+ algarrobilla: json["algarrobilla"],
892+ bowgrace: json["bowgrace"],
893+ catharticalness: json["catharticalness"]?.toDouble(),
894+ centaurid: json["Centaurid"],
895+ chirotherium: json["Chirotherium"],
896+ disdiapason: json["disdiapason"],
897+ flix: json["flix"],
898+ germanely: json["germanely"],
899+ homocerc: json["homocerc"],
900+ inhume: json["inhume"],
901+ lepidote: json["lepidote"],
902+ megalochirous: json["megalochirous"],
903+ ninepenny: json["ninepenny"],
904+ nonbookish: json["nonbookish"],
905+ nondeist: json["nondeist"],
906+ nymphaeaceous: json["nymphaeaceous"],
907+ parietofrontal: json["parietofrontal"],
908+ sancyite: json["sancyite"],
909+ subjectivist: json["subjectivist"],
910+ tibiad: json["tibiad"],
911+ transonic: json["transonic"],
912+ tripetalous: json["tripetalous"],
913+ trunchman: json["trunchman"],
914+ urger: json["urger"],
915+ withdrawnness: json["withdrawnness"],
916+ );
917+
918+ Map<String, dynamic> toJson() => {
919+ "algarrobilla": algarrobilla,
920+ "bowgrace": bowgrace,
921+ "catharticalness": catharticalness,
922+ "Centaurid": centaurid,
923+ "Chirotherium": chirotherium,
924+ "disdiapason": disdiapason,
925+ "flix": flix,
926+ "germanely": germanely,
927+ "homocerc": homocerc,
928+ "inhume": inhume,
929+ "lepidote": lepidote,
930+ "megalochirous": megalochirous,
931+ "ninepenny": ninepenny,
932+ "nonbookish": nonbookish,
933+ "nondeist": nondeist,
934+ "nymphaeaceous": nymphaeaceous,
935+ "parietofrontal": parietofrontal,
936+ "sancyite": sancyite,
937+ "subjectivist": subjectivist,
938+ "tibiad": tibiad,
939+ "transonic": transonic,
940+ "tripetalous": tripetalous,
941+ "trunchman": trunchman,
942+ "urger": urger,
943+ "withdrawnness": withdrawnness,
944+ };
945+}
946+
947+class Scatty {
948+ final dynamic aeriferous;
949+ final dynamic antical;
950+ final dynamic antighostism;
951+ final dynamic arcanum;
952+ final dynamic autotrophy;
953+ final dynamic baronial;
954+ final dynamic caffeine;
955+ final dynamic gorgoniacean;
956+ final dynamic heroical;
957+ final dynamic hydropical;
958+ final dynamic mechanology;
959+ final dynamic musicopoetic;
960+ final dynamic officiality;
961+ final dynamic oftentimes;
962+ final dynamic ophthalmotonometer;
963+ final dynamic reflectively;
964+ final dynamic springer;
965+ final dynamic tabasco;
966+ final dynamic teleianthous;
967+ final dynamic uncombated;
968+
969+ Scatty({
970+ required this.aeriferous,
971+ required this.antical,
972+ required this.antighostism,
973+ required this.arcanum,
974+ required this.autotrophy,
975+ required this.baronial,
976+ required this.caffeine,
977+ required this.gorgoniacean,
978+ required this.heroical,
979+ required this.hydropical,
980+ required this.mechanology,
981+ required this.musicopoetic,
982+ required this.officiality,
983+ required this.oftentimes,
984+ required this.ophthalmotonometer,
985+ required this.reflectively,
986+ required this.springer,
987+ required this.tabasco,
988+ required this.teleianthous,
989+ required this.uncombated,
990+ });
991+
992+ factory Scatty.fromJson(Map<String, dynamic> json) => Scatty(
993+ aeriferous: json["aeriferous"],
994+ antical: json["antical"],
995+ antighostism: json["antighostism"],
996+ arcanum: json["arcanum"],
997+ autotrophy: json["autotrophy"],
998+ baronial: json["baronial"],
999+ caffeine: json["caffeine"],
1000+ gorgoniacean: json["gorgoniacean"],
1001+ heroical: json["heroical"],
1002+ hydropical: json["hydropical"],
1003+ mechanology: json["mechanology"],
1004+ musicopoetic: json["musicopoetic"],
1005+ officiality: json["officiality"],
1006+ oftentimes: json["oftentimes"],
1007+ ophthalmotonometer: json["ophthalmotonometer"],
1008+ reflectively: json["reflectively"],
1009+ springer: json["springer"],
1010+ tabasco: json["Tabasco"],
1011+ teleianthous: json["teleianthous"],
1012+ uncombated: json["uncombated"],
1013+ );
1014+
1015+ Map<String, dynamic> toJson() => {
1016+ "aeriferous": aeriferous,
1017+ "antical": antical,
1018+ "antighostism": antighostism,
1019+ "arcanum": arcanum,
1020+ "autotrophy": autotrophy,
1021+ "baronial": baronial,
1022+ "caffeine": caffeine,
1023+ "gorgoniacean": gorgoniacean,
1024+ "heroical": heroical,
1025+ "hydropical": hydropical,
1026+ "mechanology": mechanology,
1027+ "musicopoetic": musicopoetic,
1028+ "officiality": officiality,
1029+ "oftentimes": oftentimes,
1030+ "ophthalmotonometer": ophthalmotonometer,
1031+ "reflectively": reflectively,
1032+ "springer": springer,
1033+ "Tabasco": tabasco,
1034+ "teleianthous": teleianthous,
1035+ "uncombated": uncombated,
1036+ };
1037+}
1038+
1039+class SisteringClass {
1040+ final dynamic amphicarpic;
1041+ final dynamic chianti;
1042+ final dynamic frigorific;
1043+ final dynamic haplomi;
1044+ final dynamic hyperkinesis;
1045+ final dynamic laudable;
1046+ final dynamic madwoman;
1047+ final dynamic maimedly;
1048+ final dynamic micropterygidae;
1049+ final dynamic microrhabdus;
1050+ final dynamic nondense;
1051+ final dynamic phlebemphraxis;
1052+ final dynamic redsear;
1053+ final dynamic schismatical;
1054+ final dynamic tartryl;
1055+ final dynamic unabhorred;
1056+ final dynamic undeliberateness;
1057+ final dynamic unmixable;
1058+ final dynamic untruckling;
1059+ final dynamic vineal;
1060+
1061+ SisteringClass({
1062+ required this.amphicarpic,
1063+ required this.chianti,
1064+ required this.frigorific,
1065+ required this.haplomi,
1066+ required this.hyperkinesis,
1067+ required this.laudable,
1068+ required this.madwoman,
1069+ required this.maimedly,
1070+ required this.micropterygidae,
1071+ required this.microrhabdus,
1072+ required this.nondense,
1073+ required this.phlebemphraxis,
1074+ required this.redsear,
1075+ required this.schismatical,
1076+ required this.tartryl,
1077+ required this.unabhorred,
1078+ required this.undeliberateness,
1079+ required this.unmixable,
1080+ required this.untruckling,
1081+ required this.vineal,
1082+ });
1083+
1084+ factory SisteringClass.fromJson(Map<String, dynamic> json) => SisteringClass(
1085+ amphicarpic: json["amphicarpic"],
1086+ chianti: json["Chianti"],
1087+ frigorific: json["frigorific"],
1088+ haplomi: json["Haplomi"],
1089+ hyperkinesis: json["hyperkinesis"],
1090+ laudable: json["laudable"],
1091+ madwoman: json["madwoman"],
1092+ maimedly: json["maimedly"],
1093+ micropterygidae: json["Micropterygidae"],
1094+ microrhabdus: json["microrhabdus"],
1095+ nondense: json["nondense"],
1096+ phlebemphraxis: json["phlebemphraxis"],
1097+ redsear: json["redsear"],
1098+ schismatical: json["schismatical"],
1099+ tartryl: json["tartryl"],
1100+ unabhorred: json["unabhorred"],
1101+ undeliberateness: json["undeliberateness"],
1102+ unmixable: json["unmixable"],
1103+ untruckling: json["untruckling"],
1104+ vineal: json["vineal"],
1105+ );
1106+
1107+ Map<String, dynamic> toJson() => {
1108+ "amphicarpic": amphicarpic,
1109+ "Chianti": chianti,
1110+ "frigorific": frigorific,
1111+ "Haplomi": haplomi,
1112+ "hyperkinesis": hyperkinesis,
1113+ "laudable": laudable,
1114+ "madwoman": madwoman,
1115+ "maimedly": maimedly,
1116+ "Micropterygidae": micropterygidae,
1117+ "microrhabdus": microrhabdus,
1118+ "nondense": nondense,
1119+ "phlebemphraxis": phlebemphraxis,
1120+ "redsear": redsear,
1121+ "schismatical": schismatical,
1122+ "tartryl": tartryl,
1123+ "unabhorred": unabhorred,
1124+ "undeliberateness": undeliberateness,
1125+ "unmixable": unmixable,
1126+ "untruckling": untruckling,
1127+ "vineal": vineal,
1128+ };
1129+}
1130+
1131+class Staghunting {
1132+ final int? calorimetric;
1133+ final int? canid;
1134+ final double? catharticalness;
1135+ final int? chirotherium;
1136+ final String? disdiapason;
1137+ final int? ditriglyphic;
1138+ final int? floriferousness;
1139+ final int? gamelike;
1140+ final int? grig;
1141+ final bool? homocerc;
1142+ final int? interloan;
1143+ final int? lithotomy;
1144+ final int? loric;
1145+ final int? membranocoriaceous;
1146+ final int? membranogenic;
1147+ final dynamic nonbookish;
1148+ final int? overtrump;
1149+ final int? scotino;
1150+ final int? seasonable;
1151+ final int? sephen;
1152+ final int? stigmarioid;
1153+ final int? tired;
1154+ final int? trifid;
1155+ final int? undefeatedly;
1156+ final int? ungirlish;
1157+
1158+ Staghunting({
1159+ this.calorimetric,
1160+ this.canid,
1161+ this.catharticalness,
1162+ this.chirotherium,
1163+ this.disdiapason,
1164+ this.ditriglyphic,
1165+ this.floriferousness,
1166+ this.gamelike,
1167+ this.grig,
1168+ this.homocerc,
1169+ this.interloan,
1170+ this.lithotomy,
1171+ this.loric,
1172+ this.membranocoriaceous,
1173+ this.membranogenic,
1174+ this.nonbookish,
1175+ this.overtrump,
1176+ this.scotino,
1177+ this.seasonable,
1178+ this.sephen,
1179+ this.stigmarioid,
1180+ this.tired,
1181+ this.trifid,
1182+ this.undefeatedly,
1183+ this.ungirlish,
1184+ });
1185+
1186+ factory Staghunting.fromJson(Map<String, dynamic> json) => Staghunting(
1187+ calorimetric: json["calorimetric"],
1188+ canid: json["canid"],
1189+ catharticalness: json["catharticalness"]?.toDouble(),
1190+ chirotherium: json["Chirotherium"],
1191+ disdiapason: json["disdiapason"],
1192+ ditriglyphic: json["ditriglyphic"],
1193+ floriferousness: json["floriferousness"],
1194+ gamelike: json["gamelike"],
1195+ grig: json["grig"],
1196+ homocerc: json["homocerc"],
1197+ interloan: json["interloan"],
1198+ lithotomy: json["lithotomy"],
1199+ loric: json["loric"],
1200+ membranocoriaceous: json["membranocoriaceous"],
1201+ membranogenic: json["membranogenic"],
1202+ nonbookish: json["nonbookish"],
1203+ overtrump: json["overtrump"],
1204+ scotino: json["scotino"],
1205+ seasonable: json["seasonable"],
1206+ sephen: json["sephen"],
1207+ stigmarioid: json["stigmarioid"],
1208+ tired: json["tired"],
1209+ trifid: json["trifid"],
1210+ undefeatedly: json["undefeatedly"],
1211+ ungirlish: json["ungirlish"],
1212+ );
1213+
1214+ Map<String, dynamic> toJson() => {
1215+ "calorimetric": calorimetric,
1216+ "canid": canid,
1217+ "catharticalness": catharticalness,
1218+ "Chirotherium": chirotherium,
1219+ "disdiapason": disdiapason,
1220+ "ditriglyphic": ditriglyphic,
1221+ "floriferousness": floriferousness,
1222+ "gamelike": gamelike,
1223+ "grig": grig,
1224+ "homocerc": homocerc,
1225+ "interloan": interloan,
1226+ "lithotomy": lithotomy,
1227+ "loric": loric,
1228+ "membranocoriaceous": membranocoriaceous,
1229+ "membranogenic": membranogenic,
1230+ "nonbookish": nonbookish,
1231+ "overtrump": overtrump,
1232+ "scotino": scotino,
1233+ "seasonable": seasonable,
1234+ "sephen": sephen,
1235+ "stigmarioid": stigmarioid,
1236+ "tired": tired,
1237+ "trifid": trifid,
1238+ "undefeatedly": undefeatedly,
1239+ "ungirlish": ungirlish,
1240+ };
1241+}
1242+
1243+class StrenuosityClass {
1244+ final int? bliss;
1245+ final int? buccate;
1246+ final int? bulletproof;
1247+ final double? catharticalness;
1248+ final int? chirotherium;
1249+ final int? crumblingness;
1250+ final String? disdiapason;
1251+ final int? engagedly;
1252+ final int? fightable;
1253+ final int? hoariness;
1254+ final bool? homocerc;
1255+ final int? hypopodium;
1256+ final int? luxurist;
1257+ final int? mechanician;
1258+ final dynamic nonbookish;
1259+ final int? onopordon;
1260+ final int? podgily;
1261+ final int? reformableness;
1262+ final int? scatterbrains;
1263+ final int? seminuria;
1264+ final int? sodomite;
1265+ final int? tramp;
1266+ final int? undueness;
1267+ final int? worthily;
1268+ final int? yankeeist;
1269+
1270+ StrenuosityClass({
1271+ this.bliss,
1272+ this.buccate,
1273+ this.bulletproof,
1274+ this.catharticalness,
1275+ this.chirotherium,
1276+ this.crumblingness,
1277+ this.disdiapason,
1278+ this.engagedly,
1279+ this.fightable,
1280+ this.hoariness,
1281+ this.homocerc,
1282+ this.hypopodium,
1283+ this.luxurist,
1284+ this.mechanician,
1285+ this.nonbookish,
1286+ this.onopordon,
1287+ this.podgily,
1288+ this.reformableness,
1289+ this.scatterbrains,
1290+ this.seminuria,
1291+ this.sodomite,
1292+ this.tramp,
1293+ this.undueness,
1294+ this.worthily,
1295+ this.yankeeist,
1296+ });
1297+
1298+ factory StrenuosityClass.fromJson(Map<String, dynamic> json) => StrenuosityClass(
1299+ bliss: json["bliss"],
1300+ buccate: json["buccate"],
1301+ bulletproof: json["bulletproof"],
1302+ catharticalness: json["catharticalness"]?.toDouble(),
1303+ chirotherium: json["Chirotherium"],
1304+ crumblingness: json["crumblingness"],
1305+ disdiapason: json["disdiapason"],
1306+ engagedly: json["engagedly"],
1307+ fightable: json["fightable"],
1308+ hoariness: json["hoariness"],
1309+ homocerc: json["homocerc"],
1310+ hypopodium: json["hypopodium"],
1311+ luxurist: json["luxurist"],
1312+ mechanician: json["mechanician"],
1313+ nonbookish: json["nonbookish"],
1314+ onopordon: json["Onopordon"],
1315+ podgily: json["podgily"],
1316+ reformableness: json["reformableness"],
1317+ scatterbrains: json["scatterbrains"],
1318+ seminuria: json["seminuria"],
1319+ sodomite: json["Sodomite"],
1320+ tramp: json["tramp"],
1321+ undueness: json["undueness"],
1322+ worthily: json["worthily"],
1323+ yankeeist: json["Yankeeist"],
1324+ );
1325+
1326+ Map<String, dynamic> toJson() => {
1327+ "bliss": bliss,
1328+ "buccate": buccate,
1329+ "bulletproof": bulletproof,
1330+ "catharticalness": catharticalness,
1331+ "Chirotherium": chirotherium,
1332+ "crumblingness": crumblingness,
1333+ "disdiapason": disdiapason,
1334+ "engagedly": engagedly,
1335+ "fightable": fightable,
1336+ "hoariness": hoariness,
1337+ "homocerc": homocerc,
1338+ "hypopodium": hypopodium,
1339+ "luxurist": luxurist,
1340+ "mechanician": mechanician,
1341+ "nonbookish": nonbookish,
1342+ "Onopordon": onopordon,
1343+ "podgily": podgily,
1344+ "reformableness": reformableness,
1345+ "scatterbrains": scatterbrains,
1346+ "seminuria": seminuria,
1347+ "Sodomite": sodomite,
1348+ "tramp": tramp,
1349+ "undueness": undueness,
1350+ "worthily": worthily,
1351+ "Yankeeist": yankeeist,
1352+ };
1353+}
1354+
1355+class TruantcyClass {
1356+ final dynamic alfiona;
1357+ final dynamic ascaridiasis;
1358+ final dynamic bungey;
1359+ final double? catharticalness;
1360+ final dynamic ceroxyle;
1361+ final int? chirotherium;
1362+ final dynamic chorology;
1363+ final String? disdiapason;
1364+ final dynamic enmarble;
1365+ final dynamic epeira;
1366+ final dynamic eurylaimi;
1367+ final dynamic germination;
1368+ final dynamic hallelujah;
1369+ final bool? homocerc;
1370+ final dynamic lev;
1371+ final dynamic mouthing;
1372+ final dynamic nonbookish;
1373+ final dynamic philliloo;
1374+ final dynamic planetal;
1375+ final dynamic poney;
1376+ final dynamic punctualist;
1377+ final dynamic returnlessly;
1378+ final dynamic skelder;
1379+ final dynamic windwaywardly;
1380+ final dynamic yuman;
1381+
1382+ TruantcyClass({
1383+ this.alfiona,
1384+ this.ascaridiasis,
1385+ this.bungey,
1386+ this.catharticalness,
1387+ this.ceroxyle,
1388+ this.chirotherium,
1389+ this.chorology,
1390+ this.disdiapason,
1391+ this.enmarble,
1392+ this.epeira,
1393+ this.eurylaimi,
1394+ this.germination,
1395+ this.hallelujah,
1396+ this.homocerc,
1397+ this.lev,
1398+ this.mouthing,
1399+ this.nonbookish,
1400+ this.philliloo,
1401+ this.planetal,
1402+ this.poney,
1403+ this.punctualist,
1404+ this.returnlessly,
1405+ this.skelder,
1406+ this.windwaywardly,
1407+ this.yuman,
1408+ });
1409+
1410+ factory TruantcyClass.fromJson(Map<String, dynamic> json) => TruantcyClass(
1411+ alfiona: json["alfiona"],
1412+ ascaridiasis: json["ascaridiasis"],
1413+ bungey: json["bungey"],
1414+ catharticalness: json["catharticalness"]?.toDouble(),
1415+ ceroxyle: json["ceroxyle"],
1416+ chirotherium: json["Chirotherium"],
1417+ chorology: json["chorology"],
1418+ disdiapason: json["disdiapason"],
1419+ enmarble: json["enmarble"],
1420+ epeira: json["Epeira"],
1421+ eurylaimi: json["Eurylaimi"],
1422+ germination: json["germination"],
1423+ hallelujah: json["hallelujah"],
1424+ homocerc: json["homocerc"],
1425+ lev: json["lev"],
1426+ mouthing: json["mouthing"],
1427+ nonbookish: json["nonbookish"],
1428+ philliloo: json["philliloo"],
1429+ planetal: json["planetal"],
1430+ poney: json["poney"],
1431+ punctualist: json["punctualist"],
1432+ returnlessly: json["returnlessly"],
1433+ skelder: json["skelder"],
1434+ windwaywardly: json["windwaywardly"],
1435+ yuman: json["Yuman"],
1436+ );
1437+
1438+ Map<String, dynamic> toJson() => {
1439+ "alfiona": alfiona,
1440+ "ascaridiasis": ascaridiasis,
1441+ "bungey": bungey,
1442+ "catharticalness": catharticalness,
1443+ "ceroxyle": ceroxyle,
1444+ "Chirotherium": chirotherium,
1445+ "chorology": chorology,
1446+ "disdiapason": disdiapason,
1447+ "enmarble": enmarble,
1448+ "Epeira": epeira,
1449+ "Eurylaimi": eurylaimi,
1450+ "germination": germination,
1451+ "hallelujah": hallelujah,
1452+ "homocerc": homocerc,
1453+ "lev": lev,
1454+ "mouthing": mouthing,
1455+ "nonbookish": nonbookish,
1456+ "philliloo": philliloo,
1457+ "planetal": planetal,
1458+ "poney": poney,
1459+ "punctualist": punctualist,
1460+ "returnlessly": returnlessly,
1461+ "skelder": skelder,
1462+ "windwaywardly": windwaywardly,
1463+ "Yuman": yuman,
1464+ };
1465+}
1466+
1467+class UnimpeachablyClass {
1468+ final int? acerin;
1469+ final int? bobadil;
1470+ final double? catharticalness;
1471+ final int? chirotherium;
1472+ final int? chlorophylligenous;
1473+ final int? conversational;
1474+ final int? demiowl;
1475+ final String? disdiapason;
1476+ final int? ectorhinal;
1477+ final int? gamblesomeness;
1478+ final bool? homocerc;
1479+ final int? irrorate;
1480+ final int? kindergartening;
1481+ final int? lateritic;
1482+ final int? mespil;
1483+ final int? misconfiguration;
1484+ final dynamic nonbookish;
1485+ final int? planometry;
1486+ final int? quiina;
1487+ final int? robert;
1488+ final int? rot;
1489+ final int? subcinctorium;
1490+ final int? tussocker;
1491+ final int? ultraproud;
1492+ final int? unsuggestedness;
1493+
1494+ UnimpeachablyClass({
1495+ this.acerin,
1496+ this.bobadil,
1497+ this.catharticalness,
1498+ this.chirotherium,
1499+ this.chlorophylligenous,
1500+ this.conversational,
1501+ this.demiowl,
1502+ this.disdiapason,
1503+ this.ectorhinal,
1504+ this.gamblesomeness,
1505+ this.homocerc,
1506+ this.irrorate,
1507+ this.kindergartening,
1508+ this.lateritic,
1509+ this.mespil,
1510+ this.misconfiguration,
1511+ this.nonbookish,
1512+ this.planometry,
1513+ this.quiina,
1514+ this.robert,
1515+ this.rot,
1516+ this.subcinctorium,
1517+ this.tussocker,
1518+ this.ultraproud,
1519+ this.unsuggestedness,
1520+ });
1521+
1522+ factory UnimpeachablyClass.fromJson(Map<String, dynamic> json) => UnimpeachablyClass(
1523+ acerin: json["acerin"],
1524+ bobadil: json["Bobadil"],
1525+ catharticalness: json["catharticalness"]?.toDouble(),
1526+ chirotherium: json["Chirotherium"],
1527+ chlorophylligenous: json["chlorophylligenous"],
1528+ conversational: json["conversational"],
1529+ demiowl: json["demiowl"],
1530+ disdiapason: json["disdiapason"],
1531+ ectorhinal: json["ectorhinal"],
1532+ gamblesomeness: json["gamblesomeness"],
1533+ homocerc: json["homocerc"],
1534+ irrorate: json["irrorate"],
1535+ kindergartening: json["kindergartening"],
1536+ lateritic: json["lateritic"],
1537+ mespil: json["mespil"],
1538+ misconfiguration: json["misconfiguration"],
1539+ nonbookish: json["nonbookish"],
1540+ planometry: json["planometry"],
1541+ quiina: json["Quiina"],
1542+ robert: json["Robert"],
1543+ rot: json["rot"],
1544+ subcinctorium: json["subcinctorium"],
1545+ tussocker: json["tussocker"],
1546+ ultraproud: json["ultraproud"],
1547+ unsuggestedness: json["unsuggestedness"],
1548+ );
1549+
1550+ Map<String, dynamic> toJson() => {
1551+ "acerin": acerin,
1552+ "Bobadil": bobadil,
1553+ "catharticalness": catharticalness,
1554+ "Chirotherium": chirotherium,
1555+ "chlorophylligenous": chlorophylligenous,
1556+ "conversational": conversational,
1557+ "demiowl": demiowl,
1558+ "disdiapason": disdiapason,
1559+ "ectorhinal": ectorhinal,
1560+ "gamblesomeness": gamblesomeness,
1561+ "homocerc": homocerc,
1562+ "irrorate": irrorate,
1563+ "kindergartening": kindergartening,
1564+ "lateritic": lateritic,
1565+ "mespil": mespil,
1566+ "misconfiguration": misconfiguration,
1567+ "nonbookish": nonbookish,
1568+ "planometry": planometry,
1569+ "Quiina": quiina,
1570+ "Robert": robert,
1571+ "rot": rot,
1572+ "subcinctorium": subcinctorium,
1573+ "tussocker": tussocker,
1574+ "ultraproud": ultraproud,
1575+ "unsuggestedness": unsuggestedness,
1576+ };
1577+}
1578+
1579+class UnstressedClass {
1580+ final dynamic alain;
1581+ final dynamic amphirhina;
1582+ final dynamic antimachinery;
1583+ final dynamic coldish;
1584+ final dynamic crantara;
1585+ final dynamic distinguishing;
1586+ final dynamic elytroposis;
1587+ final dynamic gentianwort;
1588+ final dynamic heliosis;
1589+ final dynamic instrumental;
1590+ final dynamic introinflection;
1591+ final dynamic kala;
1592+ final dynamic lincolnian;
1593+ final dynamic metad;
1594+ final dynamic sarcophilus;
1595+ final dynamic swingingly;
1596+ final dynamic unconformity;
1597+ final dynamic undecreed;
1598+ final dynamic venerable;
1599+ final dynamic vowellessness;
1600+
1601+ UnstressedClass({
1602+ required this.alain,
1603+ required this.amphirhina,
1604+ required this.antimachinery,
1605+ required this.coldish,
1606+ required this.crantara,
1607+ required this.distinguishing,
1608+ required this.elytroposis,
1609+ required this.gentianwort,
1610+ required this.heliosis,
1611+ required this.instrumental,
1612+ required this.introinflection,
1613+ required this.kala,
1614+ required this.lincolnian,
1615+ required this.metad,
1616+ required this.sarcophilus,
1617+ required this.swingingly,
1618+ required this.unconformity,
1619+ required this.undecreed,
1620+ required this.venerable,
1621+ required this.vowellessness,
1622+ });
1623+
1624+ factory UnstressedClass.fromJson(Map<String, dynamic> json) => UnstressedClass(
1625+ alain: json["Alain"],
1626+ amphirhina: json["Amphirhina"],
1627+ antimachinery: json["antimachinery"],
1628+ coldish: json["coldish"],
1629+ crantara: json["crantara"],
1630+ distinguishing: json["distinguishing"],
1631+ elytroposis: json["elytroposis"],
1632+ gentianwort: json["gentianwort"],
1633+ heliosis: json["heliosis"],
1634+ instrumental: json["instrumental"],
1635+ introinflection: json["introinflection"],
1636+ kala: json["kala"],
1637+ lincolnian: json["Lincolnian"],
1638+ metad: json["metad"],
1639+ sarcophilus: json["Sarcophilus"],
1640+ swingingly: json["swingingly"],
1641+ unconformity: json["unconformity"],
1642+ undecreed: json["undecreed"],
1643+ venerable: json["venerable"],
1644+ vowellessness: json["vowellessness"],
1645+ );
1646+
1647+ Map<String, dynamic> toJson() => {
1648+ "Alain": alain,
1649+ "Amphirhina": amphirhina,
1650+ "antimachinery": antimachinery,
1651+ "coldish": coldish,
1652+ "crantara": crantara,
1653+ "distinguishing": distinguishing,
1654+ "elytroposis": elytroposis,
1655+ "gentianwort": gentianwort,
1656+ "heliosis": heliosis,
1657+ "instrumental": instrumental,
1658+ "introinflection": introinflection,
1659+ "kala": kala,
1660+ "Lincolnian": lincolnian,
1661+ "metad": metad,
1662+ "Sarcophilus": sarcophilus,
1663+ "swingingly": swingingly,
1664+ "unconformity": unconformity,
1665+ "undecreed": undecreed,
1666+ "venerable": venerable,
1667+ "vowellessness": vowellessness,
1668+ };
1669+}
1670+
1671+class WrothyClass {
1672+ final dynamic aeschynanthus;
1673+ final dynamic aquiferous;
1674+ final dynamic cheapener;
1675+ final dynamic enumeration;
1676+ final dynamic ephesine;
1677+ final dynamic escadrille;
1678+ final dynamic estrous;
1679+ final dynamic interestedly;
1680+ final dynamic katakinetomer;
1681+ final dynamic mortification;
1682+ final dynamic morula;
1683+ final dynamic orthosymmetrical;
1684+ final dynamic overbark;
1685+ final dynamic politist;
1686+ final dynamic qualified;
1687+ final dynamic sphenomalar;
1688+ final dynamic throatful;
1689+ final dynamic transhumance;
1690+ final dynamic triandrian;
1691+ final dynamic unbooked;
1692+
1693+ WrothyClass({
1694+ required this.aeschynanthus,
1695+ required this.aquiferous,
1696+ required this.cheapener,
1697+ required this.enumeration,
1698+ required this.ephesine,
1699+ required this.escadrille,
1700+ required this.estrous,
1701+ required this.interestedly,
1702+ required this.katakinetomer,
1703+ required this.mortification,
1704+ required this.morula,
1705+ required this.orthosymmetrical,
1706+ required this.overbark,
1707+ required this.politist,
1708+ required this.qualified,
1709+ required this.sphenomalar,
1710+ required this.throatful,
1711+ required this.transhumance,
1712+ required this.triandrian,
1713+ required this.unbooked,
1714+ });
1715+
1716+ factory WrothyClass.fromJson(Map<String, dynamic> json) => WrothyClass(
1717+ aeschynanthus: json["Aeschynanthus"],
1718+ aquiferous: json["aquiferous"],
1719+ cheapener: json["cheapener"],
1720+ enumeration: json["enumeration"],
1721+ ephesine: json["Ephesine"],
1722+ escadrille: json["escadrille"],
1723+ estrous: json["estrous"],
1724+ interestedly: json["interestedly"],
1725+ katakinetomer: json["katakinetomer"],
1726+ mortification: json["mortification"],
1727+ morula: json["morula"],
1728+ orthosymmetrical: json["orthosymmetrical"],
1729+ overbark: json["overbark"],
1730+ politist: json["politist"],
1731+ qualified: json["qualified"],
1732+ sphenomalar: json["sphenomalar"],
1733+ throatful: json["throatful"],
1734+ transhumance: json["transhumance"],
1735+ triandrian: json["triandrian"],
1736+ unbooked: json["unbooked"],
1737+ );
1738+
1739+ Map<String, dynamic> toJson() => {
1740+ "Aeschynanthus": aeschynanthus,
1741+ "aquiferous": aquiferous,
1742+ "cheapener": cheapener,
1743+ "enumeration": enumeration,
1744+ "Ephesine": ephesine,
1745+ "escadrille": escadrille,
1746+ "estrous": estrous,
1747+ "interestedly": interestedly,
1748+ "katakinetomer": katakinetomer,
1749+ "mortification": mortification,
1750+ "morula": morula,
1751+ "orthosymmetrical": orthosymmetrical,
1752+ "overbark": overbark,
1753+ "politist": politist,
1754+ "qualified": qualified,
1755+ "sphenomalar": sphenomalar,
1756+ "throatful": throatful,
1757+ "transhumance": transhumance,
1758+ "triandrian": triandrian,
1759+ "unbooked": unbooked,
1760+ };
1761+}
Adartfinal-props-false--58a791807e0c / TopLevel.dart+1,761 −0
@@ -0,0 +1,1761 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ List<dynamic> protrusive;
13+ List<dynamic> pulpitism;
14+ List<dynamic> pyodermia;
15+ List<dynamic> quebrachine;
16+ List<dynamic> querier;
17+ List<dynamic> rebarbative;
18+ List<Reimagine> reimagine;
19+ Ressaut ressaut;
20+ List<dynamic> retrocervical;
21+ List<dynamic> revert;
22+ List<dynamic> rewrite;
23+ List<dynamic> saccoderm;
24+ List<dynamic> santir;
25+ List<dynamic> saprophilous;
26+ List<dynamic> saxten;
27+ List<Scatty?> scatty;
28+ List<dynamic> scoffer;
29+ List<dynamic> scrampum;
30+ double semantic;
31+ List<dynamic> serpentinic;
32+ List<dynamic> shadowable;
33+ List<dynamic> sistering;
34+ List<Staghunting> staghunting;
35+ List<dynamic> stagmometer;
36+ List<dynamic> stimulability;
37+ List<dynamic> strangleable;
38+ List<dynamic> strenuosity;
39+ List<dynamic> tabaxir;
40+ List<dynamic> talpiform;
41+ List<dynamic> thwack;
42+ List<double?> to;
43+ List<dynamic> tortricine;
44+ List<dynamic> truantcy;
45+ List<String> turgesce;
46+ List<dynamic> unbeginning;
47+ List<double> underdunged;
48+ List<dynamic> undesirability;
49+ List<dynamic> unerasing;
50+ List<dynamic> unguentarium;
51+ List<dynamic> unimpeachably;
52+ List<dynamic> unmortgaged;
53+ List<dynamic> unobstructed;
54+ List<dynamic> unreceptivity;
55+ List<dynamic> unsatisfactoriness;
56+ List<int> unsecurity;
57+ List<dynamic> unstressed;
58+ List<dynamic> untasked;
59+ List<dynamic> unvarying;
60+ List<dynamic> vehemently;
61+ Map<String, bool> warriorship;
62+ List<dynamic> whitepot;
63+ List<dynamic> wrothy;
64+
65+ TopLevel({
66+ required this.protrusive,
67+ required this.pulpitism,
68+ required this.pyodermia,
69+ required this.quebrachine,
70+ required this.querier,
71+ required this.rebarbative,
72+ required this.reimagine,
73+ required this.ressaut,
74+ required this.retrocervical,
75+ required this.revert,
76+ required this.rewrite,
77+ required this.saccoderm,
78+ required this.santir,
79+ required this.saprophilous,
80+ required this.saxten,
81+ required this.scatty,
82+ required this.scoffer,
83+ required this.scrampum,
84+ required this.semantic,
85+ required this.serpentinic,
86+ required this.shadowable,
87+ required this.sistering,
88+ required this.staghunting,
89+ required this.stagmometer,
90+ required this.stimulability,
91+ required this.strangleable,
92+ required this.strenuosity,
93+ required this.tabaxir,
94+ required this.talpiform,
95+ required this.thwack,
96+ required this.to,
97+ required this.tortricine,
98+ required this.truantcy,
99+ required this.turgesce,
100+ required this.unbeginning,
101+ required this.underdunged,
102+ required this.undesirability,
103+ required this.unerasing,
104+ required this.unguentarium,
105+ required this.unimpeachably,
106+ required this.unmortgaged,
107+ required this.unobstructed,
108+ required this.unreceptivity,
109+ required this.unsatisfactoriness,
110+ required this.unsecurity,
111+ required this.unstressed,
112+ required this.untasked,
113+ required this.unvarying,
114+ required this.vehemently,
115+ required this.warriorship,
116+ required this.whitepot,
117+ required this.wrothy,
118+ });
119+
120+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
121+ protrusive: List<dynamic>.from(json["protrusive"].map((x) => x)),
122+ pulpitism: List<dynamic>.from(json["pulpitism"].map((x) => x)),
123+ pyodermia: List<dynamic>.from(json["pyodermia"].map((x) => x)),
124+ quebrachine: List<dynamic>.from(json["quebrachine"].map((x) => x)),
125+ querier: List<dynamic>.from(json["querier"].map((x) => x)),
126+ rebarbative: List<dynamic>.from(json["rebarbative"].map((x) => x)),
127+ reimagine: List<Reimagine>.from(json["reimagine"].map((x) => Reimagine.fromJson(x))),
128+ ressaut: Ressaut.fromJson(json["ressaut"]),
129+ retrocervical: List<dynamic>.from(json["retrocervical"].map((x) => x)),
130+ revert: List<dynamic>.from(json["revert"].map((x) => x)),
131+ rewrite: List<dynamic>.from(json["rewrite"].map((x) => x)),
132+ saccoderm: List<dynamic>.from(json["saccoderm"].map((x) => x)),
133+ santir: List<dynamic>.from(json["santir"].map((x) => x)),
134+ saprophilous: List<dynamic>.from(json["saprophilous"].map((x) => x)),
135+ saxten: List<dynamic>.from(json["saxten"].map((x) => x)),
136+ scatty: List<Scatty?>.from(json["scatty"].map((x) => x == null ? null : Scatty.fromJson(x))),
137+ scoffer: List<dynamic>.from(json["scoffer"].map((x) => x)),
138+ scrampum: List<dynamic>.from(json["scrampum"].map((x) => x)),
139+ semantic: json["semantic"]?.toDouble(),
140+ serpentinic: List<dynamic>.from(json["serpentinic"].map((x) => x)),
141+ shadowable: List<dynamic>.from(json["shadowable"].map((x) => x)),
142+ sistering: List<dynamic>.from(json["sistering"].map((x) => x)),
143+ staghunting: List<Staghunting>.from(json["staghunting"].map((x) => Staghunting.fromJson(x))),
144+ stagmometer: List<dynamic>.from(json["stagmometer"].map((x) => x)),
145+ stimulability: List<dynamic>.from(json["stimulability"].map((x) => x)),
146+ strangleable: List<dynamic>.from(json["strangleable"].map((x) => x)),
147+ strenuosity: List<dynamic>.from(json["strenuosity"].map((x) => x)),
148+ tabaxir: List<dynamic>.from(json["tabaxir"].map((x) => x)),
149+ talpiform: List<dynamic>.from(json["talpiform"].map((x) => x)),
150+ thwack: List<dynamic>.from(json["thwack"].map((x) => x)),
151+ to: List<double?>.from(json["to"].map((x) => x?.toDouble())),
152+ tortricine: List<dynamic>.from(json["tortricine"].map((x) => x)),
153+ truantcy: List<dynamic>.from(json["truantcy"].map((x) => x)),
154+ turgesce: List<String>.from(json["turgesce"].map((x) => x)),
155+ unbeginning: List<dynamic>.from(json["unbeginning"].map((x) => x)),
156+ underdunged: List<double>.from(json["underdunged"].map((x) => x?.toDouble())),
157+ undesirability: List<dynamic>.from(json["undesirability"].map((x) => x)),
158+ unerasing: List<dynamic>.from(json["unerasing"].map((x) => x)),
159+ unguentarium: List<dynamic>.from(json["unguentarium"].map((x) => x)),
160+ unimpeachably: List<dynamic>.from(json["unimpeachably"].map((x) => x)),
161+ unmortgaged: List<dynamic>.from(json["unmortgaged"].map((x) => x)),
162+ unobstructed: List<dynamic>.from(json["unobstructed"].map((x) => x)),
163+ unreceptivity: List<dynamic>.from(json["unreceptivity"].map((x) => x)),
164+ unsatisfactoriness: List<dynamic>.from(json["unsatisfactoriness"].map((x) => x)),
165+ unsecurity: List<int>.from(json["unsecurity"].map((x) => x)),
166+ unstressed: List<dynamic>.from(json["unstressed"].map((x) => x)),
167+ untasked: List<dynamic>.from(json["untasked"].map((x) => x)),
168+ unvarying: List<dynamic>.from(json["unvarying"].map((x) => x)),
169+ vehemently: List<dynamic>.from(json["vehemently"].map((x) => x)),
170+ warriorship: Map.from(json["warriorship"]).map((k, v) => MapEntry<String, bool>(k, v)),
171+ whitepot: List<dynamic>.from(json["whitepot"].map((x) => x)),
172+ wrothy: List<dynamic>.from(json["wrothy"].map((x) => x)),
173+ );
174+
175+ Map<String, dynamic> toJson() => {
176+ "protrusive": List<dynamic>.from(protrusive.map((x) => x)),
177+ "pulpitism": List<dynamic>.from(pulpitism.map((x) => x)),
178+ "pyodermia": List<dynamic>.from(pyodermia.map((x) => x)),
179+ "quebrachine": List<dynamic>.from(quebrachine.map((x) => x)),
180+ "querier": List<dynamic>.from(querier.map((x) => x)),
181+ "rebarbative": List<dynamic>.from(rebarbative.map((x) => x)),
182+ "reimagine": List<dynamic>.from(reimagine.map((x) => x.toJson())),
183+ "ressaut": ressaut.toJson(),
184+ "retrocervical": List<dynamic>.from(retrocervical.map((x) => x)),
185+ "revert": List<dynamic>.from(revert.map((x) => x)),
186+ "rewrite": List<dynamic>.from(rewrite.map((x) => x)),
187+ "saccoderm": List<dynamic>.from(saccoderm.map((x) => x)),
188+ "santir": List<dynamic>.from(santir.map((x) => x)),
189+ "saprophilous": List<dynamic>.from(saprophilous.map((x) => x)),
190+ "saxten": List<dynamic>.from(saxten.map((x) => x)),
191+ "scatty": List<dynamic>.from(scatty.map((x) => x?.toJson())),
192+ "scoffer": List<dynamic>.from(scoffer.map((x) => x)),
193+ "scrampum": List<dynamic>.from(scrampum.map((x) => x)),
194+ "semantic": semantic,
195+ "serpentinic": List<dynamic>.from(serpentinic.map((x) => x)),
196+ "shadowable": List<dynamic>.from(shadowable.map((x) => x)),
197+ "sistering": List<dynamic>.from(sistering.map((x) => x)),
198+ "staghunting": List<dynamic>.from(staghunting.map((x) => x.toJson())),
199+ "stagmometer": List<dynamic>.from(stagmometer.map((x) => x)),
200+ "stimulability": List<dynamic>.from(stimulability.map((x) => x)),
201+ "strangleable": List<dynamic>.from(strangleable.map((x) => x)),
202+ "strenuosity": List<dynamic>.from(strenuosity.map((x) => x)),
203+ "tabaxir": List<dynamic>.from(tabaxir.map((x) => x)),
204+ "talpiform": List<dynamic>.from(talpiform.map((x) => x)),
205+ "thwack": List<dynamic>.from(thwack.map((x) => x)),
206+ "to": List<dynamic>.from(to.map((x) => x)),
207+ "tortricine": List<dynamic>.from(tortricine.map((x) => x)),
208+ "truantcy": List<dynamic>.from(truantcy.map((x) => x)),
209+ "turgesce": List<dynamic>.from(turgesce.map((x) => x)),
210+ "unbeginning": List<dynamic>.from(unbeginning.map((x) => x)),
211+ "underdunged": List<dynamic>.from(underdunged.map((x) => x)),
212+ "undesirability": List<dynamic>.from(undesirability.map((x) => x)),
213+ "unerasing": List<dynamic>.from(unerasing.map((x) => x)),
214+ "unguentarium": List<dynamic>.from(unguentarium.map((x) => x)),
215+ "unimpeachably": List<dynamic>.from(unimpeachably.map((x) => x)),
216+ "unmortgaged": List<dynamic>.from(unmortgaged.map((x) => x)),
217+ "unobstructed": List<dynamic>.from(unobstructed.map((x) => x)),
218+ "unreceptivity": List<dynamic>.from(unreceptivity.map((x) => x)),
219+ "unsatisfactoriness": List<dynamic>.from(unsatisfactoriness.map((x) => x)),
220+ "unsecurity": List<dynamic>.from(unsecurity.map((x) => x)),
221+ "unstressed": List<dynamic>.from(unstressed.map((x) => x)),
222+ "untasked": List<dynamic>.from(untasked.map((x) => x)),
223+ "unvarying": List<dynamic>.from(unvarying.map((x) => x)),
224+ "vehemently": List<dynamic>.from(vehemently.map((x) => x)),
225+ "warriorship": Map.from(warriorship).map((k, v) => MapEntry<String, dynamic>(k, v)),
226+ "whitepot": List<dynamic>.from(whitepot.map((x) => x)),
227+ "wrothy": List<dynamic>.from(wrothy.map((x) => x)),
228+ };
229+}
230+
231+class PulpitismClass {
232+ dynamic abnet;
233+ dynamic buckhorn;
234+ dynamic calciform;
235+ dynamic chelophore;
236+ dynamic cogitation;
237+ dynamic decreeable;
238+ dynamic despicable;
239+ dynamic isodiazo;
240+ dynamic jadedly;
241+ dynamic leptochlorite;
242+ dynamic nursling;
243+ dynamic palamedean;
244+ dynamic photoheliograph;
245+ dynamic pipewood;
246+ dynamic roberd;
247+ dynamic statable;
248+ dynamic superassume;
249+ dynamic syllabe;
250+ dynamic toughhead;
251+ dynamic underburn;
252+
253+ PulpitismClass({
254+ required this.abnet,
255+ required this.buckhorn,
256+ required this.calciform,
257+ required this.chelophore,
258+ required this.cogitation,
259+ required this.decreeable,
260+ required this.despicable,
261+ required this.isodiazo,
262+ required this.jadedly,
263+ required this.leptochlorite,
264+ required this.nursling,
265+ required this.palamedean,
266+ required this.photoheliograph,
267+ required this.pipewood,
268+ required this.roberd,
269+ required this.statable,
270+ required this.superassume,
271+ required this.syllabe,
272+ required this.toughhead,
273+ required this.underburn,
274+ });
275+
276+ factory PulpitismClass.fromJson(Map<String, dynamic> json) => PulpitismClass(
277+ abnet: json["abnet"],
278+ buckhorn: json["buckhorn"],
279+ calciform: json["calciform"],
280+ chelophore: json["chelophore"],
281+ cogitation: json["cogitation"],
282+ decreeable: json["decreeable"],
283+ despicable: json["despicable"],
284+ isodiazo: json["isodiazo"],
285+ jadedly: json["jadedly"],
286+ leptochlorite: json["leptochlorite"],
287+ nursling: json["nursling"],
288+ palamedean: json["palamedean"],
289+ photoheliograph: json["photoheliograph"],
290+ pipewood: json["pipewood"],
291+ roberd: json["roberd"],
292+ statable: json["statable"],
293+ superassume: json["superassume"],
294+ syllabe: json["syllabe"],
295+ toughhead: json["toughhead"],
296+ underburn: json["underburn"],
297+ );
298+
299+ Map<String, dynamic> toJson() => {
300+ "abnet": abnet,
301+ "buckhorn": buckhorn,
302+ "calciform": calciform,
303+ "chelophore": chelophore,
304+ "cogitation": cogitation,
305+ "decreeable": decreeable,
306+ "despicable": despicable,
307+ "isodiazo": isodiazo,
308+ "jadedly": jadedly,
309+ "leptochlorite": leptochlorite,
310+ "nursling": nursling,
311+ "palamedean": palamedean,
312+ "photoheliograph": photoheliograph,
313+ "pipewood": pipewood,
314+ "roberd": roberd,
315+ "statable": statable,
316+ "superassume": superassume,
317+ "syllabe": syllabe,
318+ "toughhead": toughhead,
319+ "underburn": underburn,
320+ };
321+}
322+
323+class PyodermiaClass {
324+ dynamic aphoristically;
325+ dynamic apophyllous;
326+ dynamic cognize;
327+ dynamic dermonosology;
328+ dynamic gyppo;
329+ dynamic ither;
330+ dynamic juglandaceous;
331+ dynamic litho;
332+ dynamic macropterous;
333+ dynamic photographer;
334+ dynamic romancing;
335+ dynamic rumness;
336+ dynamic somniloquist;
337+ dynamic stressfully;
338+ dynamic tactically;
339+ dynamic tracheophony;
340+ dynamic unappositely;
341+ dynamic unclothedly;
342+ dynamic unimplied;
343+ dynamic unsyncopated;
344+
345+ PyodermiaClass({
346+ required this.aphoristically,
347+ required this.apophyllous,
348+ required this.cognize,
349+ required this.dermonosology,
350+ required this.gyppo,
351+ required this.ither,
352+ required this.juglandaceous,
353+ required this.litho,
354+ required this.macropterous,
355+ required this.photographer,
356+ required this.romancing,
357+ required this.rumness,
358+ required this.somniloquist,
359+ required this.stressfully,
360+ required this.tactically,
361+ required this.tracheophony,
362+ required this.unappositely,
363+ required this.unclothedly,
364+ required this.unimplied,
365+ required this.unsyncopated,
366+ });
367+
368+ factory PyodermiaClass.fromJson(Map<String, dynamic> json) => PyodermiaClass(
369+ aphoristically: json["aphoristically"],
370+ apophyllous: json["apophyllous"],
371+ cognize: json["cognize"],
372+ dermonosology: json["dermonosology"],
373+ gyppo: json["Gyppo"],
374+ ither: json["ither"],
375+ juglandaceous: json["juglandaceous"],
376+ litho: json["litho"],
377+ macropterous: json["macropterous"],
378+ photographer: json["photographer"],
379+ romancing: json["romancing"],
380+ rumness: json["rumness"],
381+ somniloquist: json["somniloquist"],
382+ stressfully: json["stressfully"],
383+ tactically: json["tactically"],
384+ tracheophony: json["tracheophony"],
385+ unappositely: json["unappositely"],
386+ unclothedly: json["unclothedly"],
387+ unimplied: json["unimplied"],
388+ unsyncopated: json["unsyncopated"],
389+ );
390+
391+ Map<String, dynamic> toJson() => {
392+ "aphoristically": aphoristically,
393+ "apophyllous": apophyllous,
394+ "cognize": cognize,
395+ "dermonosology": dermonosology,
396+ "Gyppo": gyppo,
397+ "ither": ither,
398+ "juglandaceous": juglandaceous,
399+ "litho": litho,
400+ "macropterous": macropterous,
401+ "photographer": photographer,
402+ "romancing": romancing,
403+ "rumness": rumness,
404+ "somniloquist": somniloquist,
405+ "stressfully": stressfully,
406+ "tactically": tactically,
407+ "tracheophony": tracheophony,
408+ "unappositely": unappositely,
409+ "unclothedly": unclothedly,
410+ "unimplied": unimplied,
411+ "unsyncopated": unsyncopated,
412+ };
413+}
414+
415+class QuebrachineClass {
416+ double catharticalness;
417+ int chirotherium;
418+ String disdiapason;
419+ bool homocerc;
420+ dynamic nonbookish;
421+
422+ QuebrachineClass({
423+ required this.catharticalness,
424+ required this.chirotherium,
425+ required this.disdiapason,
426+ required this.homocerc,
427+ required this.nonbookish,
428+ });
429+
430+ factory QuebrachineClass.fromJson(Map<String, dynamic> json) => QuebrachineClass(
431+ catharticalness: json["catharticalness"]?.toDouble(),
432+ chirotherium: json["Chirotherium"],
433+ disdiapason: json["disdiapason"],
434+ homocerc: json["homocerc"],
435+ nonbookish: json["nonbookish"],
436+ );
437+
438+ Map<String, dynamic> toJson() => {
439+ "catharticalness": catharticalness,
440+ "Chirotherium": chirotherium,
441+ "disdiapason": disdiapason,
442+ "homocerc": homocerc,
443+ "nonbookish": nonbookish,
444+ };
445+}
446+
447+class Reimagine {
448+ dynamic adducible;
449+ dynamic anabolin;
450+ dynamic brainy;
451+ double? catharticalness;
452+ int? chirotherium;
453+ dynamic chrysamine;
454+ String? disdiapason;
455+ dynamic fluxweed;
456+ dynamic glaucine;
457+ dynamic grobianism;
458+ dynamic hermo;
459+ dynamic hieroglyphist;
460+ bool? homocerc;
461+ dynamic icteroid;
462+ dynamic immortal;
463+ dynamic impetulant;
464+ dynamic irrigate;
465+ dynamic myxedema;
466+ dynamic nonbookish;
467+ dynamic onyx;
468+ dynamic repasser;
469+ dynamic septomarginal;
470+ dynamic subdie;
471+ dynamic tibiometatarsal;
472+ dynamic waltzlike;
473+
474+ Reimagine({
475+ this.adducible,
476+ this.anabolin,
477+ this.brainy,
478+ this.catharticalness,
479+ this.chirotherium,
480+ this.chrysamine,
481+ this.disdiapason,
482+ this.fluxweed,
483+ this.glaucine,
484+ this.grobianism,
485+ this.hermo,
486+ this.hieroglyphist,
487+ this.homocerc,
488+ this.icteroid,
489+ this.immortal,
490+ this.impetulant,
491+ this.irrigate,
492+ this.myxedema,
493+ this.nonbookish,
494+ this.onyx,
495+ this.repasser,
496+ this.septomarginal,
497+ this.subdie,
498+ this.tibiometatarsal,
499+ this.waltzlike,
500+ });
501+
502+ factory Reimagine.fromJson(Map<String, dynamic> json) => Reimagine(
503+ adducible: json["adducible"],
504+ anabolin: json["anabolin"],
505+ brainy: json["brainy"],
506+ catharticalness: json["catharticalness"]?.toDouble(),
507+ chirotherium: json["Chirotherium"],
508+ chrysamine: json["chrysamine"],
509+ disdiapason: json["disdiapason"],
510+ fluxweed: json["fluxweed"],
511+ glaucine: json["glaucine"],
512+ grobianism: json["grobianism"],
513+ hermo: json["Hermo"],
514+ hieroglyphist: json["hieroglyphist"],
515+ homocerc: json["homocerc"],
516+ icteroid: json["icteroid"],
517+ immortal: json["immortal"],
518+ impetulant: json["impetulant"],
519+ irrigate: json["irrigate"],
520+ myxedema: json["myxedema"],
521+ nonbookish: json["nonbookish"],
522+ onyx: json["onyx"],
523+ repasser: json["repasser"],
524+ septomarginal: json["septomarginal"],
525+ subdie: json["subdie"],
526+ tibiometatarsal: json["tibiometatarsal"],
527+ waltzlike: json["waltzlike"],
528+ );
529+
530+ Map<String, dynamic> toJson() => {
531+ "adducible": adducible,
532+ "anabolin": anabolin,
533+ "brainy": brainy,
534+ "catharticalness": catharticalness,
535+ "Chirotherium": chirotherium,
536+ "chrysamine": chrysamine,
537+ "disdiapason": disdiapason,
538+ "fluxweed": fluxweed,
539+ "glaucine": glaucine,
540+ "grobianism": grobianism,
541+ "Hermo": hermo,
542+ "hieroglyphist": hieroglyphist,
543+ "homocerc": homocerc,
544+ "icteroid": icteroid,
545+ "immortal": immortal,
546+ "impetulant": impetulant,
547+ "irrigate": irrigate,
548+ "myxedema": myxedema,
549+ "nonbookish": nonbookish,
550+ "onyx": onyx,
551+ "repasser": repasser,
552+ "septomarginal": septomarginal,
553+ "subdie": subdie,
554+ "tibiometatarsal": tibiometatarsal,
555+ "waltzlike": waltzlike,
556+ };
557+}
558+
559+class Ressaut {
560+ String apperceptive;
561+ String cuttoo;
562+ String douser;
563+ String drinkproof;
564+ String forementioned;
565+ String freesia;
566+ String genevieve;
567+ String hyperdiabolical;
568+ String hypocone;
569+ String irreverentially;
570+ String jumart;
571+ String mimosaceae;
572+ String mollicrush;
573+ String nedder;
574+ String retinasphalt;
575+ String sough;
576+ String steading;
577+ String theopaschitism;
578+ String undurableness;
579+ String unmingleable;
580+
581+ Ressaut({
582+ required this.apperceptive,
583+ required this.cuttoo,
584+ required this.douser,
585+ required this.drinkproof,
586+ required this.forementioned,
587+ required this.freesia,
588+ required this.genevieve,
589+ required this.hyperdiabolical,
590+ required this.hypocone,
591+ required this.irreverentially,
592+ required this.jumart,
593+ required this.mimosaceae,
594+ required this.mollicrush,
595+ required this.nedder,
596+ required this.retinasphalt,
597+ required this.sough,
598+ required this.steading,
599+ required this.theopaschitism,
600+ required this.undurableness,
601+ required this.unmingleable,
602+ });
603+
604+ factory Ressaut.fromJson(Map<String, dynamic> json) => Ressaut(
605+ apperceptive: json["apperceptive"],
606+ cuttoo: json["cuttoo"],
607+ douser: json["douser"],
608+ drinkproof: json["drinkproof"],
609+ forementioned: json["forementioned"],
610+ freesia: json["Freesia"],
611+ genevieve: json["Genevieve"],
612+ hyperdiabolical: json["hyperdiabolical"],
613+ hypocone: json["hypocone"],
614+ irreverentially: json["irreverentially"],
615+ jumart: json["jumart"],
616+ mimosaceae: json["Mimosaceae"],
617+ mollicrush: json["mollicrush"],
618+ nedder: json["nedder"],
619+ retinasphalt: json["retinasphalt"],
620+ sough: json["sough"],
621+ steading: json["steading"],
622+ theopaschitism: json["Theopaschitism"],
623+ undurableness: json["undurableness"],
624+ unmingleable: json["unmingleable"],
625+ );
626+
627+ Map<String, dynamic> toJson() => {
628+ "apperceptive": apperceptive,
629+ "cuttoo": cuttoo,
630+ "douser": douser,
631+ "drinkproof": drinkproof,
632+ "forementioned": forementioned,
633+ "Freesia": freesia,
634+ "Genevieve": genevieve,
635+ "hyperdiabolical": hyperdiabolical,
636+ "hypocone": hypocone,
637+ "irreverentially": irreverentially,
638+ "jumart": jumart,
639+ "Mimosaceae": mimosaceae,
640+ "mollicrush": mollicrush,
641+ "nedder": nedder,
642+ "retinasphalt": retinasphalt,
643+ "sough": sough,
644+ "steading": steading,
645+ "Theopaschitism": theopaschitism,
646+ "undurableness": undurableness,
647+ "unmingleable": unmingleable,
648+ };
649+}
650+
651+class RewriteClass {
652+ dynamic accountancy;
653+ dynamic cacotrophic;
654+ dynamic contest;
655+ dynamic couthily;
656+ dynamic falculate;
657+ dynamic foreseize;
658+ dynamic hyades;
659+ dynamic lemnad;
660+ dynamic monotheistically;
661+ dynamic nonflying;
662+ dynamic ptenoglossa;
663+ dynamic repatch;
664+ dynamic rodman;
665+ dynamic strung;
666+ dynamic titmal;
667+ dynamic twalpennyworth;
668+ dynamic unblamable;
669+ dynamic vertical;
670+ dynamic whiggification;
671+ dynamic yardman;
672+
673+ RewriteClass({
674+ required this.accountancy,
675+ required this.cacotrophic,
676+ required this.contest,
677+ required this.couthily,
678+ required this.falculate,
679+ required this.foreseize,
680+ required this.hyades,
681+ required this.lemnad,
682+ required this.monotheistically,
683+ required this.nonflying,
684+ required this.ptenoglossa,
685+ required this.repatch,
686+ required this.rodman,
687+ required this.strung,
688+ required this.titmal,
689+ required this.twalpennyworth,
690+ required this.unblamable,
691+ required this.vertical,
692+ required this.whiggification,
693+ required this.yardman,
694+ });
695+
696+ factory RewriteClass.fromJson(Map<String, dynamic> json) => RewriteClass(
697+ accountancy: json["accountancy"],
698+ cacotrophic: json["cacotrophic"],
699+ contest: json["contest"],
700+ couthily: json["couthily"],
701+ falculate: json["falculate"],
702+ foreseize: json["foreseize"],
703+ hyades: json["Hyades"],
704+ lemnad: json["lemnad"],
705+ monotheistically: json["monotheistically"],
706+ nonflying: json["nonflying"],
707+ ptenoglossa: json["Ptenoglossa"],
708+ repatch: json["repatch"],
709+ rodman: json["rodman"],
710+ strung: json["strung"],
711+ titmal: json["titmal"],
712+ twalpennyworth: json["twalpennyworth"],
713+ unblamable: json["unblamable"],
714+ vertical: json["vertical"],
715+ whiggification: json["Whiggification"],
716+ yardman: json["yardman"],
717+ );
718+
719+ Map<String, dynamic> toJson() => {
720+ "accountancy": accountancy,
721+ "cacotrophic": cacotrophic,
722+ "contest": contest,
723+ "couthily": couthily,
724+ "falculate": falculate,
725+ "foreseize": foreseize,
726+ "Hyades": hyades,
727+ "lemnad": lemnad,
728+ "monotheistically": monotheistically,
729+ "nonflying": nonflying,
730+ "Ptenoglossa": ptenoglossa,
731+ "repatch": repatch,
732+ "rodman": rodman,
733+ "strung": strung,
734+ "titmal": titmal,
735+ "twalpennyworth": twalpennyworth,
736+ "unblamable": unblamable,
737+ "vertical": vertical,
738+ "Whiggification": whiggification,
739+ "yardman": yardman,
740+ };
741+}
742+
743+class SantirClass {
744+ dynamic admiredly;
745+ dynamic demicaponier;
746+ dynamic epitympanic;
747+ dynamic investitor;
748+ dynamic lupiform;
749+ dynamic monoflagellate;
750+ dynamic paleoethnic;
751+ dynamic prediscountable;
752+ dynamic rhetoricals;
753+ dynamic roomth;
754+ dynamic saccharose;
755+ dynamic septonasal;
756+ dynamic serpenticide;
757+ dynamic setarious;
758+ dynamic spaework;
759+ dynamic stylite;
760+ dynamic suessiones;
761+ dynamic timelily;
762+ dynamic unprofaned;
763+ dynamic vorticular;
764+
765+ SantirClass({
766+ required this.admiredly,
767+ required this.demicaponier,
768+ required this.epitympanic,
769+ required this.investitor,
770+ required this.lupiform,
771+ required this.monoflagellate,
772+ required this.paleoethnic,
773+ required this.prediscountable,
774+ required this.rhetoricals,
775+ required this.roomth,
776+ required this.saccharose,
777+ required this.septonasal,
778+ required this.serpenticide,
779+ required this.setarious,
780+ required this.spaework,
781+ required this.stylite,
782+ required this.suessiones,
783+ required this.timelily,
784+ required this.unprofaned,
785+ required this.vorticular,
786+ });
787+
788+ factory SantirClass.fromJson(Map<String, dynamic> json) => SantirClass(
789+ admiredly: json["admiredly"],
790+ demicaponier: json["demicaponier"],
791+ epitympanic: json["epitympanic"],
792+ investitor: json["investitor"],
793+ lupiform: json["lupiform"],
794+ monoflagellate: json["monoflagellate"],
795+ paleoethnic: json["paleoethnic"],
796+ prediscountable: json["prediscountable"],
797+ rhetoricals: json["rhetoricals"],
798+ roomth: json["roomth"],
799+ saccharose: json["saccharose"],
800+ septonasal: json["septonasal"],
801+ serpenticide: json["serpenticide"],
802+ setarious: json["setarious"],
803+ spaework: json["spaework"],
804+ stylite: json["stylite"],
805+ suessiones: json["Suessiones"],
806+ timelily: json["timelily"],
807+ unprofaned: json["unprofaned"],
808+ vorticular: json["vorticular"],
809+ );
810+
811+ Map<String, dynamic> toJson() => {
812+ "admiredly": admiredly,
813+ "demicaponier": demicaponier,
814+ "epitympanic": epitympanic,
815+ "investitor": investitor,
816+ "lupiform": lupiform,
817+ "monoflagellate": monoflagellate,
818+ "paleoethnic": paleoethnic,
819+ "prediscountable": prediscountable,
820+ "rhetoricals": rhetoricals,
821+ "roomth": roomth,
822+ "saccharose": saccharose,
823+ "septonasal": septonasal,
824+ "serpenticide": serpenticide,
825+ "setarious": setarious,
826+ "spaework": spaework,
827+ "stylite": stylite,
828+ "Suessiones": suessiones,
829+ "timelily": timelily,
830+ "unprofaned": unprofaned,
831+ "vorticular": vorticular,
832+ };
833+}
834+
835+class SaxtenClass {
836+ dynamic algarrobilla;
837+ dynamic bowgrace;
838+ double? catharticalness;
839+ dynamic centaurid;
840+ int? chirotherium;
841+ String? disdiapason;
842+ dynamic flix;
843+ dynamic germanely;
844+ bool? homocerc;
845+ dynamic inhume;
846+ dynamic lepidote;
847+ dynamic megalochirous;
848+ dynamic ninepenny;
849+ dynamic nonbookish;
850+ dynamic nondeist;
851+ dynamic nymphaeaceous;
852+ dynamic parietofrontal;
853+ dynamic sancyite;
854+ dynamic subjectivist;
855+ dynamic tibiad;
856+ dynamic transonic;
857+ dynamic tripetalous;
858+ dynamic trunchman;
859+ dynamic urger;
860+ dynamic withdrawnness;
861+
862+ SaxtenClass({
863+ this.algarrobilla,
864+ this.bowgrace,
865+ this.catharticalness,
866+ this.centaurid,
867+ this.chirotherium,
868+ this.disdiapason,
869+ this.flix,
870+ this.germanely,
871+ this.homocerc,
872+ this.inhume,
873+ this.lepidote,
874+ this.megalochirous,
875+ this.ninepenny,
876+ this.nonbookish,
877+ this.nondeist,
878+ this.nymphaeaceous,
879+ this.parietofrontal,
880+ this.sancyite,
881+ this.subjectivist,
882+ this.tibiad,
883+ this.transonic,
884+ this.tripetalous,
885+ this.trunchman,
886+ this.urger,
887+ this.withdrawnness,
888+ });
889+
890+ factory SaxtenClass.fromJson(Map<String, dynamic> json) => SaxtenClass(
891+ algarrobilla: json["algarrobilla"],
892+ bowgrace: json["bowgrace"],
893+ catharticalness: json["catharticalness"]?.toDouble(),
894+ centaurid: json["Centaurid"],
895+ chirotherium: json["Chirotherium"],
896+ disdiapason: json["disdiapason"],
897+ flix: json["flix"],
898+ germanely: json["germanely"],
899+ homocerc: json["homocerc"],
900+ inhume: json["inhume"],
901+ lepidote: json["lepidote"],
902+ megalochirous: json["megalochirous"],
903+ ninepenny: json["ninepenny"],
904+ nonbookish: json["nonbookish"],
905+ nondeist: json["nondeist"],
906+ nymphaeaceous: json["nymphaeaceous"],
907+ parietofrontal: json["parietofrontal"],
908+ sancyite: json["sancyite"],
909+ subjectivist: json["subjectivist"],
910+ tibiad: json["tibiad"],
911+ transonic: json["transonic"],
912+ tripetalous: json["tripetalous"],
913+ trunchman: json["trunchman"],
914+ urger: json["urger"],
915+ withdrawnness: json["withdrawnness"],
916+ );
917+
918+ Map<String, dynamic> toJson() => {
919+ "algarrobilla": algarrobilla,
920+ "bowgrace": bowgrace,
921+ "catharticalness": catharticalness,
922+ "Centaurid": centaurid,
923+ "Chirotherium": chirotherium,
924+ "disdiapason": disdiapason,
925+ "flix": flix,
926+ "germanely": germanely,
927+ "homocerc": homocerc,
928+ "inhume": inhume,
929+ "lepidote": lepidote,
930+ "megalochirous": megalochirous,
931+ "ninepenny": ninepenny,
932+ "nonbookish": nonbookish,
933+ "nondeist": nondeist,
934+ "nymphaeaceous": nymphaeaceous,
935+ "parietofrontal": parietofrontal,
936+ "sancyite": sancyite,
937+ "subjectivist": subjectivist,
938+ "tibiad": tibiad,
939+ "transonic": transonic,
940+ "tripetalous": tripetalous,
941+ "trunchman": trunchman,
942+ "urger": urger,
943+ "withdrawnness": withdrawnness,
944+ };
945+}
946+
947+class Scatty {
948+ dynamic aeriferous;
949+ dynamic antical;
950+ dynamic antighostism;
951+ dynamic arcanum;
952+ dynamic autotrophy;
953+ dynamic baronial;
954+ dynamic caffeine;
955+ dynamic gorgoniacean;
956+ dynamic heroical;
957+ dynamic hydropical;
958+ dynamic mechanology;
959+ dynamic musicopoetic;
960+ dynamic officiality;
961+ dynamic oftentimes;
962+ dynamic ophthalmotonometer;
963+ dynamic reflectively;
964+ dynamic springer;
965+ dynamic tabasco;
966+ dynamic teleianthous;
967+ dynamic uncombated;
968+
969+ Scatty({
970+ required this.aeriferous,
971+ required this.antical,
972+ required this.antighostism,
973+ required this.arcanum,
974+ required this.autotrophy,
975+ required this.baronial,
976+ required this.caffeine,
977+ required this.gorgoniacean,
978+ required this.heroical,
979+ required this.hydropical,
980+ required this.mechanology,
981+ required this.musicopoetic,
982+ required this.officiality,
983+ required this.oftentimes,
984+ required this.ophthalmotonometer,
985+ required this.reflectively,
986+ required this.springer,
987+ required this.tabasco,
988+ required this.teleianthous,
989+ required this.uncombated,
990+ });
991+
992+ factory Scatty.fromJson(Map<String, dynamic> json) => Scatty(
993+ aeriferous: json["aeriferous"],
994+ antical: json["antical"],
995+ antighostism: json["antighostism"],
996+ arcanum: json["arcanum"],
997+ autotrophy: json["autotrophy"],
998+ baronial: json["baronial"],
999+ caffeine: json["caffeine"],
1000+ gorgoniacean: json["gorgoniacean"],
1001+ heroical: json["heroical"],
1002+ hydropical: json["hydropical"],
1003+ mechanology: json["mechanology"],
1004+ musicopoetic: json["musicopoetic"],
1005+ officiality: json["officiality"],
1006+ oftentimes: json["oftentimes"],
1007+ ophthalmotonometer: json["ophthalmotonometer"],
1008+ reflectively: json["reflectively"],
1009+ springer: json["springer"],
1010+ tabasco: json["Tabasco"],
1011+ teleianthous: json["teleianthous"],
1012+ uncombated: json["uncombated"],
1013+ );
1014+
1015+ Map<String, dynamic> toJson() => {
1016+ "aeriferous": aeriferous,
1017+ "antical": antical,
1018+ "antighostism": antighostism,
1019+ "arcanum": arcanum,
1020+ "autotrophy": autotrophy,
1021+ "baronial": baronial,
1022+ "caffeine": caffeine,
1023+ "gorgoniacean": gorgoniacean,
1024+ "heroical": heroical,
1025+ "hydropical": hydropical,
1026+ "mechanology": mechanology,
1027+ "musicopoetic": musicopoetic,
1028+ "officiality": officiality,
1029+ "oftentimes": oftentimes,
1030+ "ophthalmotonometer": ophthalmotonometer,
1031+ "reflectively": reflectively,
1032+ "springer": springer,
1033+ "Tabasco": tabasco,
1034+ "teleianthous": teleianthous,
1035+ "uncombated": uncombated,
1036+ };
1037+}
1038+
1039+class SisteringClass {
1040+ dynamic amphicarpic;
1041+ dynamic chianti;
1042+ dynamic frigorific;
1043+ dynamic haplomi;
1044+ dynamic hyperkinesis;
1045+ dynamic laudable;
1046+ dynamic madwoman;
1047+ dynamic maimedly;
1048+ dynamic micropterygidae;
1049+ dynamic microrhabdus;
1050+ dynamic nondense;
1051+ dynamic phlebemphraxis;
1052+ dynamic redsear;
1053+ dynamic schismatical;
1054+ dynamic tartryl;
1055+ dynamic unabhorred;
1056+ dynamic undeliberateness;
1057+ dynamic unmixable;
1058+ dynamic untruckling;
1059+ dynamic vineal;
1060+
1061+ SisteringClass({
1062+ required this.amphicarpic,
1063+ required this.chianti,
1064+ required this.frigorific,
1065+ required this.haplomi,
1066+ required this.hyperkinesis,
1067+ required this.laudable,
1068+ required this.madwoman,
1069+ required this.maimedly,
1070+ required this.micropterygidae,
1071+ required this.microrhabdus,
1072+ required this.nondense,
1073+ required this.phlebemphraxis,
1074+ required this.redsear,
1075+ required this.schismatical,
1076+ required this.tartryl,
1077+ required this.unabhorred,
1078+ required this.undeliberateness,
1079+ required this.unmixable,
1080+ required this.untruckling,
1081+ required this.vineal,
1082+ });
1083+
1084+ factory SisteringClass.fromJson(Map<String, dynamic> json) => SisteringClass(
1085+ amphicarpic: json["amphicarpic"],
1086+ chianti: json["Chianti"],
1087+ frigorific: json["frigorific"],
1088+ haplomi: json["Haplomi"],
1089+ hyperkinesis: json["hyperkinesis"],
1090+ laudable: json["laudable"],
1091+ madwoman: json["madwoman"],
1092+ maimedly: json["maimedly"],
1093+ micropterygidae: json["Micropterygidae"],
1094+ microrhabdus: json["microrhabdus"],
1095+ nondense: json["nondense"],
1096+ phlebemphraxis: json["phlebemphraxis"],
1097+ redsear: json["redsear"],
1098+ schismatical: json["schismatical"],
1099+ tartryl: json["tartryl"],
1100+ unabhorred: json["unabhorred"],
1101+ undeliberateness: json["undeliberateness"],
1102+ unmixable: json["unmixable"],
1103+ untruckling: json["untruckling"],
1104+ vineal: json["vineal"],
1105+ );
1106+
1107+ Map<String, dynamic> toJson() => {
1108+ "amphicarpic": amphicarpic,
1109+ "Chianti": chianti,
1110+ "frigorific": frigorific,
1111+ "Haplomi": haplomi,
1112+ "hyperkinesis": hyperkinesis,
1113+ "laudable": laudable,
1114+ "madwoman": madwoman,
1115+ "maimedly": maimedly,
1116+ "Micropterygidae": micropterygidae,
1117+ "microrhabdus": microrhabdus,
1118+ "nondense": nondense,
1119+ "phlebemphraxis": phlebemphraxis,
1120+ "redsear": redsear,
1121+ "schismatical": schismatical,
1122+ "tartryl": tartryl,
1123+ "unabhorred": unabhorred,
1124+ "undeliberateness": undeliberateness,
1125+ "unmixable": unmixable,
1126+ "untruckling": untruckling,
1127+ "vineal": vineal,
1128+ };
1129+}
1130+
1131+class Staghunting {
1132+ int? calorimetric;
1133+ int? canid;
1134+ double? catharticalness;
1135+ int? chirotherium;
1136+ String? disdiapason;
1137+ int? ditriglyphic;
1138+ int? floriferousness;
1139+ int? gamelike;
1140+ int? grig;
1141+ bool? homocerc;
1142+ int? interloan;
1143+ int? lithotomy;
1144+ int? loric;
1145+ int? membranocoriaceous;
1146+ int? membranogenic;
1147+ dynamic nonbookish;
1148+ int? overtrump;
1149+ int? scotino;
1150+ int? seasonable;
1151+ int? sephen;
1152+ int? stigmarioid;
1153+ int? tired;
1154+ int? trifid;
1155+ int? undefeatedly;
1156+ int? ungirlish;
1157+
1158+ Staghunting({
1159+ this.calorimetric,
1160+ this.canid,
1161+ this.catharticalness,
1162+ this.chirotherium,
1163+ this.disdiapason,
1164+ this.ditriglyphic,
1165+ this.floriferousness,
1166+ this.gamelike,
1167+ this.grig,
1168+ this.homocerc,
1169+ this.interloan,
1170+ this.lithotomy,
1171+ this.loric,
1172+ this.membranocoriaceous,
1173+ this.membranogenic,
1174+ this.nonbookish,
1175+ this.overtrump,
1176+ this.scotino,
1177+ this.seasonable,
1178+ this.sephen,
1179+ this.stigmarioid,
1180+ this.tired,
1181+ this.trifid,
1182+ this.undefeatedly,
1183+ this.ungirlish,
1184+ });
1185+
1186+ factory Staghunting.fromJson(Map<String, dynamic> json) => Staghunting(
1187+ calorimetric: json["calorimetric"],
1188+ canid: json["canid"],
1189+ catharticalness: json["catharticalness"]?.toDouble(),
1190+ chirotherium: json["Chirotherium"],
1191+ disdiapason: json["disdiapason"],
1192+ ditriglyphic: json["ditriglyphic"],
1193+ floriferousness: json["floriferousness"],
1194+ gamelike: json["gamelike"],
1195+ grig: json["grig"],
1196+ homocerc: json["homocerc"],
1197+ interloan: json["interloan"],
1198+ lithotomy: json["lithotomy"],
1199+ loric: json["loric"],
1200+ membranocoriaceous: json["membranocoriaceous"],
1201+ membranogenic: json["membranogenic"],
1202+ nonbookish: json["nonbookish"],
1203+ overtrump: json["overtrump"],
1204+ scotino: json["scotino"],
1205+ seasonable: json["seasonable"],
1206+ sephen: json["sephen"],
1207+ stigmarioid: json["stigmarioid"],
1208+ tired: json["tired"],
1209+ trifid: json["trifid"],
1210+ undefeatedly: json["undefeatedly"],
1211+ ungirlish: json["ungirlish"],
1212+ );
1213+
1214+ Map<String, dynamic> toJson() => {
1215+ "calorimetric": calorimetric,
1216+ "canid": canid,
1217+ "catharticalness": catharticalness,
1218+ "Chirotherium": chirotherium,
1219+ "disdiapason": disdiapason,
1220+ "ditriglyphic": ditriglyphic,
1221+ "floriferousness": floriferousness,
1222+ "gamelike": gamelike,
1223+ "grig": grig,
1224+ "homocerc": homocerc,
1225+ "interloan": interloan,
1226+ "lithotomy": lithotomy,
1227+ "loric": loric,
1228+ "membranocoriaceous": membranocoriaceous,
1229+ "membranogenic": membranogenic,
1230+ "nonbookish": nonbookish,
1231+ "overtrump": overtrump,
1232+ "scotino": scotino,
1233+ "seasonable": seasonable,
1234+ "sephen": sephen,
1235+ "stigmarioid": stigmarioid,
1236+ "tired": tired,
1237+ "trifid": trifid,
1238+ "undefeatedly": undefeatedly,
1239+ "ungirlish": ungirlish,
1240+ };
1241+}
1242+
1243+class StrenuosityClass {
1244+ int? bliss;
1245+ int? buccate;
1246+ int? bulletproof;
1247+ double? catharticalness;
1248+ int? chirotherium;
1249+ int? crumblingness;
1250+ String? disdiapason;
1251+ int? engagedly;
1252+ int? fightable;
1253+ int? hoariness;
1254+ bool? homocerc;
1255+ int? hypopodium;
1256+ int? luxurist;
1257+ int? mechanician;
1258+ dynamic nonbookish;
1259+ int? onopordon;
1260+ int? podgily;
1261+ int? reformableness;
1262+ int? scatterbrains;
1263+ int? seminuria;
1264+ int? sodomite;
1265+ int? tramp;
1266+ int? undueness;
1267+ int? worthily;
1268+ int? yankeeist;
1269+
1270+ StrenuosityClass({
1271+ this.bliss,
1272+ this.buccate,
1273+ this.bulletproof,
1274+ this.catharticalness,
1275+ this.chirotherium,
1276+ this.crumblingness,
1277+ this.disdiapason,
1278+ this.engagedly,
1279+ this.fightable,
1280+ this.hoariness,
1281+ this.homocerc,
1282+ this.hypopodium,
1283+ this.luxurist,
1284+ this.mechanician,
1285+ this.nonbookish,
1286+ this.onopordon,
1287+ this.podgily,
1288+ this.reformableness,
1289+ this.scatterbrains,
1290+ this.seminuria,
1291+ this.sodomite,
1292+ this.tramp,
1293+ this.undueness,
1294+ this.worthily,
1295+ this.yankeeist,
1296+ });
1297+
1298+ factory StrenuosityClass.fromJson(Map<String, dynamic> json) => StrenuosityClass(
1299+ bliss: json["bliss"],
1300+ buccate: json["buccate"],
1301+ bulletproof: json["bulletproof"],
1302+ catharticalness: json["catharticalness"]?.toDouble(),
1303+ chirotherium: json["Chirotherium"],
1304+ crumblingness: json["crumblingness"],
1305+ disdiapason: json["disdiapason"],
1306+ engagedly: json["engagedly"],
1307+ fightable: json["fightable"],
1308+ hoariness: json["hoariness"],
1309+ homocerc: json["homocerc"],
1310+ hypopodium: json["hypopodium"],
1311+ luxurist: json["luxurist"],
1312+ mechanician: json["mechanician"],
1313+ nonbookish: json["nonbookish"],
1314+ onopordon: json["Onopordon"],
1315+ podgily: json["podgily"],
1316+ reformableness: json["reformableness"],
1317+ scatterbrains: json["scatterbrains"],
1318+ seminuria: json["seminuria"],
1319+ sodomite: json["Sodomite"],
1320+ tramp: json["tramp"],
1321+ undueness: json["undueness"],
1322+ worthily: json["worthily"],
1323+ yankeeist: json["Yankeeist"],
1324+ );
1325+
1326+ Map<String, dynamic> toJson() => {
1327+ "bliss": bliss,
1328+ "buccate": buccate,
1329+ "bulletproof": bulletproof,
1330+ "catharticalness": catharticalness,
1331+ "Chirotherium": chirotherium,
1332+ "crumblingness": crumblingness,
1333+ "disdiapason": disdiapason,
1334+ "engagedly": engagedly,
1335+ "fightable": fightable,
1336+ "hoariness": hoariness,
1337+ "homocerc": homocerc,
1338+ "hypopodium": hypopodium,
1339+ "luxurist": luxurist,
1340+ "mechanician": mechanician,
1341+ "nonbookish": nonbookish,
1342+ "Onopordon": onopordon,
1343+ "podgily": podgily,
1344+ "reformableness": reformableness,
1345+ "scatterbrains": scatterbrains,
1346+ "seminuria": seminuria,
1347+ "Sodomite": sodomite,
1348+ "tramp": tramp,
1349+ "undueness": undueness,
1350+ "worthily": worthily,
1351+ "Yankeeist": yankeeist,
1352+ };
1353+}
1354+
1355+class TruantcyClass {
1356+ dynamic alfiona;
1357+ dynamic ascaridiasis;
1358+ dynamic bungey;
1359+ double? catharticalness;
1360+ dynamic ceroxyle;
1361+ int? chirotherium;
1362+ dynamic chorology;
1363+ String? disdiapason;
1364+ dynamic enmarble;
1365+ dynamic epeira;
1366+ dynamic eurylaimi;
1367+ dynamic germination;
1368+ dynamic hallelujah;
1369+ bool? homocerc;
1370+ dynamic lev;
1371+ dynamic mouthing;
1372+ dynamic nonbookish;
1373+ dynamic philliloo;
1374+ dynamic planetal;
1375+ dynamic poney;
1376+ dynamic punctualist;
1377+ dynamic returnlessly;
1378+ dynamic skelder;
1379+ dynamic windwaywardly;
1380+ dynamic yuman;
1381+
1382+ TruantcyClass({
1383+ this.alfiona,
1384+ this.ascaridiasis,
1385+ this.bungey,
1386+ this.catharticalness,
1387+ this.ceroxyle,
1388+ this.chirotherium,
1389+ this.chorology,
1390+ this.disdiapason,
1391+ this.enmarble,
1392+ this.epeira,
1393+ this.eurylaimi,
1394+ this.germination,
1395+ this.hallelujah,
1396+ this.homocerc,
1397+ this.lev,
1398+ this.mouthing,
1399+ this.nonbookish,
1400+ this.philliloo,
1401+ this.planetal,
1402+ this.poney,
1403+ this.punctualist,
1404+ this.returnlessly,
1405+ this.skelder,
1406+ this.windwaywardly,
1407+ this.yuman,
1408+ });
1409+
1410+ factory TruantcyClass.fromJson(Map<String, dynamic> json) => TruantcyClass(
1411+ alfiona: json["alfiona"],
1412+ ascaridiasis: json["ascaridiasis"],
1413+ bungey: json["bungey"],
1414+ catharticalness: json["catharticalness"]?.toDouble(),
1415+ ceroxyle: json["ceroxyle"],
1416+ chirotherium: json["Chirotherium"],
1417+ chorology: json["chorology"],
1418+ disdiapason: json["disdiapason"],
1419+ enmarble: json["enmarble"],
1420+ epeira: json["Epeira"],
1421+ eurylaimi: json["Eurylaimi"],
1422+ germination: json["germination"],
1423+ hallelujah: json["hallelujah"],
1424+ homocerc: json["homocerc"],
1425+ lev: json["lev"],
1426+ mouthing: json["mouthing"],
1427+ nonbookish: json["nonbookish"],
1428+ philliloo: json["philliloo"],
1429+ planetal: json["planetal"],
1430+ poney: json["poney"],
1431+ punctualist: json["punctualist"],
1432+ returnlessly: json["returnlessly"],
1433+ skelder: json["skelder"],
1434+ windwaywardly: json["windwaywardly"],
1435+ yuman: json["Yuman"],
1436+ );
1437+
1438+ Map<String, dynamic> toJson() => {
1439+ "alfiona": alfiona,
1440+ "ascaridiasis": ascaridiasis,
1441+ "bungey": bungey,
1442+ "catharticalness": catharticalness,
1443+ "ceroxyle": ceroxyle,
1444+ "Chirotherium": chirotherium,
1445+ "chorology": chorology,
1446+ "disdiapason": disdiapason,
1447+ "enmarble": enmarble,
1448+ "Epeira": epeira,
1449+ "Eurylaimi": eurylaimi,
1450+ "germination": germination,
1451+ "hallelujah": hallelujah,
1452+ "homocerc": homocerc,
1453+ "lev": lev,
1454+ "mouthing": mouthing,
1455+ "nonbookish": nonbookish,
1456+ "philliloo": philliloo,
1457+ "planetal": planetal,
1458+ "poney": poney,
1459+ "punctualist": punctualist,
1460+ "returnlessly": returnlessly,
1461+ "skelder": skelder,
1462+ "windwaywardly": windwaywardly,
1463+ "Yuman": yuman,
1464+ };
1465+}
1466+
1467+class UnimpeachablyClass {
1468+ int? acerin;
1469+ int? bobadil;
1470+ double? catharticalness;
1471+ int? chirotherium;
1472+ int? chlorophylligenous;
1473+ int? conversational;
1474+ int? demiowl;
1475+ String? disdiapason;
1476+ int? ectorhinal;
1477+ int? gamblesomeness;
1478+ bool? homocerc;
1479+ int? irrorate;
1480+ int? kindergartening;
1481+ int? lateritic;
1482+ int? mespil;
1483+ int? misconfiguration;
1484+ dynamic nonbookish;
1485+ int? planometry;
1486+ int? quiina;
1487+ int? robert;
1488+ int? rot;
1489+ int? subcinctorium;
1490+ int? tussocker;
1491+ int? ultraproud;
1492+ int? unsuggestedness;
1493+
1494+ UnimpeachablyClass({
1495+ this.acerin,
1496+ this.bobadil,
1497+ this.catharticalness,
1498+ this.chirotherium,
1499+ this.chlorophylligenous,
1500+ this.conversational,
1501+ this.demiowl,
1502+ this.disdiapason,
1503+ this.ectorhinal,
1504+ this.gamblesomeness,
1505+ this.homocerc,
1506+ this.irrorate,
1507+ this.kindergartening,
1508+ this.lateritic,
1509+ this.mespil,
1510+ this.misconfiguration,
1511+ this.nonbookish,
1512+ this.planometry,
1513+ this.quiina,
1514+ this.robert,
1515+ this.rot,
1516+ this.subcinctorium,
1517+ this.tussocker,
1518+ this.ultraproud,
1519+ this.unsuggestedness,
1520+ });
1521+
1522+ factory UnimpeachablyClass.fromJson(Map<String, dynamic> json) => UnimpeachablyClass(
1523+ acerin: json["acerin"],
1524+ bobadil: json["Bobadil"],
1525+ catharticalness: json["catharticalness"]?.toDouble(),
1526+ chirotherium: json["Chirotherium"],
1527+ chlorophylligenous: json["chlorophylligenous"],
1528+ conversational: json["conversational"],
1529+ demiowl: json["demiowl"],
1530+ disdiapason: json["disdiapason"],
1531+ ectorhinal: json["ectorhinal"],
1532+ gamblesomeness: json["gamblesomeness"],
1533+ homocerc: json["homocerc"],
1534+ irrorate: json["irrorate"],
1535+ kindergartening: json["kindergartening"],
1536+ lateritic: json["lateritic"],
1537+ mespil: json["mespil"],
1538+ misconfiguration: json["misconfiguration"],
1539+ nonbookish: json["nonbookish"],
1540+ planometry: json["planometry"],
1541+ quiina: json["Quiina"],
1542+ robert: json["Robert"],
1543+ rot: json["rot"],
1544+ subcinctorium: json["subcinctorium"],
1545+ tussocker: json["tussocker"],
1546+ ultraproud: json["ultraproud"],
1547+ unsuggestedness: json["unsuggestedness"],
1548+ );
1549+
1550+ Map<String, dynamic> toJson() => {
1551+ "acerin": acerin,
1552+ "Bobadil": bobadil,
1553+ "catharticalness": catharticalness,
1554+ "Chirotherium": chirotherium,
1555+ "chlorophylligenous": chlorophylligenous,
1556+ "conversational": conversational,
1557+ "demiowl": demiowl,
1558+ "disdiapason": disdiapason,
1559+ "ectorhinal": ectorhinal,
1560+ "gamblesomeness": gamblesomeness,
1561+ "homocerc": homocerc,
1562+ "irrorate": irrorate,
1563+ "kindergartening": kindergartening,
1564+ "lateritic": lateritic,
1565+ "mespil": mespil,
1566+ "misconfiguration": misconfiguration,
1567+ "nonbookish": nonbookish,
1568+ "planometry": planometry,
1569+ "Quiina": quiina,
1570+ "Robert": robert,
1571+ "rot": rot,
1572+ "subcinctorium": subcinctorium,
1573+ "tussocker": tussocker,
1574+ "ultraproud": ultraproud,
1575+ "unsuggestedness": unsuggestedness,
1576+ };
1577+}
1578+
1579+class UnstressedClass {
1580+ dynamic alain;
1581+ dynamic amphirhina;
1582+ dynamic antimachinery;
1583+ dynamic coldish;
1584+ dynamic crantara;
1585+ dynamic distinguishing;
1586+ dynamic elytroposis;
1587+ dynamic gentianwort;
1588+ dynamic heliosis;
1589+ dynamic instrumental;
1590+ dynamic introinflection;
1591+ dynamic kala;
1592+ dynamic lincolnian;
1593+ dynamic metad;
1594+ dynamic sarcophilus;
1595+ dynamic swingingly;
1596+ dynamic unconformity;
1597+ dynamic undecreed;
1598+ dynamic venerable;
1599+ dynamic vowellessness;
1600+
1601+ UnstressedClass({
1602+ required this.alain,
1603+ required this.amphirhina,
1604+ required this.antimachinery,
1605+ required this.coldish,
1606+ required this.crantara,
1607+ required this.distinguishing,
1608+ required this.elytroposis,
1609+ required this.gentianwort,
1610+ required this.heliosis,
1611+ required this.instrumental,
1612+ required this.introinflection,
1613+ required this.kala,
1614+ required this.lincolnian,
1615+ required this.metad,
1616+ required this.sarcophilus,
1617+ required this.swingingly,
1618+ required this.unconformity,
1619+ required this.undecreed,
1620+ required this.venerable,
1621+ required this.vowellessness,
1622+ });
1623+
1624+ factory UnstressedClass.fromJson(Map<String, dynamic> json) => UnstressedClass(
1625+ alain: json["Alain"],
1626+ amphirhina: json["Amphirhina"],
1627+ antimachinery: json["antimachinery"],
1628+ coldish: json["coldish"],
1629+ crantara: json["crantara"],
1630+ distinguishing: json["distinguishing"],
1631+ elytroposis: json["elytroposis"],
1632+ gentianwort: json["gentianwort"],
1633+ heliosis: json["heliosis"],
1634+ instrumental: json["instrumental"],
1635+ introinflection: json["introinflection"],
1636+ kala: json["kala"],
1637+ lincolnian: json["Lincolnian"],
1638+ metad: json["metad"],
1639+ sarcophilus: json["Sarcophilus"],
1640+ swingingly: json["swingingly"],
1641+ unconformity: json["unconformity"],
1642+ undecreed: json["undecreed"],
1643+ venerable: json["venerable"],
1644+ vowellessness: json["vowellessness"],
1645+ );
1646+
1647+ Map<String, dynamic> toJson() => {
1648+ "Alain": alain,
1649+ "Amphirhina": amphirhina,
1650+ "antimachinery": antimachinery,
1651+ "coldish": coldish,
1652+ "crantara": crantara,
1653+ "distinguishing": distinguishing,
1654+ "elytroposis": elytroposis,
1655+ "gentianwort": gentianwort,
1656+ "heliosis": heliosis,
1657+ "instrumental": instrumental,
1658+ "introinflection": introinflection,
1659+ "kala": kala,
1660+ "Lincolnian": lincolnian,
1661+ "metad": metad,
1662+ "Sarcophilus": sarcophilus,
1663+ "swingingly": swingingly,
1664+ "unconformity": unconformity,
1665+ "undecreed": undecreed,
1666+ "venerable": venerable,
1667+ "vowellessness": vowellessness,
1668+ };
1669+}
1670+
1671+class WrothyClass {
1672+ dynamic aeschynanthus;
1673+ dynamic aquiferous;
1674+ dynamic cheapener;
1675+ dynamic enumeration;
1676+ dynamic ephesine;
1677+ dynamic escadrille;
1678+ dynamic estrous;
1679+ dynamic interestedly;
1680+ dynamic katakinetomer;
1681+ dynamic mortification;
1682+ dynamic morula;
1683+ dynamic orthosymmetrical;
1684+ dynamic overbark;
1685+ dynamic politist;
1686+ dynamic qualified;
1687+ dynamic sphenomalar;
1688+ dynamic throatful;
1689+ dynamic transhumance;
1690+ dynamic triandrian;
1691+ dynamic unbooked;
1692+
1693+ WrothyClass({
1694+ required this.aeschynanthus,
1695+ required this.aquiferous,
1696+ required this.cheapener,
1697+ required this.enumeration,
1698+ required this.ephesine,
1699+ required this.escadrille,
1700+ required this.estrous,
1701+ required this.interestedly,
1702+ required this.katakinetomer,
1703+ required this.mortification,
1704+ required this.morula,
1705+ required this.orthosymmetrical,
1706+ required this.overbark,
1707+ required this.politist,
1708+ required this.qualified,
1709+ required this.sphenomalar,
1710+ required this.throatful,
1711+ required this.transhumance,
1712+ required this.triandrian,
1713+ required this.unbooked,
1714+ });
1715+
1716+ factory WrothyClass.fromJson(Map<String, dynamic> json) => WrothyClass(
1717+ aeschynanthus: json["Aeschynanthus"],
1718+ aquiferous: json["aquiferous"],
1719+ cheapener: json["cheapener"],
1720+ enumeration: json["enumeration"],
1721+ ephesine: json["Ephesine"],
1722+ escadrille: json["escadrille"],
1723+ estrous: json["estrous"],
1724+ interestedly: json["interestedly"],
1725+ katakinetomer: json["katakinetomer"],
1726+ mortification: json["mortification"],
1727+ morula: json["morula"],
1728+ orthosymmetrical: json["orthosymmetrical"],
1729+ overbark: json["overbark"],
1730+ politist: json["politist"],
1731+ qualified: json["qualified"],
1732+ sphenomalar: json["sphenomalar"],
1733+ throatful: json["throatful"],
1734+ transhumance: json["transhumance"],
1735+ triandrian: json["triandrian"],
1736+ unbooked: json["unbooked"],
1737+ );
1738+
1739+ Map<String, dynamic> toJson() => {
1740+ "Aeschynanthus": aeschynanthus,
1741+ "aquiferous": aquiferous,
1742+ "cheapener": cheapener,
1743+ "enumeration": enumeration,
1744+ "Ephesine": ephesine,
1745+ "escadrille": escadrille,
1746+ "estrous": estrous,
1747+ "interestedly": interestedly,
1748+ "katakinetomer": katakinetomer,
1749+ "mortification": mortification,
1750+ "morula": morula,
1751+ "orthosymmetrical": orthosymmetrical,
1752+ "overbark": overbark,
1753+ "politist": politist,
1754+ "qualified": qualified,
1755+ "sphenomalar": sphenomalar,
1756+ "throatful": throatful,
1757+ "transhumance": transhumance,
1758+ "triandrian": triandrian,
1759+ "unbooked": unbooked,
1760+ };
1761+}
Test case

test/inputs/json/priority/direct-recursive.json

1 generated file · +41 −0
Adartdefault / TopLevel.dart+41 −0
@@ -0,0 +1,41 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final TopLevel? also;
13+ final bool bar;
14+ final int foo;
15+ final double moo;
16+ final String quux;
17+
18+ TopLevel({
19+ this.also,
20+ required this.bar,
21+ required this.foo,
22+ required this.moo,
23+ required this.quux,
24+ });
25+
26+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
27+ also: json["also"] == null ? null : TopLevel.fromJson(json["also"]),
28+ bar: json["bar"],
29+ foo: json["foo"],
30+ moo: json["moo"]?.toDouble(),
31+ quux: json["quux"],
32+ );
33+
34+ Map<String, dynamic> toJson() => {
35+ "also": also?.toJson(),
36+ "bar": bar,
37+ "foo": foo,
38+ "moo": moo,
39+ "quux": quux,
40+ };
41+}
Test case

test/inputs/json/priority/list.json

1 generated file · +29 −0
Adartdefault / TopLevel.dart+29 −0
@@ -0,0 +1,29 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final int data;
13+ final TopLevel? next;
14+
15+ TopLevel({
16+ required this.data,
17+ required this.next,
18+ });
19+
20+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
21+ data: json["data"],
22+ next: json["next"] == null ? null : TopLevel.fromJson(json["next"]),
23+ );
24+
25+ Map<String, dynamic> toJson() => {
26+ "data": data,
27+ "next": next?.toJson(),
28+ };
29+}
Test case

test/inputs/json/priority/nbl-stats.json

1 generated file · +1,225 −0
Adartdefault / TopLevel.dart+1,225 −0
@@ -0,0 +1,1225 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final int attendance;
13+ final String clock;
14+ final int disableMatch;
15+ final int inOt;
16+ final List<List<dynamic>> leaddata;
17+ final String officialsReferee1;
18+ final String officialsReferee2;
19+ final String officialsReferee3;
20+ final List<Othermatch> othermatches;
21+ final List<Pbp> pbp;
22+ final int period;
23+ final int periodLengthOvertime;
24+ final int periodLengthRegular;
25+ final PerType periodType;
26+ final int periodsMax;
27+ final Map<String, List<Scorer>> scorers;
28+ final List<dynamic> timeline;
29+ final Map<String, Tm> tm;
30+ final int totalTimeAdded;
31+ final Totallds totallds;
32+
33+ TopLevel({
34+ required this.attendance,
35+ required this.clock,
36+ required this.disableMatch,
37+ required this.inOt,
38+ required this.leaddata,
39+ required this.officialsReferee1,
40+ required this.officialsReferee2,
41+ required this.officialsReferee3,
42+ required this.othermatches,
43+ required this.pbp,
44+ required this.period,
45+ required this.periodLengthOvertime,
46+ required this.periodLengthRegular,
47+ required this.periodType,
48+ required this.periodsMax,
49+ required this.scorers,
50+ required this.timeline,
51+ required this.tm,
52+ required this.totalTimeAdded,
53+ required this.totallds,
54+ });
55+
56+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
57+ attendance: json["attendance"],
58+ clock: json["clock"],
59+ disableMatch: json["disableMatch"],
60+ inOt: json["inOT"],
61+ leaddata: List<List<dynamic>>.from(json["leaddata"].map((x) => List<dynamic>.from(x.map((x) => x)))),
62+ officialsReferee1: json["officials_referee1"],
63+ officialsReferee2: json["officials_referee2"],
64+ officialsReferee3: json["officials_referee3"],
65+ othermatches: List<Othermatch>.from(json["othermatches"].map((x) => Othermatch.fromJson(x))),
66+ pbp: List<Pbp>.from(json["pbp"].map((x) => Pbp.fromJson(x))),
67+ period: json["period"],
68+ periodLengthOvertime: json["periodLengthOVERTIME"],
69+ periodLengthRegular: json["periodLengthREGULAR"],
70+ periodType: perTypeValues.map[json["periodType"]]!,
71+ periodsMax: json["periodsMax"],
72+ scorers: Map.from(json["scorers"]).map((k, v) => MapEntry<String, List<Scorer>>(k, List<Scorer>.from(v.map((x) => Scorer.fromJson(x))))),
73+ timeline: List<dynamic>.from(json["timeline"].map((x) => x)),
74+ tm: Map.from(json["tm"]).map((k, v) => MapEntry<String, Tm>(k, Tm.fromJson(v))),
75+ totalTimeAdded: json["totalTimeAdded"],
76+ totallds: Totallds.fromJson(json["totallds"]),
77+ );
78+
79+ Map<String, dynamic> toJson() => {
80+ "attendance": attendance,
81+ "clock": clock,
82+ "disableMatch": disableMatch,
83+ "inOT": inOt,
84+ "leaddata": List<dynamic>.from(leaddata.map((x) => List<dynamic>.from(x.map((x) => x)))),
85+ "officials_referee1": officialsReferee1,
86+ "officials_referee2": officialsReferee2,
87+ "officials_referee3": officialsReferee3,
88+ "othermatches": List<dynamic>.from(othermatches.map((x) => x.toJson())),
89+ "pbp": List<dynamic>.from(pbp.map((x) => x.toJson())),
90+ "period": period,
91+ "periodLengthOVERTIME": periodLengthOvertime,
92+ "periodLengthREGULAR": periodLengthRegular,
93+ "periodType": perTypeValues.reverse[periodType],
94+ "periodsMax": periodsMax,
95+ "scorers": Map.from(scorers).map((k, v) => MapEntry<String, dynamic>(k, List<dynamic>.from(v.map((x) => x.toJson())))),
96+ "timeline": List<dynamic>.from(timeline.map((x) => x)),
97+ "tm": Map.from(tm).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
98+ "totalTimeAdded": totalTimeAdded,
99+ "totallds": totallds.toJson(),
100+ };
101+}
102+
103+enum LeaddatumEnum {
104+ EMPTY,
105+ P1,
106+ P2,
107+ P3,
108+ P4
109+}
110+
111+final leaddatumEnumValues = EnumValues({
112+ "": LeaddatumEnum.EMPTY,
113+ "P1": LeaddatumEnum.P1,
114+ "P2": LeaddatumEnum.P2,
115+ "P3": LeaddatumEnum.P3,
116+ "P4": LeaddatumEnum.P4
117+});
118+
119+class Othermatch {
120+ final String clock;
121+ final String competitionName;
122+ final String id;
123+ final int period;
124+ final PerType periodType;
125+ final Team team1;
126+ final String team1Name;
127+ final int team1Score;
128+ final Team team2;
129+ final String team2Name;
130+ final int team2Score;
131+
132+ Othermatch({
133+ required this.clock,
134+ required this.competitionName,
135+ required this.id,
136+ required this.period,
137+ required this.periodType,
138+ required this.team1,
139+ required this.team1Name,
140+ required this.team1Score,
141+ required this.team2,
142+ required this.team2Name,
143+ required this.team2Score,
144+ });
145+
146+ factory Othermatch.fromJson(Map<String, dynamic> json) => Othermatch(
147+ clock: json["clock"],
148+ competitionName: json["competitionName"],
149+ id: json["id"],
150+ period: json["period"],
151+ periodType: perTypeValues.map[json["periodType"]]!,
152+ team1: Team.fromJson(json["team1"]),
153+ team1Name: json["team1Name"],
154+ team1Score: json["team1Score"],
155+ team2: Team.fromJson(json["team2"]),
156+ team2Name: json["team2Name"],
157+ team2Score: json["team2Score"],
158+ );
159+
160+ Map<String, dynamic> toJson() => {
161+ "clock": clock,
162+ "competitionName": competitionName,
163+ "id": id,
164+ "period": period,
165+ "periodType": perTypeValues.reverse[periodType],
166+ "team1": team1.toJson(),
167+ "team1Name": team1Name,
168+ "team1Score": team1Score,
169+ "team2": team2.toJson(),
170+ "team2Name": team2Name,
171+ "team2Score": team2Score,
172+ };
173+}
174+
175+enum PerType {
176+ REGULAR
177+}
178+
179+final perTypeValues = EnumValues({
180+ "REGULAR": PerType.REGULAR
181+});
182+
183+class Team {
184+ final String teamCode;
185+ final String teamCodeInternational;
186+ final String teamName;
187+ final String teamNameInternational;
188+
189+ Team({
190+ required this.teamCode,
191+ required this.teamCodeInternational,
192+ required this.teamName,
193+ required this.teamNameInternational,
194+ });
195+
196+ factory Team.fromJson(Map<String, dynamic> json) => Team(
197+ teamCode: json["teamCode"],
198+ teamCodeInternational: json["teamCodeInternational"],
199+ teamName: json["teamName"],
200+ teamNameInternational: json["teamNameInternational"],
201+ );
202+
203+ Map<String, dynamic> toJson() => {
204+ "teamCode": teamCode,
205+ "teamCodeInternational": teamCodeInternational,
206+ "teamName": teamName,
207+ "teamNameInternational": teamNameInternational,
208+ };
209+}
210+
211+class Pbp {
212+ final ActionType actionType;
213+ final String? familyName;
214+ final FamilyNameInitial? familyNameInitial;
215+ final String? firstName;
216+ final FirstNameInitial? firstNameInitial;
217+ final String gt;
218+ final String? internationalFamilyName;
219+ final FamilyNameInitial? internationalFamilyNameInitial;
220+ final String? internationalFirstName;
221+ final FirstNameInitial? internationalFirstNameInitial;
222+ final int lead;
223+ final int period;
224+ final PerType periodType;
225+ final String player;
226+ final int pno;
227+ final String qualifier;
228+ final int s1;
229+ final int s2;
230+ final ScoreboardName? scoreboardName;
231+ final int scoring;
232+ final String shirtNumber;
233+ final String subType;
234+ final int success;
235+ final int tno;
236+
237+ Pbp({
238+ required this.actionType,
239+ this.familyName,
240+ this.familyNameInitial,
241+ this.firstName,
242+ this.firstNameInitial,
243+ required this.gt,
244+ this.internationalFamilyName,
245+ this.internationalFamilyNameInitial,
246+ this.internationalFirstName,
247+ this.internationalFirstNameInitial,
248+ required this.lead,
249+ required this.period,
250+ required this.periodType,
251+ required this.player,
252+ required this.pno,
253+ required this.qualifier,
254+ required this.s1,
255+ required this.s2,
256+ this.scoreboardName,
257+ required this.scoring,
258+ required this.shirtNumber,
259+ required this.subType,
260+ required this.success,
261+ required this.tno,
262+ });
263+
264+ factory Pbp.fromJson(Map<String, dynamic> json) => Pbp(
265+ actionType: actionTypeValues.map[json["actionType"]]!,
266+ familyName: json["familyName"],
267+ familyNameInitial: familyNameInitialValues.map[json["familyNameInitial"]],
268+ firstName: json["firstName"],
269+ firstNameInitial: firstNameInitialValues.map[json["firstNameInitial"]],
270+ gt: json["gt"],
271+ internationalFamilyName: json["internationalFamilyName"],
272+ internationalFamilyNameInitial: familyNameInitialValues.map[json["internationalFamilyNameInitial"]],
273+ internationalFirstName: json["internationalFirstName"],
274+ internationalFirstNameInitial: firstNameInitialValues.map[json["internationalFirstNameInitial"]],
275+ lead: json["lead"],
276+ period: json["period"],
277+ periodType: perTypeValues.map[json["periodType"]]!,
278+ player: json["player"],
279+ pno: json["pno"],
280+ qualifier: json["qualifier"],
281+ s1: json["s1"],
282+ s2: json["s2"],
283+ scoreboardName: scoreboardNameValues.map[json["scoreboardName"]],
284+ scoring: json["scoring"],
285+ shirtNumber: json["shirtNumber"],
286+ subType: json["subType"],
287+ success: json["success"],
288+ tno: json["tno"],
289+ );
290+
291+ Map<String, dynamic> toJson() => {
292+ "actionType": actionTypeValues.reverse[actionType],
293+ "familyName": familyName,
294+ "familyNameInitial": familyNameInitialValues.reverse[familyNameInitial],
295+ "firstName": firstName,
296+ "firstNameInitial": firstNameInitialValues.reverse[firstNameInitial],
297+ "gt": gt,
298+ "internationalFamilyName": internationalFamilyName,
299+ "internationalFamilyNameInitial": familyNameInitialValues.reverse[internationalFamilyNameInitial],
300+ "internationalFirstName": internationalFirstName,
301+ "internationalFirstNameInitial": firstNameInitialValues.reverse[internationalFirstNameInitial],
302+ "lead": lead,
303+ "period": period,
304+ "periodType": perTypeValues.reverse[periodType],
305+ "player": player,
306+ "pno": pno,
307+ "qualifier": qualifier,
308+ "s1": s1,
309+ "s2": s2,
310+ "scoreboardName": scoreboardNameValues.reverse[scoreboardName],
311+ "scoring": scoring,
312+ "shirtNumber": shirtNumber,
313+ "subType": subType,
314+ "success": success,
315+ "tno": tno,
316+ };
317+}
318+
319+enum ActionType {
320+ GAME,
321+ PERIOD,
322+ THE_3_PT,
323+ THE_2_PT,
324+ REBOUND,
325+ TIMEOUT,
326+ FOULON,
327+ FOUL,
328+ ASSIST,
329+ SUBSTITUTION,
330+ FREETHROW,
331+ STEAL,
332+ TURNOVER,
333+ BLOCK,
334+ JUMPBALL
335+}
336+
337+final actionTypeValues = EnumValues({
338+ "game": ActionType.GAME,
339+ "period": ActionType.PERIOD,
340+ "3pt": ActionType.THE_3_PT,
341+ "2pt": ActionType.THE_2_PT,
342+ "rebound": ActionType.REBOUND,
343+ "timeout": ActionType.TIMEOUT,
344+ "foulon": ActionType.FOULON,
345+ "foul": ActionType.FOUL,
346+ "assist": ActionType.ASSIST,
347+ "substitution": ActionType.SUBSTITUTION,
348+ "freethrow": ActionType.FREETHROW,
349+ "steal": ActionType.STEAL,
350+ "turnover": ActionType.TURNOVER,
351+ "block": ActionType.BLOCK,
352+ "jumpball": ActionType.JUMPBALL
353+});
354+
355+enum FamilyNameInitial {
356+ R,
357+ M,
358+ S,
359+ C,
360+ O,
361+ W,
362+ A,
363+ P,
364+ V,
365+ I,
366+ J,
367+ FAMILY_NAME_INITIAL_S,
368+ H,
369+ B
370+}
371+
372+final familyNameInitialValues = EnumValues({
373+ "R": FamilyNameInitial.R,
374+ "M": FamilyNameInitial.M,
375+ "s": FamilyNameInitial.S,
376+ "C": FamilyNameInitial.C,
377+ "O": FamilyNameInitial.O,
378+ "W": FamilyNameInitial.W,
379+ "A": FamilyNameInitial.A,
380+ "P": FamilyNameInitial.P,
381+ "V": FamilyNameInitial.V,
382+ "I": FamilyNameInitial.I,
383+ "J": FamilyNameInitial.J,
384+ "S": FamilyNameInitial.FAMILY_NAME_INITIAL_S,
385+ "H": FamilyNameInitial.H,
386+ "B": FamilyNameInitial.B
387+});
388+
389+enum FirstNameInitial {
390+ D,
391+ J,
392+ T,
393+ C,
394+ O,
395+ H,
396+ L,
397+ A,
398+ K,
399+ R,
400+ B,
401+ N
402+}
403+
404+final firstNameInitialValues = EnumValues({
405+ "D": FirstNameInitial.D,
406+ "J": FirstNameInitial.J,
407+ "T": FirstNameInitial.T,
408+ "C": FirstNameInitial.C,
409+ "O": FirstNameInitial.O,
410+ "H": FirstNameInitial.H,
411+ "L": FirstNameInitial.L,
412+ "A": FirstNameInitial.A,
413+ "K": FirstNameInitial.K,
414+ "R": FirstNameInitial.R,
415+ "B": FirstNameInitial.B,
416+ "N": FirstNameInitial.N
417+});
418+
419+enum ScoreboardName {
420+ EMPTY,
421+ T_S,
422+ R_IHATA,
423+ D_JONES,
424+ B_VALENTINE
425+}
426+
427+final scoreboardNameValues = EnumValues({
428+ "": ScoreboardName.EMPTY,
429+ "T. s": ScoreboardName.T_S,
430+ "R. Ihata": ScoreboardName.R_IHATA,
431+ "D. Jones": ScoreboardName.D_JONES,
432+ "B. Valentine": ScoreboardName.B_VALENTINE
433+});
434+
435+class Scorer {
436+ final String? familyName;
437+ final FamilyNameInitial? familyNameInitial;
438+ final String? firstName;
439+ final FirstNameInitial? firstNameInitial;
440+ final String? gt;
441+ final String? internationalFamilyName;
442+ final FamilyNameInitial? internationalFamilyNameInitial;
443+ final String? internationalFirstName;
444+ final FirstNameInitial? internationalFirstNameInitial;
445+ final String? name;
446+ final int? per;
447+ final PerType? perType;
448+ final String? player;
449+ final int pno;
450+ final ScoreboardName? scoreboardName;
451+ final String shirtNumber;
452+ final String? summary;
453+ final List<Time>? times;
454+ final int tno;
455+ final int? tot;
456+
457+ Scorer({
458+ this.familyName,
459+ this.familyNameInitial,
460+ this.firstName,
461+ this.firstNameInitial,
462+ this.gt,
463+ this.internationalFamilyName,
464+ this.internationalFamilyNameInitial,
465+ this.internationalFirstName,
466+ this.internationalFirstNameInitial,
467+ this.name,
468+ this.per,
469+ this.perType,
470+ this.player,
471+ required this.pno,
472+ this.scoreboardName,
473+ required this.shirtNumber,
474+ this.summary,
475+ this.times,
476+ required this.tno,
477+ this.tot,
478+ });
479+
480+ factory Scorer.fromJson(Map<String, dynamic> json) => Scorer(
481+ familyName: json["familyName"],
482+ familyNameInitial: familyNameInitialValues.map[json["familyNameInitial"]],
483+ firstName: json["firstName"],
484+ firstNameInitial: firstNameInitialValues.map[json["firstNameInitial"]],
485+ gt: json["gt"],
486+ internationalFamilyName: json["internationalFamilyName"],
487+ internationalFamilyNameInitial: familyNameInitialValues.map[json["internationalFamilyNameInitial"]],
488+ internationalFirstName: json["internationalFirstName"],
489+ internationalFirstNameInitial: firstNameInitialValues.map[json["internationalFirstNameInitial"]],
490+ name: json["name"],
491+ per: json["per"],
492+ perType: perTypeValues.map[json["perType"]],
493+ player: json["player"],
494+ pno: json["pno"],
495+ scoreboardName: scoreboardNameValues.map[json["scoreboardName"]],
496+ shirtNumber: json["shirtNumber"],
497+ summary: json["summary"],
498+ times: json["times"] == null ? null : List<Time>.from(json["times"]!.map((x) => Time.fromJson(x))),
499+ tno: json["tno"],
500+ tot: json["tot"],
501+ );
502+
503+ Map<String, dynamic> toJson() => {
504+ "familyName": familyName,
505+ "familyNameInitial": familyNameInitialValues.reverse[familyNameInitial],
506+ "firstName": firstName,
507+ "firstNameInitial": firstNameInitialValues.reverse[firstNameInitial],
508+ "gt": gt,
509+ "internationalFamilyName": internationalFamilyName,
510+ "internationalFamilyNameInitial": familyNameInitialValues.reverse[internationalFamilyNameInitial],
511+ "internationalFirstName": internationalFirstName,
512+ "internationalFirstNameInitial": firstNameInitialValues.reverse[internationalFirstNameInitial],
513+ "name": name,
514+ "per": per,
515+ "perType": perTypeValues.reverse[perType],
516+ "player": player,
517+ "pno": pno,
518+ "scoreboardName": scoreboardNameValues.reverse[scoreboardName],
519+ "shirtNumber": shirtNumber,
520+ "summary": summary,
521+ "times": times == null ? null : List<dynamic>.from(times!.map((x) => x.toJson())),
522+ "tno": tno,
523+ "tot": tot,
524+ };
525+}
526+
527+class Time {
528+ final String gt;
529+ final int per;
530+ final PerType perType;
531+
532+ Time({
533+ required this.gt,
534+ required this.per,
535+ required this.perType,
536+ });
537+
538+ factory Time.fromJson(Map<String, dynamic> json) => Time(
539+ gt: json["gt"],
540+ per: json["per"],
541+ perType: perTypeValues.map[json["perType"]]!,
542+ );
543+
544+ Map<String, dynamic> toJson() => {
545+ "gt": gt,
546+ "per": per,
547+ "perType": perTypeValues.reverse[perType],
548+ };
549+}
550+
551+class Tm {
552+ final String code;
553+ final String codeInternational;
554+ final int fouls;
555+ final int fullScore;
556+ final Lds lds;
557+ final String logo;
558+ final String name;
559+ final String nameInternational;
560+ final int p1Score;
561+ final int p2Score;
562+ final int p3Score;
563+ final int p4Score;
564+ final Map<String, Pl> pl;
565+ final int score;
566+ final List<Scorer> scoring;
567+ final String shortName;
568+ final String shortNameInternational;
569+ final List<Shot> shot;
570+ final int timeouts;
571+ final int totEff1;
572+ final int totEff2;
573+ final double totEff3;
574+ final int totEff4;
575+ final int totEff5;
576+ final int totEff6;
577+ final int totEff7;
578+ final int totSAssists;
579+ final int totSBenchPoints;
580+ final int totSBiggestLead;
581+ final int totSBiggestScoringRun;
582+ final int totSBlocks;
583+ final int totSBlocksReceived;
584+ final int totSFieldGoalsAttempted;
585+ final int totSFieldGoalsMade;
586+ final int totSFieldGoalsPercentage;
587+ final int totSFoulsOn;
588+ final int totSFoulsPersonal;
589+ final int totSFoulsTeam;
590+ final int totSFreeThrowsAttempted;
591+ final int totSFreeThrowsMade;
592+ final int totSFreeThrowsPercentage;
593+ final int totSLeadChanges;
594+ final int totSMinutes;
595+ final int totSPoints;
596+ final int totSPointsFastBreak;
597+ final int totSPointsFromTurnovers;
598+ final int totSPointsInThePaint;
599+ final int totSPointsSecondChance;
600+ final int totSReboundsDefensive;
601+ final int totSReboundsOffensive;
602+ final int totSReboundsTeam;
603+ final int totSReboundsTeamDefensive;
604+ final int totSReboundsTeamOffensive;
605+ final int totSReboundsTotal;
606+ final int totSSteals;
607+ final int totSThreePointersAttempted;
608+ final int totSThreePointersMade;
609+ final int totSThreePointersPercentage;
610+ final double totSTimeLeading;
611+ final int totSTimesScoresLevel;
612+ final int totSTurnovers;
613+ final int totSTurnoversTeam;
614+ final int totSTwoPointersAttempted;
615+ final int totSTwoPointersMade;
616+ final int totSTwoPointersPercentage;
617+
618+ Tm({
619+ required this.code,
620+ required this.codeInternational,
621+ required this.fouls,
622+ required this.fullScore,
623+ required this.lds,
624+ required this.logo,
625+ required this.name,
626+ required this.nameInternational,
627+ required this.p1Score,
628+ required this.p2Score,
629+ required this.p3Score,
630+ required this.p4Score,
631+ required this.pl,
632+ required this.score,
633+ required this.scoring,
634+ required this.shortName,
635+ required this.shortNameInternational,
636+ required this.shot,
637+ required this.timeouts,
638+ required this.totEff1,
639+ required this.totEff2,
640+ required this.totEff3,
641+ required this.totEff4,
642+ required this.totEff5,
643+ required this.totEff6,
644+ required this.totEff7,
645+ required this.totSAssists,
646+ required this.totSBenchPoints,
647+ required this.totSBiggestLead,
648+ required this.totSBiggestScoringRun,
649+ required this.totSBlocks,
650+ required this.totSBlocksReceived,
651+ required this.totSFieldGoalsAttempted,
652+ required this.totSFieldGoalsMade,
653+ required this.totSFieldGoalsPercentage,
654+ required this.totSFoulsOn,
655+ required this.totSFoulsPersonal,
656+ required this.totSFoulsTeam,
657+ required this.totSFreeThrowsAttempted,
658+ required this.totSFreeThrowsMade,
659+ required this.totSFreeThrowsPercentage,
660+ required this.totSLeadChanges,
661+ required this.totSMinutes,
662+ required this.totSPoints,
663+ required this.totSPointsFastBreak,
664+ required this.totSPointsFromTurnovers,
665+ required this.totSPointsInThePaint,
666+ required this.totSPointsSecondChance,
667+ required this.totSReboundsDefensive,
668+ required this.totSReboundsOffensive,
669+ required this.totSReboundsTeam,
670+ required this.totSReboundsTeamDefensive,
671+ required this.totSReboundsTeamOffensive,
672+ required this.totSReboundsTotal,
673+ required this.totSSteals,
674+ required this.totSThreePointersAttempted,
675+ required this.totSThreePointersMade,
676+ required this.totSThreePointersPercentage,
677+ required this.totSTimeLeading,
678+ required this.totSTimesScoresLevel,
679+ required this.totSTurnovers,
680+ required this.totSTurnoversTeam,
681+ required this.totSTwoPointersAttempted,
682+ required this.totSTwoPointersMade,
683+ required this.totSTwoPointersPercentage,
684+ });
685+
686+ factory Tm.fromJson(Map<String, dynamic> json) => Tm(
687+ code: json["code"],
688+ codeInternational: json["codeInternational"],
689+ fouls: json["fouls"],
690+ fullScore: json["full_score"],
691+ lds: Lds.fromJson(json["lds"]),
692+ logo: json["logo"],
693+ name: json["name"],
694+ nameInternational: json["nameInternational"],
695+ p1Score: json["p1_score"],
696+ p2Score: json["p2_score"],
697+ p3Score: json["p3_score"],
698+ p4Score: json["p4_score"],
699+ pl: Map.from(json["pl"]).map((k, v) => MapEntry<String, Pl>(k, Pl.fromJson(v))),
700+ score: json["score"],
701+ scoring: List<Scorer>.from(json["scoring"].map((x) => Scorer.fromJson(x))),
702+ shortName: json["shortName"],
703+ shortNameInternational: json["shortNameInternational"],
704+ shot: List<Shot>.from(json["shot"].map((x) => Shot.fromJson(x))),
705+ timeouts: json["timeouts"],
706+ totEff1: json["tot_eff_1"],
707+ totEff2: json["tot_eff_2"],
708+ totEff3: json["tot_eff_3"]?.toDouble(),
709+ totEff4: json["tot_eff_4"],
710+ totEff5: json["tot_eff_5"],
711+ totEff6: json["tot_eff_6"],
712+ totEff7: json["tot_eff_7"],
713+ totSAssists: json["tot_sAssists"],
714+ totSBenchPoints: json["tot_sBenchPoints"],
715+ totSBiggestLead: json["tot_sBiggestLead"],
716+ totSBiggestScoringRun: json["tot_sBiggestScoringRun"],
717+ totSBlocks: json["tot_sBlocks"],
718+ totSBlocksReceived: json["tot_sBlocksReceived"],
719+ totSFieldGoalsAttempted: json["tot_sFieldGoalsAttempted"],
720+ totSFieldGoalsMade: json["tot_sFieldGoalsMade"],
721+ totSFieldGoalsPercentage: json["tot_sFieldGoalsPercentage"],
722+ totSFoulsOn: json["tot_sFoulsOn"],
723+ totSFoulsPersonal: json["tot_sFoulsPersonal"],
724+ totSFoulsTeam: json["tot_sFoulsTeam"],
725+ totSFreeThrowsAttempted: json["tot_sFreeThrowsAttempted"],
726+ totSFreeThrowsMade: json["tot_sFreeThrowsMade"],
727+ totSFreeThrowsPercentage: json["tot_sFreeThrowsPercentage"],
728+ totSLeadChanges: json["tot_sLeadChanges"],
729+ totSMinutes: json["tot_sMinutes"],
730+ totSPoints: json["tot_sPoints"],
731+ totSPointsFastBreak: json["tot_sPointsFastBreak"],
732+ totSPointsFromTurnovers: json["tot_sPointsFromTurnovers"],
733+ totSPointsInThePaint: json["tot_sPointsInThePaint"],
734+ totSPointsSecondChance: json["tot_sPointsSecondChance"],
735+ totSReboundsDefensive: json["tot_sReboundsDefensive"],
736+ totSReboundsOffensive: json["tot_sReboundsOffensive"],
737+ totSReboundsTeam: json["tot_sReboundsTeam"],
738+ totSReboundsTeamDefensive: json["tot_sReboundsTeamDefensive"],
739+ totSReboundsTeamOffensive: json["tot_sReboundsTeamOffensive"],
740+ totSReboundsTotal: json["tot_sReboundsTotal"],
741+ totSSteals: json["tot_sSteals"],
742+ totSThreePointersAttempted: json["tot_sThreePointersAttempted"],
743+ totSThreePointersMade: json["tot_sThreePointersMade"],
744+ totSThreePointersPercentage: json["tot_sThreePointersPercentage"],
745+ totSTimeLeading: json["tot_sTimeLeading"]?.toDouble(),
746+ totSTimesScoresLevel: json["tot_sTimesScoresLevel"],
747+ totSTurnovers: json["tot_sTurnovers"],
748+ totSTurnoversTeam: json["tot_sTurnoversTeam"],
749+ totSTwoPointersAttempted: json["tot_sTwoPointersAttempted"],
750+ totSTwoPointersMade: json["tot_sTwoPointersMade"],
751+ totSTwoPointersPercentage: json["tot_sTwoPointersPercentage"],
752+ );
753+
754+ Map<String, dynamic> toJson() => {
755+ "code": code,
756+ "codeInternational": codeInternational,
757+ "fouls": fouls,
758+ "full_score": fullScore,
759+ "lds": lds.toJson(),
760+ "logo": logo,
761+ "name": name,
762+ "nameInternational": nameInternational,
763+ "p1_score": p1Score,
764+ "p2_score": p2Score,
765+ "p3_score": p3Score,
766+ "p4_score": p4Score,
767+ "pl": Map.from(pl).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
768+ "score": score,
769+ "scoring": List<dynamic>.from(scoring.map((x) => x.toJson())),
770+ "shortName": shortName,
771+ "shortNameInternational": shortNameInternational,
772+ "shot": List<dynamic>.from(shot.map((x) => x.toJson())),
773+ "timeouts": timeouts,
774+ "tot_eff_1": totEff1,
775+ "tot_eff_2": totEff2,
776+ "tot_eff_3": totEff3,
777+ "tot_eff_4": totEff4,
778+ "tot_eff_5": totEff5,
779+ "tot_eff_6": totEff6,
780+ "tot_eff_7": totEff7,
781+ "tot_sAssists": totSAssists,
782+ "tot_sBenchPoints": totSBenchPoints,
783+ "tot_sBiggestLead": totSBiggestLead,
784+ "tot_sBiggestScoringRun": totSBiggestScoringRun,
785+ "tot_sBlocks": totSBlocks,
786+ "tot_sBlocksReceived": totSBlocksReceived,
787+ "tot_sFieldGoalsAttempted": totSFieldGoalsAttempted,
788+ "tot_sFieldGoalsMade": totSFieldGoalsMade,
789+ "tot_sFieldGoalsPercentage": totSFieldGoalsPercentage,
790+ "tot_sFoulsOn": totSFoulsOn,
791+ "tot_sFoulsPersonal": totSFoulsPersonal,
792+ "tot_sFoulsTeam": totSFoulsTeam,
793+ "tot_sFreeThrowsAttempted": totSFreeThrowsAttempted,
794+ "tot_sFreeThrowsMade": totSFreeThrowsMade,
795+ "tot_sFreeThrowsPercentage": totSFreeThrowsPercentage,
796+ "tot_sLeadChanges": totSLeadChanges,
797+ "tot_sMinutes": totSMinutes,
798+ "tot_sPoints": totSPoints,
799+ "tot_sPointsFastBreak": totSPointsFastBreak,
800+ "tot_sPointsFromTurnovers": totSPointsFromTurnovers,
801+ "tot_sPointsInThePaint": totSPointsInThePaint,
802+ "tot_sPointsSecondChance": totSPointsSecondChance,
803+ "tot_sReboundsDefensive": totSReboundsDefensive,
804+ "tot_sReboundsOffensive": totSReboundsOffensive,
805+ "tot_sReboundsTeam": totSReboundsTeam,
806+ "tot_sReboundsTeamDefensive": totSReboundsTeamDefensive,
807+ "tot_sReboundsTeamOffensive": totSReboundsTeamOffensive,
808+ "tot_sReboundsTotal": totSReboundsTotal,
809+ "tot_sSteals": totSSteals,
810+ "tot_sThreePointersAttempted": totSThreePointersAttempted,
811+ "tot_sThreePointersMade": totSThreePointersMade,
812+ "tot_sThreePointersPercentage": totSThreePointersPercentage,
813+ "tot_sTimeLeading": totSTimeLeading,
814+ "tot_sTimesScoresLevel": totSTimesScoresLevel,
815+ "tot_sTurnovers": totSTurnovers,
816+ "tot_sTurnoversTeam": totSTurnoversTeam,
817+ "tot_sTwoPointersAttempted": totSTwoPointersAttempted,
818+ "tot_sTwoPointersMade": totSTwoPointersMade,
819+ "tot_sTwoPointersPercentage": totSTwoPointersPercentage,
820+ };
821+}
822+
823+class Lds {
824+ final Map<String, Scorer> sAssists;
825+ final SBlocks sBlocks;
826+ final Map<String, Scorer> sPoints;
827+ final Map<String, Scorer> sReboundsTotal;
828+ final Map<String, Scorer> sSteals;
829+
830+ Lds({
831+ required this.sAssists,
832+ required this.sBlocks,
833+ required this.sPoints,
834+ required this.sReboundsTotal,
835+ required this.sSteals,
836+ });
837+
838+ factory Lds.fromJson(Map<String, dynamic> json) => Lds(
839+ sAssists: Map.from(json["sAssists"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
840+ sBlocks: SBlocks.fromJson(json["sBlocks"]),
841+ sPoints: Map.from(json["sPoints"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
842+ sReboundsTotal: Map.from(json["sReboundsTotal"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
843+ sSteals: Map.from(json["sSteals"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
844+ );
845+
846+ Map<String, dynamic> toJson() => {
847+ "sAssists": Map.from(sAssists).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
848+ "sBlocks": sBlocks.toJson(),
849+ "sPoints": Map.from(sPoints).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
850+ "sReboundsTotal": Map.from(sReboundsTotal).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
851+ "sSteals": Map.from(sSteals).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
852+ };
853+}
854+
855+class SBlocks {
856+ final Scorer the1;
857+
858+ SBlocks({
859+ required this.the1,
860+ });
861+
862+ factory SBlocks.fromJson(Map<String, dynamic> json) => SBlocks(
863+ the1: Scorer.fromJson(json["1"]),
864+ );
865+
866+ Map<String, dynamic> toJson() => {
867+ "1": the1.toJson(),
868+ };
869+}
870+
871+class Pl {
872+ final int active;
873+ final int? captain;
874+ final Comp? comp;
875+ final int eff1;
876+ final int eff2;
877+ final double eff3;
878+ final double eff4;
879+ final int eff5;
880+ final int eff6;
881+ final int eff7;
882+ final String familyName;
883+ final FamilyNameInitial familyNameInitial;
884+ final String firstName;
885+ final FirstNameInitial firstNameInitial;
886+ final String internationalFamilyName;
887+ final FamilyNameInitial internationalFamilyNameInitial;
888+ final String internationalFirstName;
889+ final FirstNameInitial internationalFirstNameInitial;
890+ final String name;
891+ final String playingPosition;
892+ final int sAssists;
893+ final int sBlocks;
894+ final int sBlocksReceived;
895+ final int sFieldGoalsAttempted;
896+ final int sFieldGoalsMade;
897+ final int sFieldGoalsPercentage;
898+ final int sFoulsOn;
899+ final int sFoulsPersonal;
900+ final int sFreeThrowsAttempted;
901+ final int sFreeThrowsMade;
902+ final int sFreeThrowsPercentage;
903+ final dynamic sMinutes;
904+ final int sPlusMinusPoints;
905+ final int sPoints;
906+ final int sPointsFastBreak;
907+ final int sPointsInThePaint;
908+ final int sPointsSecondChance;
909+ final int sReboundsDefensive;
910+ final int sReboundsOffensive;
911+ final int sReboundsTotal;
912+ final int sSteals;
913+ final int sThreePointersAttempted;
914+ final int sThreePointersMade;
915+ final int sThreePointersPercentage;
916+ final int sTurnovers;
917+ final int sTwoPointersAttempted;
918+ final int sTwoPointersMade;
919+ final int sTwoPointersPercentage;
920+ final String shirtNumber;
921+ final int starter;
922+
923+ Pl({
924+ required this.active,
925+ this.captain,
926+ this.comp,
927+ required this.eff1,
928+ required this.eff2,
929+ required this.eff3,
930+ required this.eff4,
931+ required this.eff5,
932+ required this.eff6,
933+ required this.eff7,
934+ required this.familyName,
935+ required this.familyNameInitial,
936+ required this.firstName,
937+ required this.firstNameInitial,
938+ required this.internationalFamilyName,
939+ required this.internationalFamilyNameInitial,
940+ required this.internationalFirstName,
941+ required this.internationalFirstNameInitial,
942+ required this.name,
943+ required this.playingPosition,
944+ required this.sAssists,
945+ required this.sBlocks,
946+ required this.sBlocksReceived,
947+ required this.sFieldGoalsAttempted,
948+ required this.sFieldGoalsMade,
949+ required this.sFieldGoalsPercentage,
950+ required this.sFoulsOn,
951+ required this.sFoulsPersonal,
952+ required this.sFreeThrowsAttempted,
953+ required this.sFreeThrowsMade,
954+ required this.sFreeThrowsPercentage,
955+ required this.sMinutes,
956+ required this.sPlusMinusPoints,
957+ required this.sPoints,
958+ required this.sPointsFastBreak,
959+ required this.sPointsInThePaint,
960+ required this.sPointsSecondChance,
961+ required this.sReboundsDefensive,
962+ required this.sReboundsOffensive,
963+ required this.sReboundsTotal,
964+ required this.sSteals,
965+ required this.sThreePointersAttempted,
966+ required this.sThreePointersMade,
967+ required this.sThreePointersPercentage,
968+ required this.sTurnovers,
969+ required this.sTwoPointersAttempted,
970+ required this.sTwoPointersMade,
971+ required this.sTwoPointersPercentage,
972+ required this.shirtNumber,
973+ required this.starter,
974+ });
975+
976+ factory Pl.fromJson(Map<String, dynamic> json) => Pl(
977+ active: json["active"],
978+ captain: json["captain"],
979+ comp: json["comp"] == null ? null : Comp.fromJson(json["comp"]),
980+ eff1: json["eff_1"],
981+ eff2: json["eff_2"],
982+ eff3: json["eff_3"]?.toDouble(),
983+ eff4: json["eff_4"]?.toDouble(),
984+ eff5: json["eff_5"],
985+ eff6: json["eff_6"],
986+ eff7: json["eff_7"],
987+ familyName: json["familyName"],
988+ familyNameInitial: familyNameInitialValues.map[json["familyNameInitial"]]!,
989+ firstName: json["firstName"],
990+ firstNameInitial: firstNameInitialValues.map[json["firstNameInitial"]]!,
991+ internationalFamilyName: json["internationalFamilyName"],
992+ internationalFamilyNameInitial: familyNameInitialValues.map[json["internationalFamilyNameInitial"]]!,
993+ internationalFirstName: json["internationalFirstName"],
994+ internationalFirstNameInitial: firstNameInitialValues.map[json["internationalFirstNameInitial"]]!,
995+ name: json["name"],
996+ playingPosition: json["playingPosition"],
997+ sAssists: json["sAssists"],
998+ sBlocks: json["sBlocks"],
999+ sBlocksReceived: json["sBlocksReceived"],
1000+ sFieldGoalsAttempted: json["sFieldGoalsAttempted"],
1001+ sFieldGoalsMade: json["sFieldGoalsMade"],
1002+ sFieldGoalsPercentage: json["sFieldGoalsPercentage"],
1003+ sFoulsOn: json["sFoulsOn"],
1004+ sFoulsPersonal: json["sFoulsPersonal"],
1005+ sFreeThrowsAttempted: json["sFreeThrowsAttempted"],
1006+ sFreeThrowsMade: json["sFreeThrowsMade"],
1007+ sFreeThrowsPercentage: json["sFreeThrowsPercentage"],
1008+ sMinutes: json["sMinutes"],
1009+ sPlusMinusPoints: json["sPlusMinusPoints"],
1010+ sPoints: json["sPoints"],
1011+ sPointsFastBreak: json["sPointsFastBreak"],
1012+ sPointsInThePaint: json["sPointsInThePaint"],
1013+ sPointsSecondChance: json["sPointsSecondChance"],
1014+ sReboundsDefensive: json["sReboundsDefensive"],
1015+ sReboundsOffensive: json["sReboundsOffensive"],
1016+ sReboundsTotal: json["sReboundsTotal"],
1017+ sSteals: json["sSteals"],
1018+ sThreePointersAttempted: json["sThreePointersAttempted"],
1019+ sThreePointersMade: json["sThreePointersMade"],
1020+ sThreePointersPercentage: json["sThreePointersPercentage"],
1021+ sTurnovers: json["sTurnovers"],
1022+ sTwoPointersAttempted: json["sTwoPointersAttempted"],
1023+ sTwoPointersMade: json["sTwoPointersMade"],
1024+ sTwoPointersPercentage: json["sTwoPointersPercentage"],
1025+ shirtNumber: json["shirtNumber"],
1026+ starter: json["starter"],
1027+ );
1028+
1029+ Map<String, dynamic> toJson() => {
1030+ "active": active,
1031+ "captain": captain,
1032+ "comp": comp?.toJson(),
1033+ "eff_1": eff1,
1034+ "eff_2": eff2,
1035+ "eff_3": eff3,
1036+ "eff_4": eff4,
1037+ "eff_5": eff5,
1038+ "eff_6": eff6,
1039+ "eff_7": eff7,
1040+ "familyName": familyName,
1041+ "familyNameInitial": familyNameInitialValues.reverse[familyNameInitial],
1042+ "firstName": firstName,
1043+ "firstNameInitial": firstNameInitialValues.reverse[firstNameInitial],
1044+ "internationalFamilyName": internationalFamilyName,
1045+ "internationalFamilyNameInitial": familyNameInitialValues.reverse[internationalFamilyNameInitial],
1046+ "internationalFirstName": internationalFirstName,
1047+ "internationalFirstNameInitial": firstNameInitialValues.reverse[internationalFirstNameInitial],
1048+ "name": name,
1049+ "playingPosition": playingPosition,
1050+ "sAssists": sAssists,
1051+ "sBlocks": sBlocks,
1052+ "sBlocksReceived": sBlocksReceived,
1053+ "sFieldGoalsAttempted": sFieldGoalsAttempted,
1054+ "sFieldGoalsMade": sFieldGoalsMade,
1055+ "sFieldGoalsPercentage": sFieldGoalsPercentage,
1056+ "sFoulsOn": sFoulsOn,
1057+ "sFoulsPersonal": sFoulsPersonal,
1058+ "sFreeThrowsAttempted": sFreeThrowsAttempted,
1059+ "sFreeThrowsMade": sFreeThrowsMade,
1060+ "sFreeThrowsPercentage": sFreeThrowsPercentage,
1061+ "sMinutes": sMinutes,
1062+ "sPlusMinusPoints": sPlusMinusPoints,
1063+ "sPoints": sPoints,
1064+ "sPointsFastBreak": sPointsFastBreak,
1065+ "sPointsInThePaint": sPointsInThePaint,
1066+ "sPointsSecondChance": sPointsSecondChance,
1067+ "sReboundsDefensive": sReboundsDefensive,
1068+ "sReboundsOffensive": sReboundsOffensive,
1069+ "sReboundsTotal": sReboundsTotal,
1070+ "sSteals": sSteals,
1071+ "sThreePointersAttempted": sThreePointersAttempted,
1072+ "sThreePointersMade": sThreePointersMade,
1073+ "sThreePointersPercentage": sThreePointersPercentage,
1074+ "sTurnovers": sTurnovers,
1075+ "sTwoPointersAttempted": sTwoPointersAttempted,
1076+ "sTwoPointersMade": sTwoPointersMade,
1077+ "sTwoPointersPercentage": sTwoPointersPercentage,
1078+ "shirtNumber": shirtNumber,
1079+ "starter": starter,
1080+ };
1081+}
1082+
1083+class Comp {
1084+ final double sAssistsAverage;
1085+ final String sMinutesAverage;
1086+ final double sPointsAverage;
1087+ final double sReboundsTotalAverage;
1088+
1089+ Comp({
1090+ required this.sAssistsAverage,
1091+ required this.sMinutesAverage,
1092+ required this.sPointsAverage,
1093+ required this.sReboundsTotalAverage,
1094+ });
1095+
1096+ factory Comp.fromJson(Map<String, dynamic> json) => Comp(
1097+ sAssistsAverage: json["sAssistsAverage"]?.toDouble(),
1098+ sMinutesAverage: json["sMinutesAverage"],
1099+ sPointsAverage: json["sPointsAverage"]?.toDouble(),
1100+ sReboundsTotalAverage: json["sReboundsTotalAverage"]?.toDouble(),
1101+ );
1102+
1103+ Map<String, dynamic> toJson() => {
1104+ "sAssistsAverage": sAssistsAverage,
1105+ "sMinutesAverage": sMinutesAverage,
1106+ "sPointsAverage": sPointsAverage,
1107+ "sReboundsTotalAverage": sReboundsTotalAverage,
1108+ };
1109+}
1110+
1111+class Shot {
1112+ final ActionType actionType;
1113+ final int p;
1114+ final int per;
1115+ final PerType perType;
1116+ final String player;
1117+ final int pno;
1118+ final int r;
1119+ final String shirtNumber;
1120+ final SubType subType;
1121+ final int tno;
1122+ final int x;
1123+ final int y;
1124+
1125+ Shot({
1126+ required this.actionType,
1127+ required this.p,
1128+ required this.per,
1129+ required this.perType,
1130+ required this.player,
1131+ required this.pno,
1132+ required this.r,
1133+ required this.shirtNumber,
1134+ required this.subType,
1135+ required this.tno,
1136+ required this.x,
1137+ required this.y,
1138+ });
1139+
1140+ factory Shot.fromJson(Map<String, dynamic> json) => Shot(
1141+ actionType: actionTypeValues.map[json["actionType"]]!,
1142+ p: json["p"],
1143+ per: json["per"],
1144+ perType: perTypeValues.map[json["perType"]]!,
1145+ player: json["player"],
1146+ pno: json["pno"],
1147+ r: json["r"],
1148+ shirtNumber: json["shirtNumber"],
1149+ subType: subTypeValues.map[json["subType"]]!,
1150+ tno: json["tno"],
1151+ x: json["x"],
1152+ y: json["y"],
1153+ );
1154+
1155+ Map<String, dynamic> toJson() => {
1156+ "actionType": actionTypeValues.reverse[actionType],
1157+ "p": p,
1158+ "per": per,
1159+ "perType": perTypeValues.reverse[perType],
1160+ "player": player,
1161+ "pno": pno,
1162+ "r": r,
1163+ "shirtNumber": shirtNumber,
1164+ "subType": subTypeValues.reverse[subType],
1165+ "tno": tno,
1166+ "x": x,
1167+ "y": y,
1168+ };
1169+}
1170+
1171+enum SubType {
1172+ JUMPSHOT,
1173+ LAYUP,
1174+ DUNK
1175+}
1176+
1177+final subTypeValues = EnumValues({
1178+ "jumpshot": SubType.JUMPSHOT,
1179+ "layup": SubType.LAYUP,
1180+ "dunk": SubType.DUNK
1181+});
1182+
1183+class Totallds {
1184+ final Map<String, Scorer> sAssists;
1185+ final Map<String, Scorer> sBlocks;
1186+ final Map<String, Scorer> sPoints;
1187+ final Map<String, Scorer> sReboundsTotal;
1188+ final Map<String, Scorer> sSteals;
1189+
1190+ Totallds({
1191+ required this.sAssists,
1192+ required this.sBlocks,
1193+ required this.sPoints,
1194+ required this.sReboundsTotal,
1195+ required this.sSteals,
1196+ });
1197+
1198+ factory Totallds.fromJson(Map<String, dynamic> json) => Totallds(
1199+ sAssists: Map.from(json["sAssists"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
1200+ sBlocks: Map.from(json["sBlocks"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
1201+ sPoints: Map.from(json["sPoints"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
1202+ sReboundsTotal: Map.from(json["sReboundsTotal"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
1203+ sSteals: Map.from(json["sSteals"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
1204+ );
1205+
1206+ Map<String, dynamic> toJson() => {
1207+ "sAssists": Map.from(sAssists).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
1208+ "sBlocks": Map.from(sBlocks).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
1209+ "sPoints": Map.from(sPoints).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
1210+ "sReboundsTotal": Map.from(sReboundsTotal).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
1211+ "sSteals": Map.from(sSteals).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
1212+ };
1213+}
1214+
1215+class EnumValues<T> {
1216+ Map<String, T> map;
1217+ late Map<T, String> reverseMap;
1218+
1219+ EnumValues(this.map);
1220+
1221+ Map<T, String> get reverse {
1222+ reverseMap = map.map((k, v) => MapEntry(v, k));
1223+ return reverseMap;
1224+ }
1225+}
Test case

test/inputs/json/priority/recursive.json

1 generated file · +501 −0
Adartdefault / TopLevel.dart+501 −0
@@ -0,0 +1,501 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final Category category;
13+ final Details details;
14+ final String match;
15+ final int page;
16+ final List<ProductElement> product;
17+ final bool schk;
18+ final int totallooseoffers;
19+ final int totalpages;
20+ final int totalresultsavailable;
21+ final int totalresultsreturned;
22+
23+ TopLevel({
24+ required this.category,
25+ required this.details,
26+ required this.match,
27+ required this.page,
28+ required this.product,
29+ required this.schk,
30+ required this.totallooseoffers,
31+ required this.totalpages,
32+ required this.totalresultsavailable,
33+ required this.totalresultsreturned,
34+ });
35+
36+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
37+ category: Category.fromJson(json["category"]),
38+ details: Details.fromJson(json["details"]),
39+ match: json["match"],
40+ page: json["page"],
41+ product: List<ProductElement>.from(json["product"].map((x) => ProductElement.fromJson(x))),
42+ schk: json["schk"],
43+ totallooseoffers: json["totallooseoffers"],
44+ totalpages: json["totalpages"],
45+ totalresultsavailable: json["totalresultsavailable"],
46+ totalresultsreturned: json["totalresultsreturned"],
47+ );
48+
49+ Map<String, dynamic> toJson() => {
50+ "category": category.toJson(),
51+ "details": details.toJson(),
52+ "match": match,
53+ "page": page,
54+ "product": List<dynamic>.from(product.map((x) => x.toJson())),
55+ "schk": schk,
56+ "totallooseoffers": totallooseoffers,
57+ "totalpages": totalpages,
58+ "totalresultsavailable": totalresultsavailable,
59+ "totalresultsreturned": totalresultsreturned,
60+ };
61+}
62+
63+class Category {
64+ final bool concatenatecategoryname;
65+ final bool hasoffer;
66+ final int id;
67+ final bool isfinal;
68+ final List<LinkElement> links;
69+ final String name;
70+ final int parentcategoryid;
71+ final CategoryThumbnail thumbnail;
72+
73+ Category({
74+ required this.concatenatecategoryname,
75+ required this.hasoffer,
76+ required this.id,
77+ required this.isfinal,
78+ required this.links,
79+ required this.name,
80+ required this.parentcategoryid,
81+ required this.thumbnail,
82+ });
83+
84+ factory Category.fromJson(Map<String, dynamic> json) => Category(
85+ concatenatecategoryname: json["concatenatecategoryname"],
86+ hasoffer: json["hasoffer"],
87+ id: json["id"],
88+ isfinal: json["isfinal"],
89+ links: List<LinkElement>.from(json["links"].map((x) => LinkElement.fromJson(x))),
90+ name: json["name"],
91+ parentcategoryid: json["parentcategoryid"],
92+ thumbnail: CategoryThumbnail.fromJson(json["thumbnail"]),
93+ );
94+
95+ Map<String, dynamic> toJson() => {
96+ "concatenatecategoryname": concatenatecategoryname,
97+ "hasoffer": hasoffer,
98+ "id": id,
99+ "isfinal": isfinal,
100+ "links": List<dynamic>.from(links.map((x) => x.toJson())),
101+ "name": name,
102+ "parentcategoryid": parentcategoryid,
103+ "thumbnail": thumbnail.toJson(),
104+ };
105+}
106+
107+class LinkElement {
108+ final LinkLink link;
109+
110+ LinkElement({
111+ required this.link,
112+ });
113+
114+ factory LinkElement.fromJson(Map<String, dynamic> json) => LinkElement(
115+ link: LinkLink.fromJson(json["link"]),
116+ );
117+
118+ Map<String, dynamic> toJson() => {
119+ "link": link.toJson(),
120+ };
121+}
122+
123+class LinkLink {
124+ final String type;
125+ final String url;
126+
127+ LinkLink({
128+ required this.type,
129+ required this.url,
130+ });
131+
132+ factory LinkLink.fromJson(Map<String, dynamic> json) => LinkLink(
133+ type: json["type"],
134+ url: json["url"],
135+ );
136+
137+ Map<String, dynamic> toJson() => {
138+ "type": type,
139+ "url": url,
140+ };
141+}
142+
143+class CategoryThumbnail {
144+ final String url;
145+
146+ CategoryThumbnail({
147+ required this.url,
148+ });
149+
150+ factory CategoryThumbnail.fromJson(Map<String, dynamic> json) => CategoryThumbnail(
151+ url: json["url"],
152+ );
153+
154+ Map<String, dynamic> toJson() => {
155+ "url": url,
156+ };
157+}
158+
159+class Details {
160+ final String applicationid;
161+ final String applicationversion;
162+ final int code;
163+ final Date date;
164+ final int elapsedtime;
165+ final String message;
166+ final String status;
167+
168+ Details({
169+ required this.applicationid,
170+ required this.applicationversion,
171+ required this.code,
172+ required this.date,
173+ required this.elapsedtime,
174+ required this.message,
175+ required this.status,
176+ });
177+
178+ factory Details.fromJson(Map<String, dynamic> json) => Details(
179+ applicationid: json["applicationid"],
180+ applicationversion: json["applicationversion"],
181+ code: json["code"],
182+ date: Date.fromJson(json["date"]),
183+ elapsedtime: json["elapsedtime"],
184+ message: json["message"],
185+ status: json["status"],
186+ );
187+
188+ Map<String, dynamic> toJson() => {
189+ "applicationid": applicationid,
190+ "applicationversion": applicationversion,
191+ "code": code,
192+ "date": date.toJson(),
193+ "elapsedtime": elapsedtime,
194+ "message": message,
195+ "status": status,
196+ };
197+}
198+
199+class Date {
200+ final int day;
201+ final Eonandyear eonandyear;
202+ final int hour;
203+ final int millisecond;
204+ final int minute;
205+ final int month;
206+ final int second;
207+ final int timezone;
208+ final bool valid;
209+ final Xmlschematype xmlschematype;
210+ final int year;
211+
212+ Date({
213+ required this.day,
214+ required this.eonandyear,
215+ required this.hour,
216+ required this.millisecond,
217+ required this.minute,
218+ required this.month,
219+ required this.second,
220+ required this.timezone,
221+ required this.valid,
222+ required this.xmlschematype,
223+ required this.year,
224+ });
225+
226+ factory Date.fromJson(Map<String, dynamic> json) => Date(
227+ day: json["day"],
228+ eonandyear: Eonandyear.fromJson(json["eonandyear"]),
229+ hour: json["hour"],
230+ millisecond: json["millisecond"],
231+ minute: json["minute"],
232+ month: json["month"],
233+ second: json["second"],
234+ timezone: json["timezone"],
235+ valid: json["valid"],
236+ xmlschematype: Xmlschematype.fromJson(json["xmlschematype"]),
237+ year: json["year"],
238+ );
239+
240+ Map<String, dynamic> toJson() => {
241+ "day": day,
242+ "eonandyear": eonandyear.toJson(),
243+ "hour": hour,
244+ "millisecond": millisecond,
245+ "minute": minute,
246+ "month": month,
247+ "second": second,
248+ "timezone": timezone,
249+ "valid": valid,
250+ "xmlschematype": xmlschematype.toJson(),
251+ "year": year,
252+ };
253+}
254+
255+class Eonandyear {
256+ final int lowestsetbit;
257+
258+ Eonandyear({
259+ required this.lowestsetbit,
260+ });
261+
262+ factory Eonandyear.fromJson(Map<String, dynamic> json) => Eonandyear(
263+ lowestsetbit: json["lowestsetbit"],
264+ );
265+
266+ Map<String, dynamic> toJson() => {
267+ "lowestsetbit": lowestsetbit,
268+ };
269+}
270+
271+class Xmlschematype {
272+ final String localpart;
273+ final String namespaceuri;
274+ final String prefix;
275+
276+ Xmlschematype({
277+ required this.localpart,
278+ required this.namespaceuri,
279+ required this.prefix,
280+ });
281+
282+ factory Xmlschematype.fromJson(Map<String, dynamic> json) => Xmlschematype(
283+ localpart: json["localpart"],
284+ namespaceuri: json["namespaceuri"],
285+ prefix: json["prefix"],
286+ );
287+
288+ Map<String, dynamic> toJson() => {
289+ "localpart": localpart,
290+ "namespaceuri": namespaceuri,
291+ "prefix": prefix,
292+ };
293+}
294+
295+class ProductElement {
296+ final ProductProduct product;
297+
298+ ProductElement({
299+ required this.product,
300+ });
301+
302+ factory ProductElement.fromJson(Map<String, dynamic> json) => ProductElement(
303+ product: ProductProduct.fromJson(json["product"]),
304+ );
305+
306+ Map<String, dynamic> toJson() => {
307+ "product": product.toJson(),
308+ };
309+}
310+
311+class ProductProduct {
312+ final int categoryid;
313+ final Currency currency;
314+ final bool eco;
315+ final bool fulldescription;
316+ final bool hasmetasearch;
317+ final int id;
318+ final List<LinkElement> links;
319+ final int numoffers;
320+ final String pricemax;
321+ final String pricemin;
322+ final String productname;
323+ final int quantity;
324+ final Rating rating;
325+ final Specification specification;
326+ final FormatsClass thumbnail;
327+ final int totalsellers;
328+
329+ ProductProduct({
330+ required this.categoryid,
331+ required this.currency,
332+ required this.eco,
333+ required this.fulldescription,
334+ required this.hasmetasearch,
335+ required this.id,
336+ required this.links,
337+ required this.numoffers,
338+ required this.pricemax,
339+ required this.pricemin,
340+ required this.productname,
341+ required this.quantity,
342+ required this.rating,
343+ required this.specification,
344+ required this.thumbnail,
345+ required this.totalsellers,
346+ });
347+
348+ factory ProductProduct.fromJson(Map<String, dynamic> json) => ProductProduct(
349+ categoryid: json["categoryid"],
350+ currency: Currency.fromJson(json["currency"]),
351+ eco: json["eco"],
352+ fulldescription: json["fulldescription"],
353+ hasmetasearch: json["hasmetasearch"],
354+ id: json["id"],
355+ links: List<LinkElement>.from(json["links"].map((x) => LinkElement.fromJson(x))),
356+ numoffers: json["numoffers"],
357+ pricemax: json["pricemax"],
358+ pricemin: json["pricemin"],
359+ productname: json["productname"],
360+ quantity: json["quantity"],
361+ rating: Rating.fromJson(json["rating"]),
362+ specification: Specification.fromJson(json["specification"]),
363+ thumbnail: FormatsClass.fromJson(json["thumbnail"]),
364+ totalsellers: json["totalsellers"],
365+ );
366+
367+ Map<String, dynamic> toJson() => {
368+ "categoryid": categoryid,
369+ "currency": currency.toJson(),
370+ "eco": eco,
371+ "fulldescription": fulldescription,
372+ "hasmetasearch": hasmetasearch,
373+ "id": id,
374+ "links": List<dynamic>.from(links.map((x) => x.toJson())),
375+ "numoffers": numoffers,
376+ "pricemax": pricemax,
377+ "pricemin": pricemin,
378+ "productname": productname,
379+ "quantity": quantity,
380+ "rating": rating.toJson(),
381+ "specification": specification.toJson(),
382+ "thumbnail": thumbnail.toJson(),
383+ "totalsellers": totalsellers,
384+ };
385+}
386+
387+class Currency {
388+ final String abbreviation;
389+
390+ Currency({
391+ required this.abbreviation,
392+ });
393+
394+ factory Currency.fromJson(Map<String, dynamic> json) => Currency(
395+ abbreviation: json["abbreviation"],
396+ );
397+
398+ Map<String, dynamic> toJson() => {
399+ "abbreviation": abbreviation,
400+ };
401+}
402+
403+class Rating {
404+ final Useraveragerating useraveragerating;
405+
406+ Rating({
407+ required this.useraveragerating,
408+ });
409+
410+ factory Rating.fromJson(Map<String, dynamic> json) => Rating(
411+ useraveragerating: Useraveragerating.fromJson(json["useraveragerating"]),
412+ );
413+
414+ Map<String, dynamic> toJson() => {
415+ "useraveragerating": useraveragerating.toJson(),
416+ };
417+}
418+
419+class Useraveragerating {
420+ final List<LinkElement> links;
421+ final int numcomments;
422+ final String rating;
423+
424+ Useraveragerating({
425+ required this.links,
426+ required this.numcomments,
427+ required this.rating,
428+ });
429+
430+ factory Useraveragerating.fromJson(Map<String, dynamic> json) => Useraveragerating(
431+ links: List<LinkElement>.from(json["links"].map((x) => LinkElement.fromJson(x))),
432+ numcomments: json["numcomments"],
433+ rating: json["rating"],
434+ );
435+
436+ Map<String, dynamic> toJson() => {
437+ "links": List<dynamic>.from(links.map((x) => x.toJson())),
438+ "numcomments": numcomments,
439+ "rating": rating,
440+ };
441+}
442+
443+class Specification {
444+ final List<LinkElement> links;
445+
446+ Specification({
447+ required this.links,
448+ });
449+
450+ factory Specification.fromJson(Map<String, dynamic> json) => Specification(
451+ links: List<LinkElement>.from(json["links"].map((x) => LinkElement.fromJson(x))),
452+ );
453+
454+ Map<String, dynamic> toJson() => {
455+ "links": List<dynamic>.from(links.map((x) => x.toJson())),
456+ };
457+}
458+
459+class Format {
460+ final FormatsClass formats;
461+
462+ Format({
463+ required this.formats,
464+ });
465+
466+ factory Format.fromJson(Map<String, dynamic> json) => Format(
467+ formats: FormatsClass.fromJson(json["formats"]),
468+ );
469+
470+ Map<String, dynamic> toJson() => {
471+ "formats": formats.toJson(),
472+ };
473+}
474+
475+class FormatsClass {
476+ final List<Format>? formats;
477+ final int height;
478+ final String url;
479+ final int width;
480+
481+ FormatsClass({
482+ this.formats,
483+ required this.height,
484+ required this.url,
485+ required this.width,
486+ });
487+
488+ factory FormatsClass.fromJson(Map<String, dynamic> json) => FormatsClass(
489+ formats: json["formats"] == null ? null : List<Format>.from(json["formats"]!.map((x) => Format.fromJson(x))),
490+ height: json["height"],
491+ url: json["url"],
492+ width: json["width"],
493+ );
494+
495+ Map<String, dynamic> toJson() => {
496+ "formats": formats == null ? null : List<dynamic>.from(formats!.map((x) => x.toJson())),
497+ "height": height,
498+ "url": url,
499+ "width": width,
500+ };
501+}
Test case

test/inputs/json/samples/github-events.json

1 generated file · +1,175 −0
Adartdefault / TopLevel.dart+1,175 −0
@@ -0,0 +1,1175 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+List<TopLevel> topLevelFromJson(String str) => List<TopLevel>.from(json.decode(str).map((x) => TopLevel.fromJson(x)));
8+
9+String topLevelToJson(List<TopLevel> data) => json.encode(List<dynamic>.from(data.map((x) => x.toJson())));
10+
11+class TopLevel {
12+ final Actor actor;
13+ final DateTime createdAt;
14+ final String id;
15+ final Actor? org;
16+ final Payload payload;
17+ final bool public;
18+ final TopLevelRepo repo;
19+ final String type;
20+
21+ TopLevel({
22+ required this.actor,
23+ required this.createdAt,
24+ required this.id,
25+ this.org,
26+ required this.payload,
27+ required this.public,
28+ required this.repo,
29+ required this.type,
30+ });
31+
32+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
33+ actor: Actor.fromJson(json["actor"]),
34+ createdAt: DateTime.parse(json["created_at"]),
35+ id: json["id"],
36+ org: json["org"] == null ? null : Actor.fromJson(json["org"]),
37+ payload: Payload.fromJson(json["payload"]),
38+ public: json["public"],
39+ repo: TopLevelRepo.fromJson(json["repo"]),
40+ type: json["type"],
41+ );
42+
43+ Map<String, dynamic> toJson() => {
44+ "actor": actor.toJson(),
45+ "created_at": createdAt.toIso8601String(),
46+ "id": id,
47+ "org": org?.toJson(),
48+ "payload": payload.toJson(),
49+ "public": public,
50+ "repo": repo.toJson(),
51+ "type": type,
52+ };
53+}
54+
55+class Actor {
56+ final String avatarUrl;
57+ final String? displayLogin;
58+ final String gravatarId;
59+ final int id;
60+ final String login;
61+ final String url;
62+
63+ Actor({
64+ required this.avatarUrl,
65+ this.displayLogin,
66+ required this.gravatarId,
67+ required this.id,
68+ required this.login,
69+ required this.url,
70+ });
71+
72+ factory Actor.fromJson(Map<String, dynamic> json) => Actor(
73+ avatarUrl: json["avatar_url"],
74+ displayLogin: json["display_login"],
75+ gravatarId: json["gravatar_id"],
76+ id: json["id"],
77+ login: json["login"],
78+ url: json["url"],
79+ );
80+
81+ Map<String, dynamic> toJson() => {
82+ "avatar_url": avatarUrl,
83+ "display_login": displayLogin,
84+ "gravatar_id": gravatarId,
85+ "id": id,
86+ "login": login,
87+ "url": url,
88+ };
89+}
90+
91+class Payload {
92+ final String? action;
93+ final String? before;
94+ final Comment? comment;
95+ final List<Commit>? commits;
96+ final String? description;
97+ final int? distinctSize;
98+ final String? head;
99+ final Issue? issue;
100+ final String? masterBranch;
101+ final int? number;
102+ final PayloadPullRequest? pullRequest;
103+ final int? pushId;
104+ final String? pusherType;
105+ final String? ref;
106+ final String? refType;
107+ final int? size;
108+
109+ Payload({
110+ this.action,
111+ this.before,
112+ this.comment,
113+ this.commits,
114+ this.description,
115+ this.distinctSize,
116+ this.head,
117+ this.issue,
118+ this.masterBranch,
119+ this.number,
120+ this.pullRequest,
121+ this.pushId,
122+ this.pusherType,
123+ this.ref,
124+ this.refType,
125+ this.size,
126+ });
127+
128+ factory Payload.fromJson(Map<String, dynamic> json) => Payload(
129+ action: json["action"],
130+ before: json["before"],
131+ comment: json["comment"] == null ? null : Comment.fromJson(json["comment"]),
132+ commits: json["commits"] == null ? null : List<Commit>.from(json["commits"]!.map((x) => Commit.fromJson(x))),
133+ description: json["description"],
134+ distinctSize: json["distinct_size"],
135+ head: json["head"],
136+ issue: json["issue"] == null ? null : Issue.fromJson(json["issue"]),
137+ masterBranch: json["master_branch"],
138+ number: json["number"],
139+ pullRequest: json["pull_request"] == null ? null : PayloadPullRequest.fromJson(json["pull_request"]),
140+ pushId: json["push_id"],
141+ pusherType: json["pusher_type"],
142+ ref: json["ref"],
143+ refType: json["ref_type"],
144+ size: json["size"],
145+ );
146+
147+ Map<String, dynamic> toJson() => {
148+ "action": action,
149+ "before": before,
150+ "comment": comment?.toJson(),
151+ "commits": commits == null ? null : List<dynamic>.from(commits!.map((x) => x.toJson())),
152+ "description": description,
153+ "distinct_size": distinctSize,
154+ "head": head,
155+ "issue": issue?.toJson(),
156+ "master_branch": masterBranch,
157+ "number": number,
158+ "pull_request": pullRequest?.toJson(),
159+ "push_id": pushId,
160+ "pusher_type": pusherType,
161+ "ref": ref,
162+ "ref_type": refType,
163+ "size": size,
164+ };
165+}
166+
167+class Comment {
168+ final String body;
169+ final DateTime createdAt;
170+ final String htmlUrl;
171+ final int id;
172+ final String issueUrl;
173+ final DateTime updatedAt;
174+ final String url;
175+ final User user;
176+
177+ Comment({
178+ required this.body,
179+ required this.createdAt,
180+ required this.htmlUrl,
181+ required this.id,
182+ required this.issueUrl,
183+ required this.updatedAt,
184+ required this.url,
185+ required this.user,
186+ });
187+
188+ factory Comment.fromJson(Map<String, dynamic> json) => Comment(
189+ body: json["body"],
190+ createdAt: DateTime.parse(json["created_at"]),
191+ htmlUrl: json["html_url"],
192+ id: json["id"],
193+ issueUrl: json["issue_url"],
194+ updatedAt: DateTime.parse(json["updated_at"]),
195+ url: json["url"],
196+ user: User.fromJson(json["user"]),
197+ );
198+
199+ Map<String, dynamic> toJson() => {
200+ "body": body,
201+ "created_at": createdAt.toIso8601String(),
202+ "html_url": htmlUrl,
203+ "id": id,
204+ "issue_url": issueUrl,
205+ "updated_at": updatedAt.toIso8601String(),
206+ "url": url,
207+ "user": user.toJson(),
208+ };
209+}
210+
211+class User {
212+ final String avatarUrl;
213+ final String eventsUrl;
214+ final String followersUrl;
215+ final String followingUrl;
216+ final String gistsUrl;
217+ final String gravatarId;
218+ final String htmlUrl;
219+ final int id;
220+ final String login;
221+ final String organizationsUrl;
222+ final String receivedEventsUrl;
223+ final String reposUrl;
224+ final bool siteAdmin;
225+ final String starredUrl;
226+ final String subscriptionsUrl;
227+ final Type type;
228+ final String url;
229+
230+ User({
231+ required this.avatarUrl,
232+ required this.eventsUrl,
233+ required this.followersUrl,
234+ required this.followingUrl,
235+ required this.gistsUrl,
236+ required this.gravatarId,
237+ required this.htmlUrl,
238+ required this.id,
239+ required this.login,
240+ required this.organizationsUrl,
241+ required this.receivedEventsUrl,
242+ required this.reposUrl,
243+ required this.siteAdmin,
244+ required this.starredUrl,
245+ required this.subscriptionsUrl,
246+ required this.type,
247+ required this.url,
248+ });
249+
250+ factory User.fromJson(Map<String, dynamic> json) => User(
251+ avatarUrl: json["avatar_url"],
252+ eventsUrl: json["events_url"],
253+ followersUrl: json["followers_url"],
254+ followingUrl: json["following_url"],
255+ gistsUrl: json["gists_url"],
256+ gravatarId: json["gravatar_id"],
257+ htmlUrl: json["html_url"],
258+ id: json["id"],
259+ login: json["login"],
260+ organizationsUrl: json["organizations_url"],
261+ receivedEventsUrl: json["received_events_url"],
262+ reposUrl: json["repos_url"],
263+ siteAdmin: json["site_admin"],
264+ starredUrl: json["starred_url"],
265+ subscriptionsUrl: json["subscriptions_url"],
266+ type: typeValues.map[json["type"]]!,
267+ url: json["url"],
268+ );
269+
270+ Map<String, dynamic> toJson() => {
271+ "avatar_url": avatarUrl,
272+ "events_url": eventsUrl,
273+ "followers_url": followersUrl,
274+ "following_url": followingUrl,
275+ "gists_url": gistsUrl,
276+ "gravatar_id": gravatarId,
277+ "html_url": htmlUrl,
278+ "id": id,
279+ "login": login,
280+ "organizations_url": organizationsUrl,
281+ "received_events_url": receivedEventsUrl,
282+ "repos_url": reposUrl,
283+ "site_admin": siteAdmin,
284+ "starred_url": starredUrl,
285+ "subscriptions_url": subscriptionsUrl,
286+ "type": typeValues.reverse[type],
287+ "url": url,
288+ };
289+}
290+
291+enum Type {
292+ USER,
293+ ORGANIZATION
294+}
295+
296+final typeValues = EnumValues({
297+ "User": Type.USER,
298+ "Organization": Type.ORGANIZATION
299+});
300+
301+class Commit {
302+ final Author author;
303+ final bool distinct;
304+ final String message;
305+ final String sha;
306+ final String url;
307+
308+ Commit({
309+ required this.author,
310+ required this.distinct,
311+ required this.message,
312+ required this.sha,
313+ required this.url,
314+ });
315+
316+ factory Commit.fromJson(Map<String, dynamic> json) => Commit(
317+ author: Author.fromJson(json["author"]),
318+ distinct: json["distinct"],
319+ message: json["message"],
320+ sha: json["sha"],
321+ url: json["url"],
322+ );
323+
324+ Map<String, dynamic> toJson() => {
325+ "author": author.toJson(),
326+ "distinct": distinct,
327+ "message": message,
328+ "sha": sha,
329+ "url": url,
330+ };
331+}
332+
333+class Author {
334+ final String email;
335+ final String name;
336+
337+ Author({
338+ required this.email,
339+ required this.name,
340+ });
341+
342+ factory Author.fromJson(Map<String, dynamic> json) => Author(
343+ email: json["email"],
344+ name: json["name"],
345+ );
346+
347+ Map<String, dynamic> toJson() => {
348+ "email": email,
349+ "name": name,
350+ };
351+}
352+
353+class Issue {
354+ final dynamic assignee;
355+ final List<dynamic> assignees;
356+ final String body;
357+ final DateTime? closedAt;
358+ final int comments;
359+ final String commentsUrl;
360+ final DateTime createdAt;
361+ final String eventsUrl;
362+ final String htmlUrl;
363+ final int id;
364+ final List<Label> labels;
365+ final String labelsUrl;
366+ final bool locked;
367+ final Milestone? milestone;
368+ final int number;
369+ final IssuePullRequest? pullRequest;
370+ final String repositoryUrl;
371+ final String state;
372+ final String title;
373+ final DateTime updatedAt;
374+ final String url;
375+ final User user;
376+
377+ Issue({
378+ required this.assignee,
379+ required this.assignees,
380+ required this.body,
381+ required this.closedAt,
382+ required this.comments,
383+ required this.commentsUrl,
384+ required this.createdAt,
385+ required this.eventsUrl,
386+ required this.htmlUrl,
387+ required this.id,
388+ required this.labels,
389+ required this.labelsUrl,
390+ required this.locked,
391+ required this.milestone,
392+ required this.number,
393+ this.pullRequest,
394+ required this.repositoryUrl,
395+ required this.state,
396+ required this.title,
397+ required this.updatedAt,
398+ required this.url,
399+ required this.user,
400+ });
401+
402+ factory Issue.fromJson(Map<String, dynamic> json) => Issue(
403+ assignee: json["assignee"],
404+ assignees: List<dynamic>.from(json["assignees"].map((x) => x)),
405+ body: json["body"],
406+ closedAt: json["closed_at"] == null ? null : DateTime.parse(json["closed_at"]),
407+ comments: json["comments"],
408+ commentsUrl: json["comments_url"],
409+ createdAt: DateTime.parse(json["created_at"]),
410+ eventsUrl: json["events_url"],
411+ htmlUrl: json["html_url"],
412+ id: json["id"],
413+ labels: List<Label>.from(json["labels"].map((x) => Label.fromJson(x))),
414+ labelsUrl: json["labels_url"],
415+ locked: json["locked"],
416+ milestone: json["milestone"] == null ? null : Milestone.fromJson(json["milestone"]),
417+ number: json["number"],
418+ pullRequest: json["pull_request"] == null ? null : IssuePullRequest.fromJson(json["pull_request"]),
419+ repositoryUrl: json["repository_url"],
420+ state: json["state"],
421+ title: json["title"],
422+ updatedAt: DateTime.parse(json["updated_at"]),
423+ url: json["url"],
424+ user: User.fromJson(json["user"]),
425+ );
426+
427+ Map<String, dynamic> toJson() => {
428+ "assignee": assignee,
429+ "assignees": List<dynamic>.from(assignees.map((x) => x)),
430+ "body": body,
431+ "closed_at": closedAt?.toIso8601String(),
432+ "comments": comments,
433+ "comments_url": commentsUrl,
434+ "created_at": createdAt.toIso8601String(),
435+ "events_url": eventsUrl,
436+ "html_url": htmlUrl,
437+ "id": id,
438+ "labels": List<dynamic>.from(labels.map((x) => x.toJson())),
439+ "labels_url": labelsUrl,
440+ "locked": locked,
441+ "milestone": milestone?.toJson(),
442+ "number": number,
443+ "pull_request": pullRequest?.toJson(),
444+ "repository_url": repositoryUrl,
445+ "state": state,
446+ "title": title,
447+ "updated_at": updatedAt.toIso8601String(),
448+ "url": url,
449+ "user": user.toJson(),
450+ };
451+}
452+
453+class Label {
454+ final String color;
455+ final int id;
456+ final bool labelDefault;
457+ final String name;
458+ final String url;
459+
460+ Label({
461+ required this.color,
462+ required this.id,
463+ required this.labelDefault,
464+ required this.name,
465+ required this.url,
466+ });
467+
468+ factory Label.fromJson(Map<String, dynamic> json) => Label(
469+ color: json["color"],
470+ id: json["id"],
471+ labelDefault: json["default"],
472+ name: json["name"],
473+ url: json["url"],
474+ );
475+
476+ Map<String, dynamic> toJson() => {
477+ "color": color,
478+ "id": id,
479+ "default": labelDefault,
480+ "name": name,
481+ "url": url,
482+ };
483+}
484+
485+class Milestone {
486+ final dynamic closedAt;
487+ final int closedIssues;
488+ final DateTime createdAt;
489+ final User creator;
490+ final String description;
491+ final DateTime? dueOn;
492+ final String htmlUrl;
493+ final int id;
494+ final String labelsUrl;
495+ final int number;
496+ final int openIssues;
497+ final String state;
498+ final String title;
499+ final DateTime updatedAt;
500+ final String url;
501+
502+ Milestone({
503+ required this.closedAt,
504+ required this.closedIssues,
505+ required this.createdAt,
506+ required this.creator,
507+ required this.description,
508+ required this.dueOn,
509+ required this.htmlUrl,
510+ required this.id,
511+ required this.labelsUrl,
512+ required this.number,
513+ required this.openIssues,
514+ required this.state,
515+ required this.title,
516+ required this.updatedAt,
517+ required this.url,
518+ });
519+
520+ factory Milestone.fromJson(Map<String, dynamic> json) => Milestone(
521+ closedAt: json["closed_at"],
522+ closedIssues: json["closed_issues"],
523+ createdAt: DateTime.parse(json["created_at"]),
524+ creator: User.fromJson(json["creator"]),
525+ description: json["description"],
526+ dueOn: json["due_on"] == null ? null : DateTime.parse(json["due_on"]),
527+ htmlUrl: json["html_url"],
528+ id: json["id"],
529+ labelsUrl: json["labels_url"],
530+ number: json["number"],
531+ openIssues: json["open_issues"],
532+ state: json["state"],
533+ title: json["title"],
534+ updatedAt: DateTime.parse(json["updated_at"]),
535+ url: json["url"],
536+ );
537+
538+ Map<String, dynamic> toJson() => {
539+ "closed_at": closedAt,
540+ "closed_issues": closedIssues,
541+ "created_at": createdAt.toIso8601String(),
542+ "creator": creator.toJson(),
543+ "description": description,
544+ "due_on": dueOn?.toIso8601String(),
545+ "html_url": htmlUrl,
546+ "id": id,
547+ "labels_url": labelsUrl,
548+ "number": number,
549+ "open_issues": openIssues,
550+ "state": state,
551+ "title": title,
552+ "updated_at": updatedAt.toIso8601String(),
553+ "url": url,
554+ };
555+}
556+
557+class IssuePullRequest {
558+ final String diffUrl;
559+ final String htmlUrl;
560+ final String patchUrl;
561+ final String url;
562+
563+ IssuePullRequest({
564+ required this.diffUrl,
565+ required this.htmlUrl,
566+ required this.patchUrl,
567+ required this.url,
568+ });
569+
570+ factory IssuePullRequest.fromJson(Map<String, dynamic> json) => IssuePullRequest(
571+ diffUrl: json["diff_url"],
572+ htmlUrl: json["html_url"],
573+ patchUrl: json["patch_url"],
574+ url: json["url"],
575+ );
576+
577+ Map<String, dynamic> toJson() => {
578+ "diff_url": diffUrl,
579+ "html_url": htmlUrl,
580+ "patch_url": patchUrl,
581+ "url": url,
582+ };
583+}
584+
585+class PayloadPullRequest {
586+ final int additions;
587+ final dynamic assignee;
588+ final List<dynamic> assignees;
589+ final Base base;
590+ final String body;
591+ final int changedFiles;
592+ final DateTime closedAt;
593+ final int comments;
594+ final String commentsUrl;
595+ final int commits;
596+ final String commitsUrl;
597+ final DateTime createdAt;
598+ final int deletions;
599+ final String diffUrl;
600+ final Base head;
601+ final String htmlUrl;
602+ final int id;
603+ final String issueUrl;
604+ final Links links;
605+ final bool locked;
606+ final bool maintainerCanModify;
607+ final String mergeCommitSha;
608+ final dynamic mergeable;
609+ final String mergeableState;
610+ final bool merged;
611+ final DateTime mergedAt;
612+ final User mergedBy;
613+ final dynamic milestone;
614+ final int number;
615+ final String patchUrl;
616+ final dynamic rebaseable;
617+ final List<dynamic> requestedReviewers;
618+ final String reviewCommentUrl;
619+ final int reviewComments;
620+ final String reviewCommentsUrl;
621+ final String state;
622+ final String statusesUrl;
623+ final String title;
624+ final DateTime updatedAt;
625+ final String url;
626+ final User user;
627+
628+ PayloadPullRequest({
629+ required this.additions,
630+ required this.assignee,
631+ required this.assignees,
632+ required this.base,
633+ required this.body,
634+ required this.changedFiles,
635+ required this.closedAt,
636+ required this.comments,
637+ required this.commentsUrl,
638+ required this.commits,
639+ required this.commitsUrl,
640+ required this.createdAt,
641+ required this.deletions,
642+ required this.diffUrl,
643+ required this.head,
644+ required this.htmlUrl,
645+ required this.id,
646+ required this.issueUrl,
647+ required this.links,
648+ required this.locked,
649+ required this.maintainerCanModify,
650+ required this.mergeCommitSha,
651+ required this.mergeable,
652+ required this.mergeableState,
653+ required this.merged,
654+ required this.mergedAt,
655+ required this.mergedBy,
656+ required this.milestone,
657+ required this.number,
658+ required this.patchUrl,
659+ required this.rebaseable,
660+ required this.requestedReviewers,
661+ required this.reviewCommentUrl,
662+ required this.reviewComments,
663+ required this.reviewCommentsUrl,
664+ required this.state,
665+ required this.statusesUrl,
666+ required this.title,
667+ required this.updatedAt,
668+ required this.url,
669+ required this.user,
670+ });
671+
672+ factory PayloadPullRequest.fromJson(Map<String, dynamic> json) => PayloadPullRequest(
673+ additions: json["additions"],
674+ assignee: json["assignee"],
675+ assignees: List<dynamic>.from(json["assignees"].map((x) => x)),
676+ base: Base.fromJson(json["base"]),
677+ body: json["body"],
678+ changedFiles: json["changed_files"],
679+ closedAt: DateTime.parse(json["closed_at"]),
680+ comments: json["comments"],
681+ commentsUrl: json["comments_url"],
682+ commits: json["commits"],
683+ commitsUrl: json["commits_url"],
684+ createdAt: DateTime.parse(json["created_at"]),
685+ deletions: json["deletions"],
686+ diffUrl: json["diff_url"],
687+ head: Base.fromJson(json["head"]),
688+ htmlUrl: json["html_url"],
689+ id: json["id"],
690+ issueUrl: json["issue_url"],
691+ links: Links.fromJson(json["_links"]),
692+ locked: json["locked"],
693+ maintainerCanModify: json["maintainer_can_modify"],
694+ mergeCommitSha: json["merge_commit_sha"],
695+ mergeable: json["mergeable"],
696+ mergeableState: json["mergeable_state"],
697+ merged: json["merged"],
698+ mergedAt: DateTime.parse(json["merged_at"]),
699+ mergedBy: User.fromJson(json["merged_by"]),
700+ milestone: json["milestone"],
701+ number: json["number"],
702+ patchUrl: json["patch_url"],
703+ rebaseable: json["rebaseable"],
704+ requestedReviewers: List<dynamic>.from(json["requested_reviewers"].map((x) => x)),
705+ reviewCommentUrl: json["review_comment_url"],
706+ reviewComments: json["review_comments"],
707+ reviewCommentsUrl: json["review_comments_url"],
708+ state: json["state"],
709+ statusesUrl: json["statuses_url"],
710+ title: json["title"],
711+ updatedAt: DateTime.parse(json["updated_at"]),
712+ url: json["url"],
713+ user: User.fromJson(json["user"]),
714+ );
715+
716+ Map<String, dynamic> toJson() => {
717+ "additions": additions,
718+ "assignee": assignee,
719+ "assignees": List<dynamic>.from(assignees.map((x) => x)),
720+ "base": base.toJson(),
721+ "body": body,
722+ "changed_files": changedFiles,
723+ "closed_at": closedAt.toIso8601String(),
724+ "comments": comments,
725+ "comments_url": commentsUrl,
726+ "commits": commits,
727+ "commits_url": commitsUrl,
728+ "created_at": createdAt.toIso8601String(),
729+ "deletions": deletions,
730+ "diff_url": diffUrl,
731+ "head": head.toJson(),
732+ "html_url": htmlUrl,
733+ "id": id,
734+ "issue_url": issueUrl,
735+ "_links": links.toJson(),
736+ "locked": locked,
737+ "maintainer_can_modify": maintainerCanModify,
738+ "merge_commit_sha": mergeCommitSha,
739+ "mergeable": mergeable,
740+ "mergeable_state": mergeableState,
741+ "merged": merged,
742+ "merged_at": mergedAt.toIso8601String(),
743+ "merged_by": mergedBy.toJson(),
744+ "milestone": milestone,
745+ "number": number,
746+ "patch_url": patchUrl,
747+ "rebaseable": rebaseable,
748+ "requested_reviewers": List<dynamic>.from(requestedReviewers.map((x) => x)),
749+ "review_comment_url": reviewCommentUrl,
750+ "review_comments": reviewComments,
751+ "review_comments_url": reviewCommentsUrl,
752+ "state": state,
753+ "statuses_url": statusesUrl,
754+ "title": title,
755+ "updated_at": updatedAt.toIso8601String(),
756+ "url": url,
757+ "user": user.toJson(),
758+ };
759+}
760+
761+class Base {
762+ final String label;
763+ final String ref;
764+ final BaseRepo repo;
765+ final String sha;
766+ final User user;
767+
768+ Base({
769+ required this.label,
770+ required this.ref,
771+ required this.repo,
772+ required this.sha,
773+ required this.user,
774+ });
775+
776+ factory Base.fromJson(Map<String, dynamic> json) => Base(
777+ label: json["label"],
778+ ref: json["ref"],
779+ repo: BaseRepo.fromJson(json["repo"]),
780+ sha: json["sha"],
781+ user: User.fromJson(json["user"]),
782+ );
783+
784+ Map<String, dynamic> toJson() => {
785+ "label": label,
786+ "ref": ref,
787+ "repo": repo.toJson(),
788+ "sha": sha,
789+ "user": user.toJson(),
790+ };
791+}
792+
793+class BaseRepo {
794+ final String archiveUrl;
795+ final String assigneesUrl;
796+ final String blobsUrl;
797+ final String branchesUrl;
798+ final String cloneUrl;
799+ final String collaboratorsUrl;
800+ final String commentsUrl;
801+ final String commitsUrl;
802+ final String compareUrl;
803+ final String contentsUrl;
804+ final String contributorsUrl;
805+ final DateTime createdAt;
806+ final String defaultBranch;
807+ final String deploymentsUrl;
808+ final String description;
809+ final String downloadsUrl;
810+ final String eventsUrl;
811+ final bool fork;
812+ final int forks;
813+ final int forksCount;
814+ final String forksUrl;
815+ final String fullName;
816+ final String gitCommitsUrl;
817+ final String gitRefsUrl;
818+ final String gitTagsUrl;
819+ final String gitUrl;
820+ final bool hasDownloads;
821+ final bool hasIssues;
822+ final bool hasPages;
823+ final bool hasProjects;
824+ final bool hasWiki;
825+ final String homepage;
826+ final String hooksUrl;
827+ final String htmlUrl;
828+ final int id;
829+ final String issueCommentUrl;
830+ final String issueEventsUrl;
831+ final String issuesUrl;
832+ final String keysUrl;
833+ final String labelsUrl;
834+ final String language;
835+ final String languagesUrl;
836+ final String mergesUrl;
837+ final String milestonesUrl;
838+ final dynamic mirrorUrl;
839+ final String name;
840+ final String notificationsUrl;
841+ final int openIssues;
842+ final int openIssuesCount;
843+ final User owner;
844+ final bool private;
845+ final String pullsUrl;
846+ final DateTime pushedAt;
847+ final String releasesUrl;
848+ final int size;
849+ final String sshUrl;
850+ final int stargazersCount;
851+ final String stargazersUrl;
852+ final String statusesUrl;
853+ final String subscribersUrl;
854+ final String subscriptionUrl;
855+ final String svnUrl;
856+ final String tagsUrl;
857+ final String teamsUrl;
858+ final String treesUrl;
859+ final DateTime updatedAt;
860+ final String url;
861+ final int watchers;
862+ final int watchersCount;
863+
864+ BaseRepo({
865+ required this.archiveUrl,
866+ required this.assigneesUrl,
867+ required this.blobsUrl,
868+ required this.branchesUrl,
869+ required this.cloneUrl,
870+ required this.collaboratorsUrl,
871+ required this.commentsUrl,
872+ required this.commitsUrl,
873+ required this.compareUrl,
874+ required this.contentsUrl,
875+ required this.contributorsUrl,
876+ required this.createdAt,
877+ required this.defaultBranch,
878+ required this.deploymentsUrl,
879+ required this.description,
880+ required this.downloadsUrl,
881+ required this.eventsUrl,
882+ required this.fork,
883+ required this.forks,
884+ required this.forksCount,
885+ required this.forksUrl,
886+ required this.fullName,
887+ required this.gitCommitsUrl,
888+ required this.gitRefsUrl,
889+ required this.gitTagsUrl,
890+ required this.gitUrl,
891+ required this.hasDownloads,
892+ required this.hasIssues,
893+ required this.hasPages,
894+ required this.hasProjects,
895+ required this.hasWiki,
896+ required this.homepage,
897+ required this.hooksUrl,
898+ required this.htmlUrl,
899+ required this.id,
900+ required this.issueCommentUrl,
901+ required this.issueEventsUrl,
902+ required this.issuesUrl,
903+ required this.keysUrl,
904+ required this.labelsUrl,
905+ required this.language,
906+ required this.languagesUrl,
907+ required this.mergesUrl,
908+ required this.milestonesUrl,
909+ required this.mirrorUrl,
910+ required this.name,
911+ required this.notificationsUrl,
912+ required this.openIssues,
913+ required this.openIssuesCount,
914+ required this.owner,
915+ required this.private,
916+ required this.pullsUrl,
917+ required this.pushedAt,
918+ required this.releasesUrl,
919+ required this.size,
920+ required this.sshUrl,
921+ required this.stargazersCount,
922+ required this.stargazersUrl,
923+ required this.statusesUrl,
924+ required this.subscribersUrl,
925+ required this.subscriptionUrl,
926+ required this.svnUrl,
927+ required this.tagsUrl,
928+ required this.teamsUrl,
929+ required this.treesUrl,
930+ required this.updatedAt,
931+ required this.url,
932+ required this.watchers,
933+ required this.watchersCount,
934+ });
935+
936+ factory BaseRepo.fromJson(Map<String, dynamic> json) => BaseRepo(
937+ archiveUrl: json["archive_url"],
938+ assigneesUrl: json["assignees_url"],
939+ blobsUrl: json["blobs_url"],
940+ branchesUrl: json["branches_url"],
941+ cloneUrl: json["clone_url"],
942+ collaboratorsUrl: json["collaborators_url"],
943+ commentsUrl: json["comments_url"],
944+ commitsUrl: json["commits_url"],
945+ compareUrl: json["compare_url"],
946+ contentsUrl: json["contents_url"],
947+ contributorsUrl: json["contributors_url"],
948+ createdAt: DateTime.parse(json["created_at"]),
949+ defaultBranch: json["default_branch"],
950+ deploymentsUrl: json["deployments_url"],
951+ description: json["description"],
952+ downloadsUrl: json["downloads_url"],
953+ eventsUrl: json["events_url"],
954+ fork: json["fork"],
955+ forks: json["forks"],
956+ forksCount: json["forks_count"],
957+ forksUrl: json["forks_url"],
958+ fullName: json["full_name"],
959+ gitCommitsUrl: json["git_commits_url"],
960+ gitRefsUrl: json["git_refs_url"],
961+ gitTagsUrl: json["git_tags_url"],
962+ gitUrl: json["git_url"],
963+ hasDownloads: json["has_downloads"],
964+ hasIssues: json["has_issues"],
965+ hasPages: json["has_pages"],
966+ hasProjects: json["has_projects"],
967+ hasWiki: json["has_wiki"],
968+ homepage: json["homepage"],
969+ hooksUrl: json["hooks_url"],
970+ htmlUrl: json["html_url"],
971+ id: json["id"],
972+ issueCommentUrl: json["issue_comment_url"],
973+ issueEventsUrl: json["issue_events_url"],
974+ issuesUrl: json["issues_url"],
975+ keysUrl: json["keys_url"],
976+ labelsUrl: json["labels_url"],
977+ language: json["language"],
978+ languagesUrl: json["languages_url"],
979+ mergesUrl: json["merges_url"],
980+ milestonesUrl: json["milestones_url"],
981+ mirrorUrl: json["mirror_url"],
982+ name: json["name"],
983+ notificationsUrl: json["notifications_url"],
984+ openIssues: json["open_issues"],
985+ openIssuesCount: json["open_issues_count"],
986+ owner: User.fromJson(json["owner"]),
987+ private: json["private"],
988+ pullsUrl: json["pulls_url"],
989+ pushedAt: DateTime.parse(json["pushed_at"]),
990+ releasesUrl: json["releases_url"],
991+ size: json["size"],
992+ sshUrl: json["ssh_url"],
993+ stargazersCount: json["stargazers_count"],
994+ stargazersUrl: json["stargazers_url"],
995+ statusesUrl: json["statuses_url"],
996+ subscribersUrl: json["subscribers_url"],
997+ subscriptionUrl: json["subscription_url"],
998+ svnUrl: json["svn_url"],
999+ tagsUrl: json["tags_url"],
1000+ teamsUrl: json["teams_url"],
1001+ treesUrl: json["trees_url"],
1002+ updatedAt: DateTime.parse(json["updated_at"]),
1003+ url: json["url"],
1004+ watchers: json["watchers"],
1005+ watchersCount: json["watchers_count"],
1006+ );
1007+
1008+ Map<String, dynamic> toJson() => {
1009+ "archive_url": archiveUrl,
1010+ "assignees_url": assigneesUrl,
1011+ "blobs_url": blobsUrl,
1012+ "branches_url": branchesUrl,
1013+ "clone_url": cloneUrl,
1014+ "collaborators_url": collaboratorsUrl,
1015+ "comments_url": commentsUrl,
1016+ "commits_url": commitsUrl,
1017+ "compare_url": compareUrl,
1018+ "contents_url": contentsUrl,
1019+ "contributors_url": contributorsUrl,
1020+ "created_at": createdAt.toIso8601String(),
1021+ "default_branch": defaultBranch,
1022+ "deployments_url": deploymentsUrl,
1023+ "description": description,
1024+ "downloads_url": downloadsUrl,
1025+ "events_url": eventsUrl,
1026+ "fork": fork,
1027+ "forks": forks,
1028+ "forks_count": forksCount,
1029+ "forks_url": forksUrl,
1030+ "full_name": fullName,
1031+ "git_commits_url": gitCommitsUrl,
1032+ "git_refs_url": gitRefsUrl,
1033+ "git_tags_url": gitTagsUrl,
1034+ "git_url": gitUrl,
1035+ "has_downloads": hasDownloads,
1036+ "has_issues": hasIssues,
1037+ "has_pages": hasPages,
1038+ "has_projects": hasProjects,
1039+ "has_wiki": hasWiki,
1040+ "homepage": homepage,
1041+ "hooks_url": hooksUrl,
1042+ "html_url": htmlUrl,
1043+ "id": id,
1044+ "issue_comment_url": issueCommentUrl,
1045+ "issue_events_url": issueEventsUrl,
1046+ "issues_url": issuesUrl,
1047+ "keys_url": keysUrl,
1048+ "labels_url": labelsUrl,
1049+ "language": language,
1050+ "languages_url": languagesUrl,
1051+ "merges_url": mergesUrl,
1052+ "milestones_url": milestonesUrl,
1053+ "mirror_url": mirrorUrl,
1054+ "name": name,
1055+ "notifications_url": notificationsUrl,
1056+ "open_issues": openIssues,
1057+ "open_issues_count": openIssuesCount,
1058+ "owner": owner.toJson(),
1059+ "private": private,
1060+ "pulls_url": pullsUrl,
1061+ "pushed_at": pushedAt.toIso8601String(),
1062+ "releases_url": releasesUrl,
1063+ "size": size,
1064+ "ssh_url": sshUrl,
1065+ "stargazers_count": stargazersCount,
1066+ "stargazers_url": stargazersUrl,
1067+ "statuses_url": statusesUrl,
1068+ "subscribers_url": subscribersUrl,
1069+ "subscription_url": subscriptionUrl,
1070+ "svn_url": svnUrl,
1071+ "tags_url": tagsUrl,
1072+ "teams_url": teamsUrl,
1073+ "trees_url": treesUrl,
1074+ "updated_at": updatedAt.toIso8601String(),
1075+ "url": url,
1076+ "watchers": watchers,
1077+ "watchers_count": watchersCount,
1078+ };
1079+}
1080+
1081+class Links {
1082+ final Comments comments;
1083+ final Comments commits;
1084+ final Comments html;
1085+ final Comments issue;
1086+ final Comments reviewComment;
1087+ final Comments reviewComments;
1088+ final Comments self;
1089+ final Comments statuses;
1090+
1091+ Links({
1092+ required this.comments,
1093+ required this.commits,
1094+ required this.html,
1095+ required this.issue,
1096+ required this.reviewComment,
1097+ required this.reviewComments,
1098+ required this.self,
1099+ required this.statuses,
1100+ });
1101+
1102+ factory Links.fromJson(Map<String, dynamic> json) => Links(
1103+ comments: Comments.fromJson(json["comments"]),
1104+ commits: Comments.fromJson(json["commits"]),
1105+ html: Comments.fromJson(json["html"]),
1106+ issue: Comments.fromJson(json["issue"]),
1107+ reviewComment: Comments.fromJson(json["review_comment"]),
1108+ reviewComments: Comments.fromJson(json["review_comments"]),
1109+ self: Comments.fromJson(json["self"]),
1110+ statuses: Comments.fromJson(json["statuses"]),
1111+ );
1112+
1113+ Map<String, dynamic> toJson() => {
1114+ "comments": comments.toJson(),
1115+ "commits": commits.toJson(),
1116+ "html": html.toJson(),
1117+ "issue": issue.toJson(),
1118+ "review_comment": reviewComment.toJson(),
1119+ "review_comments": reviewComments.toJson(),
1120+ "self": self.toJson(),
1121+ "statuses": statuses.toJson(),
1122+ };
1123+}
1124+
1125+class Comments {
1126+ final String href;
1127+
1128+ Comments({
1129+ required this.href,
1130+ });
1131+
1132+ factory Comments.fromJson(Map<String, dynamic> json) => Comments(
1133+ href: json["href"],
1134+ );
1135+
1136+ Map<String, dynamic> toJson() => {
1137+ "href": href,
1138+ };
1139+}
1140+
1141+class TopLevelRepo {
1142+ final int id;
1143+ final String name;
1144+ final String url;
1145+
1146+ TopLevelRepo({
1147+ required this.id,
1148+ required this.name,
1149+ required this.url,
1150+ });
1151+
1152+ factory TopLevelRepo.fromJson(Map<String, dynamic> json) => TopLevelRepo(
1153+ id: json["id"],
1154+ name: json["name"],
1155+ url: json["url"],
1156+ );
1157+
1158+ Map<String, dynamic> toJson() => {
1159+ "id": id,
1160+ "name": name,
1161+ "url": url,
1162+ };
1163+}
1164+
1165+class EnumValues<T> {
1166+ Map<String, T> map;
1167+ late Map<T, String> reverseMap;
1168+
1169+ EnumValues(this.map);
1170+
1171+ Map<T, String> get reverse {
1172+ reverseMap = map.map((k, v) => MapEntry(v, k));
1173+ return reverseMap;
1174+ }
1175+}
Test case

test/inputs/json/samples/pokedex.json

1 generated file · +195 −0
Adartdefault / TopLevel.dart+195 −0
@@ -0,0 +1,195 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final List<Pokemon> pokemon;
13+
14+ TopLevel({
15+ required this.pokemon,
16+ });
17+
18+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
19+ pokemon: List<Pokemon>.from(json["pokemon"].map((x) => Pokemon.fromJson(x))),
20+ );
21+
22+ Map<String, dynamic> toJson() => {
23+ "pokemon": List<dynamic>.from(pokemon.map((x) => x.toJson())),
24+ };
25+}
26+
27+class Pokemon {
28+ final double avgSpawns;
29+ final String candy;
30+ final int? candyCount;
31+ final Egg egg;
32+ final String height;
33+ final int id;
34+ final String img;
35+ final List<double>? multipliers;
36+ final String name;
37+ final List<Evolution>? nextEvolution;
38+ final String num;
39+ final List<Evolution>? prevEvolution;
40+ final double spawnChance;
41+ final String spawnTime;
42+ final List<Type> type;
43+ final List<Type> weaknesses;
44+ final String weight;
45+
46+ Pokemon({
47+ required this.avgSpawns,
48+ required this.candy,
49+ this.candyCount,
50+ required this.egg,
51+ required this.height,
52+ required this.id,
53+ required this.img,
54+ required this.multipliers,
55+ required this.name,
56+ this.nextEvolution,
57+ required this.num,
58+ this.prevEvolution,
59+ required this.spawnChance,
60+ required this.spawnTime,
61+ required this.type,
62+ required this.weaknesses,
63+ required this.weight,
64+ });
65+
66+ factory Pokemon.fromJson(Map<String, dynamic> json) => Pokemon(
67+ avgSpawns: json["avg_spawns"]?.toDouble(),
68+ candy: json["candy"],
69+ candyCount: json["candy_count"],
70+ egg: eggValues.map[json["egg"]]!,
71+ height: json["height"],
72+ id: json["id"],
73+ img: json["img"],
74+ multipliers: json["multipliers"] == null ? null : List<double>.from(json["multipliers"]!.map((x) => x?.toDouble())),
75+ name: json["name"],
76+ nextEvolution: json["next_evolution"] == null ? null : List<Evolution>.from(json["next_evolution"]!.map((x) => Evolution.fromJson(x))),
77+ num: json["num"],
78+ prevEvolution: json["prev_evolution"] == null ? null : List<Evolution>.from(json["prev_evolution"]!.map((x) => Evolution.fromJson(x))),
79+ spawnChance: json["spawn_chance"]?.toDouble(),
80+ spawnTime: json["spawn_time"],
81+ type: List<Type>.from(json["type"].map((x) => typeValues.map[x]!)),
82+ weaknesses: List<Type>.from(json["weaknesses"].map((x) => typeValues.map[x]!)),
83+ weight: json["weight"],
84+ );
85+
86+ Map<String, dynamic> toJson() => {
87+ "avg_spawns": avgSpawns,
88+ "candy": candy,
89+ "candy_count": candyCount,
90+ "egg": eggValues.reverse[egg],
91+ "height": height,
92+ "id": id,
93+ "img": img,
94+ "multipliers": multipliers == null ? null : List<dynamic>.from(multipliers!.map((x) => x)),
95+ "name": name,
96+ "next_evolution": nextEvolution == null ? null : List<dynamic>.from(nextEvolution!.map((x) => x.toJson())),
97+ "num": num,
98+ "prev_evolution": prevEvolution == null ? null : List<dynamic>.from(prevEvolution!.map((x) => x.toJson())),
99+ "spawn_chance": spawnChance,
100+ "spawn_time": spawnTime,
101+ "type": List<dynamic>.from(type.map((x) => typeValues.reverse[x])),
102+ "weaknesses": List<dynamic>.from(weaknesses.map((x) => typeValues.reverse[x])),
103+ "weight": weight,
104+ };
105+}
106+
107+enum Egg {
108+ THE_2_KM,
109+ NOT_IN_EGGS,
110+ THE_5_KM,
111+ THE_10_KM,
112+ OMANYTE_CANDY
113+}
114+
115+final eggValues = EnumValues({
116+ "2 km": Egg.THE_2_KM,
117+ "Not in Eggs": Egg.NOT_IN_EGGS,
118+ "5 km": Egg.THE_5_KM,
119+ "10 km": Egg.THE_10_KM,
120+ "Omanyte Candy": Egg.OMANYTE_CANDY
121+});
122+
123+class Evolution {
124+ final String name;
125+ final String num;
126+
127+ Evolution({
128+ required this.name,
129+ required this.num,
130+ });
131+
132+ factory Evolution.fromJson(Map<String, dynamic> json) => Evolution(
133+ name: json["name"],
134+ num: json["num"],
135+ );
136+
137+ Map<String, dynamic> toJson() => {
138+ "name": name,
139+ "num": num,
140+ };
141+}
142+
143+enum Type {
144+ FIRE,
145+ ICE,
146+ FLYING,
147+ PSYCHIC,
148+ WATER,
149+ GROUND,
150+ ROCK,
151+ ELECTRIC,
152+ GRASS,
153+ FIGHTING,
154+ POISON,
155+ BUG,
156+ FAIRY,
157+ GHOST,
158+ DARK,
159+ STEEL,
160+ DRAGON,
161+ NORMAL
162+}
163+
164+final typeValues = EnumValues({
165+ "Fire": Type.FIRE,
166+ "Ice": Type.ICE,
167+ "Flying": Type.FLYING,
168+ "Psychic": Type.PSYCHIC,
169+ "Water": Type.WATER,
170+ "Ground": Type.GROUND,
171+ "Rock": Type.ROCK,
172+ "Electric": Type.ELECTRIC,
173+ "Grass": Type.GRASS,
174+ "Fighting": Type.FIGHTING,
175+ "Poison": Type.POISON,
176+ "Bug": Type.BUG,
177+ "Fairy": Type.FAIRY,
178+ "Ghost": Type.GHOST,
179+ "Dark": Type.DARK,
180+ "Steel": Type.STEEL,
181+ "Dragon": Type.DRAGON,
182+ "Normal": Type.NORMAL
183+});
184+
185+class EnumValues<T> {
186+ Map<String, T> map;
187+ late Map<T, String> reverseMap;
188+
189+ EnumValues(this.map);
190+
191+ Map<T, String> get reverse {
192+ reverseMap = map.map((k, v) => MapEntry(v, k));
193+ return reverseMap;
194+ }
195+}
Test case

test/inputs/json/samples/reddit.json

1 generated file · +559 −0
Adartdefault / TopLevel.dart+559 −0
@@ -0,0 +1,559 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final TopLevelData data;
13+ final String kind;
14+
15+ TopLevel({
16+ required this.data,
17+ required this.kind,
18+ });
19+
20+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
21+ data: TopLevelData.fromJson(json["data"]),
22+ kind: json["kind"],
23+ );
24+
25+ Map<String, dynamic> toJson() => {
26+ "data": data.toJson(),
27+ "kind": kind,
28+ };
29+}
30+
31+class TopLevelData {
32+ final String after;
33+ final dynamic before;
34+ final List<Child> children;
35+ final String modhash;
36+
37+ TopLevelData({
38+ required this.after,
39+ required this.before,
40+ required this.children,
41+ required this.modhash,
42+ });
43+
44+ factory TopLevelData.fromJson(Map<String, dynamic> json) => TopLevelData(
45+ after: json["after"],
46+ before: json["before"],
47+ children: List<Child>.from(json["children"].map((x) => Child.fromJson(x))),
48+ modhash: json["modhash"],
49+ );
50+
51+ Map<String, dynamic> toJson() => {
52+ "after": after,
53+ "before": before,
54+ "children": List<dynamic>.from(children.map((x) => x.toJson())),
55+ "modhash": modhash,
56+ };
57+}
58+
59+class Child {
60+ final ChildData data;
61+ final Kind kind;
62+
63+ Child({
64+ required this.data,
65+ required this.kind,
66+ });
67+
68+ factory Child.fromJson(Map<String, dynamic> json) => Child(
69+ data: ChildData.fromJson(json["data"]),
70+ kind: kindValues.map[json["kind"]]!,
71+ );
72+
73+ Map<String, dynamic> toJson() => {
74+ "data": data.toJson(),
75+ "kind": kindValues.reverse[kind],
76+ };
77+}
78+
79+class ChildData {
80+ final dynamic approvedAtUtc;
81+ final dynamic approvedBy;
82+ final bool archived;
83+ final String author;
84+ final String? authorFlairCssClass;
85+ final String? authorFlairText;
86+ final dynamic bannedAtUtc;
87+ final dynamic bannedBy;
88+ final bool brandSafe;
89+ final bool canGild;
90+ final bool canModPost;
91+ final bool clicked;
92+ final bool contestMode;
93+ final int created;
94+ final int createdUtc;
95+ final String? distinguished;
96+ final Domain domain;
97+ final int downs;
98+ final bool edited;
99+ final int gilded;
100+ final bool hidden;
101+ final bool hideScore;
102+ final String id;
103+ final bool isSelf;
104+ final bool isVideo;
105+ final dynamic likes;
106+ final String? linkFlairCssClass;
107+ final String? linkFlairText;
108+ final bool locked;
109+ final dynamic media;
110+ final MediaEmbed mediaEmbed;
111+ final List<dynamic> modReports;
112+ final String name;
113+ final int numComments;
114+ final dynamic numReports;
115+ final bool over18;
116+ final WhitelistStatus parentWhitelistStatus;
117+ final String permalink;
118+ final PostHint postHint;
119+ final Preview preview;
120+ final bool quarantine;
121+ final dynamic removalReason;
122+ final dynamic reportReasons;
123+ final bool saved;
124+ final int score;
125+ final dynamic secureMedia;
126+ final MediaEmbed secureMediaEmbed;
127+ final String selftext;
128+ final dynamic selftextHtml;
129+ final bool spoiler;
130+ final bool stickied;
131+ final Subreddit subreddit;
132+ final SubredditId subredditId;
133+ final SubredditNamePrefixed subredditNamePrefixed;
134+ final SubredditType subredditType;
135+ final dynamic suggestedSort;
136+ final String thumbnail;
137+ final int thumbnailHeight;
138+ final int thumbnailWidth;
139+ final String title;
140+ final int ups;
141+ final String url;
142+ final List<dynamic> userReports;
143+ final dynamic viewCount;
144+ final bool visited;
145+ final WhitelistStatus whitelistStatus;
146+
147+ ChildData({
148+ required this.approvedAtUtc,
149+ required this.approvedBy,
150+ required this.archived,
151+ required this.author,
152+ required this.authorFlairCssClass,
153+ required this.authorFlairText,
154+ required this.bannedAtUtc,
155+ required this.bannedBy,
156+ required this.brandSafe,
157+ required this.canGild,
158+ required this.canModPost,
159+ required this.clicked,
160+ required this.contestMode,
161+ required this.created,
162+ required this.createdUtc,
163+ required this.distinguished,
164+ required this.domain,
165+ required this.downs,
166+ required this.edited,
167+ required this.gilded,
168+ required this.hidden,
169+ required this.hideScore,
170+ required this.id,
171+ required this.isSelf,
172+ required this.isVideo,
173+ required this.likes,
174+ required this.linkFlairCssClass,
175+ required this.linkFlairText,
176+ required this.locked,
177+ required this.media,
178+ required this.mediaEmbed,
179+ required this.modReports,
180+ required this.name,
181+ required this.numComments,
182+ required this.numReports,
183+ required this.over18,
184+ required this.parentWhitelistStatus,
185+ required this.permalink,
186+ required this.postHint,
187+ required this.preview,
188+ required this.quarantine,
189+ required this.removalReason,
190+ required this.reportReasons,
191+ required this.saved,
192+ required this.score,
193+ required this.secureMedia,
194+ required this.secureMediaEmbed,
195+ required this.selftext,
196+ required this.selftextHtml,
197+ required this.spoiler,
198+ required this.stickied,
199+ required this.subreddit,
200+ required this.subredditId,
201+ required this.subredditNamePrefixed,
202+ required this.subredditType,
203+ required this.suggestedSort,
204+ required this.thumbnail,
205+ required this.thumbnailHeight,
206+ required this.thumbnailWidth,
207+ required this.title,
208+ required this.ups,
209+ required this.url,
210+ required this.userReports,
211+ required this.viewCount,
212+ required this.visited,
213+ required this.whitelistStatus,
214+ });
215+
216+ factory ChildData.fromJson(Map<String, dynamic> json) => ChildData(
217+ approvedAtUtc: json["approved_at_utc"],
218+ approvedBy: json["approved_by"],
219+ archived: json["archived"],
220+ author: json["author"],
221+ authorFlairCssClass: json["author_flair_css_class"],
222+ authorFlairText: json["author_flair_text"],
223+ bannedAtUtc: json["banned_at_utc"],
224+ bannedBy: json["banned_by"],
225+ brandSafe: json["brand_safe"],
226+ canGild: json["can_gild"],
227+ canModPost: json["can_mod_post"],
228+ clicked: json["clicked"],
229+ contestMode: json["contest_mode"],
230+ created: json["created"],
231+ createdUtc: json["created_utc"],
232+ distinguished: json["distinguished"],
233+ domain: domainValues.map[json["domain"]]!,
234+ downs: json["downs"],
235+ edited: json["edited"],
236+ gilded: json["gilded"],
237+ hidden: json["hidden"],
238+ hideScore: json["hide_score"],
239+ id: json["id"],
240+ isSelf: json["is_self"],
241+ isVideo: json["is_video"],
242+ likes: json["likes"],
243+ linkFlairCssClass: json["link_flair_css_class"],
244+ linkFlairText: json["link_flair_text"],
245+ locked: json["locked"],
246+ media: json["media"],
247+ mediaEmbed: MediaEmbed.fromJson(json["media_embed"]),
248+ modReports: List<dynamic>.from(json["mod_reports"].map((x) => x)),
249+ name: json["name"],
250+ numComments: json["num_comments"],
251+ numReports: json["num_reports"],
252+ over18: json["over_18"],
253+ parentWhitelistStatus: whitelistStatusValues.map[json["parent_whitelist_status"]]!,
254+ permalink: json["permalink"],
255+ postHint: postHintValues.map[json["post_hint"]]!,
256+ preview: Preview.fromJson(json["preview"]),
257+ quarantine: json["quarantine"],
258+ removalReason: json["removal_reason"],
259+ reportReasons: json["report_reasons"],
260+ saved: json["saved"],
261+ score: json["score"],
262+ secureMedia: json["secure_media"],
263+ secureMediaEmbed: MediaEmbed.fromJson(json["secure_media_embed"]),
264+ selftext: json["selftext"],
265+ selftextHtml: json["selftext_html"],
266+ spoiler: json["spoiler"],
267+ stickied: json["stickied"],
268+ subreddit: subredditValues.map[json["subreddit"]]!,
269+ subredditId: subredditIdValues.map[json["subreddit_id"]]!,
270+ subredditNamePrefixed: subredditNamePrefixedValues.map[json["subreddit_name_prefixed"]]!,
271+ subredditType: subredditTypeValues.map[json["subreddit_type"]]!,
272+ suggestedSort: json["suggested_sort"],
273+ thumbnail: json["thumbnail"],
274+ thumbnailHeight: json["thumbnail_height"],
275+ thumbnailWidth: json["thumbnail_width"],
276+ title: json["title"],
277+ ups: json["ups"],
278+ url: json["url"],
279+ userReports: List<dynamic>.from(json["user_reports"].map((x) => x)),
280+ viewCount: json["view_count"],
281+ visited: json["visited"],
282+ whitelistStatus: whitelistStatusValues.map[json["whitelist_status"]]!,
283+ );
284+
285+ Map<String, dynamic> toJson() => {
286+ "approved_at_utc": approvedAtUtc,
287+ "approved_by": approvedBy,
288+ "archived": archived,
289+ "author": author,
290+ "author_flair_css_class": authorFlairCssClass,
291+ "author_flair_text": authorFlairText,
292+ "banned_at_utc": bannedAtUtc,
293+ "banned_by": bannedBy,
294+ "brand_safe": brandSafe,
295+ "can_gild": canGild,
296+ "can_mod_post": canModPost,
297+ "clicked": clicked,
298+ "contest_mode": contestMode,
299+ "created": created,
300+ "created_utc": createdUtc,
301+ "distinguished": distinguished,
302+ "domain": domainValues.reverse[domain],
303+ "downs": downs,
304+ "edited": edited,
305+ "gilded": gilded,
306+ "hidden": hidden,
307+ "hide_score": hideScore,
308+ "id": id,
309+ "is_self": isSelf,
310+ "is_video": isVideo,
311+ "likes": likes,
312+ "link_flair_css_class": linkFlairCssClass,
313+ "link_flair_text": linkFlairText,
314+ "locked": locked,
315+ "media": media,
316+ "media_embed": mediaEmbed.toJson(),
317+ "mod_reports": List<dynamic>.from(modReports.map((x) => x)),
318+ "name": name,
319+ "num_comments": numComments,
320+ "num_reports": numReports,
321+ "over_18": over18,
322+ "parent_whitelist_status": whitelistStatusValues.reverse[parentWhitelistStatus],
323+ "permalink": permalink,
324+ "post_hint": postHintValues.reverse[postHint],
325+ "preview": preview.toJson(),
326+ "quarantine": quarantine,
327+ "removal_reason": removalReason,
328+ "report_reasons": reportReasons,
329+ "saved": saved,
330+ "score": score,
331+ "secure_media": secureMedia,
332+ "secure_media_embed": secureMediaEmbed.toJson(),
333+ "selftext": selftext,
334+ "selftext_html": selftextHtml,
335+ "spoiler": spoiler,
336+ "stickied": stickied,
337+ "subreddit": subredditValues.reverse[subreddit],
338+ "subreddit_id": subredditIdValues.reverse[subredditId],
339+ "subreddit_name_prefixed": subredditNamePrefixedValues.reverse[subredditNamePrefixed],
340+ "subreddit_type": subredditTypeValues.reverse[subredditType],
341+ "suggested_sort": suggestedSort,
342+ "thumbnail": thumbnail,
343+ "thumbnail_height": thumbnailHeight,
344+ "thumbnail_width": thumbnailWidth,
345+ "title": title,
346+ "ups": ups,
347+ "url": url,
348+ "user_reports": List<dynamic>.from(userReports.map((x) => x)),
349+ "view_count": viewCount,
350+ "visited": visited,
351+ "whitelist_status": whitelistStatusValues.reverse[whitelistStatus],
352+ };
353+}
354+
355+enum Domain {
356+ REDDIT_COM,
357+ I_IMGUR_COM,
358+ IMGUR_COM,
359+ I_REDD_IT
360+}
361+
362+final domainValues = EnumValues({
363+ "reddit.com": Domain.REDDIT_COM,
364+ "i.imgur.com": Domain.I_IMGUR_COM,
365+ "imgur.com": Domain.IMGUR_COM,
366+ "i.redd.it": Domain.I_REDD_IT
367+});
368+
369+class MediaEmbed {
370+ MediaEmbed();
371+
372+ factory MediaEmbed.fromJson(Map<String, dynamic> json) => MediaEmbed(
373+ );
374+
375+ Map<String, dynamic> toJson() => {
376+ };
377+}
378+
379+enum WhitelistStatus {
380+ ALL_ADS
381+}
382+
383+final whitelistStatusValues = EnumValues({
384+ "all_ads": WhitelistStatus.ALL_ADS
385+});
386+
387+enum PostHint {
388+ LINK,
389+ IMAGE
390+}
391+
392+final postHintValues = EnumValues({
393+ "link": PostHint.LINK,
394+ "image": PostHint.IMAGE
395+});
396+
397+class Preview {
398+ final bool enabled;
399+ final List<Image> images;
400+
401+ Preview({
402+ required this.enabled,
403+ required this.images,
404+ });
405+
406+ factory Preview.fromJson(Map<String, dynamic> json) => Preview(
407+ enabled: json["enabled"],
408+ images: List<Image>.from(json["images"].map((x) => Image.fromJson(x))),
409+ );
410+
411+ Map<String, dynamic> toJson() => {
412+ "enabled": enabled,
413+ "images": List<dynamic>.from(images.map((x) => x.toJson())),
414+ };
415+}
416+
417+class Image {
418+ final String id;
419+ final List<Source> resolutions;
420+ final Source source;
421+ final Variants variants;
422+
423+ Image({
424+ required this.id,
425+ required this.resolutions,
426+ required this.source,
427+ required this.variants,
428+ });
429+
430+ factory Image.fromJson(Map<String, dynamic> json) => Image(
431+ id: json["id"],
432+ resolutions: List<Source>.from(json["resolutions"].map((x) => Source.fromJson(x))),
433+ source: Source.fromJson(json["source"]),
434+ variants: Variants.fromJson(json["variants"]),
435+ );
436+
437+ Map<String, dynamic> toJson() => {
438+ "id": id,
439+ "resolutions": List<dynamic>.from(resolutions.map((x) => x.toJson())),
440+ "source": source.toJson(),
441+ "variants": variants.toJson(),
442+ };
443+}
444+
445+class Source {
446+ final int height;
447+ final String url;
448+ final int width;
449+
450+ Source({
451+ required this.height,
452+ required this.url,
453+ required this.width,
454+ });
455+
456+ factory Source.fromJson(Map<String, dynamic> json) => Source(
457+ height: json["height"],
458+ url: json["url"],
459+ width: json["width"],
460+ );
461+
462+ Map<String, dynamic> toJson() => {
463+ "height": height,
464+ "url": url,
465+ "width": width,
466+ };
467+}
468+
469+class Variants {
470+ final Gif? gif;
471+ final Gif? mp4;
472+
473+ Variants({
474+ this.gif,
475+ this.mp4,
476+ });
477+
478+ factory Variants.fromJson(Map<String, dynamic> json) => Variants(
479+ gif: json["gif"] == null ? null : Gif.fromJson(json["gif"]),
480+ mp4: json["mp4"] == null ? null : Gif.fromJson(json["mp4"]),
481+ );
482+
483+ Map<String, dynamic> toJson() => {
484+ "gif": gif?.toJson(),
485+ "mp4": mp4?.toJson(),
486+ };
487+}
488+
489+class Gif {
490+ final List<Source> resolutions;
491+ final Source source;
492+
493+ Gif({
494+ required this.resolutions,
495+ required this.source,
496+ });
497+
498+ factory Gif.fromJson(Map<String, dynamic> json) => Gif(
499+ resolutions: List<Source>.from(json["resolutions"].map((x) => Source.fromJson(x))),
500+ source: Source.fromJson(json["source"]),
501+ );
502+
503+ Map<String, dynamic> toJson() => {
504+ "resolutions": List<dynamic>.from(resolutions.map((x) => x.toJson())),
505+ "source": source.toJson(),
506+ };
507+}
508+
509+enum Subreddit {
510+ FUNNY
511+}
512+
513+final subredditValues = EnumValues({
514+ "funny": Subreddit.FUNNY
515+});
516+
517+enum SubredditId {
518+ T5_2_QH33
519+}
520+
521+final subredditIdValues = EnumValues({
522+ "t5_2qh33": SubredditId.T5_2_QH33
523+});
524+
525+enum SubredditNamePrefixed {
526+ R_FUNNY
527+}
528+
529+final subredditNamePrefixedValues = EnumValues({
530+ "r/funny": SubredditNamePrefixed.R_FUNNY
531+});
532+
533+enum SubredditType {
534+ PUBLIC
535+}
536+
537+final subredditTypeValues = EnumValues({
538+ "public": SubredditType.PUBLIC
539+});
540+
541+enum Kind {
542+ T3
543+}
544+
545+final kindValues = EnumValues({
546+ "t3": Kind.T3
547+});
548+
549+class EnumValues<T> {
550+ Map<String, T> map;
551+ late Map<T, String> reverseMap;
552+
553+ EnumValues(this.map);
554+
555+ Map<T, String> get reverse {
556+ reverseMap = map.map((k, v) => MapEntry(v, k));
557+ return reverseMap;
558+ }
559+}
Test case

test/inputs/json/samples/us-senators.json

1 generated file · +389 −0
Adartdefault / TopLevel.dart+389 −0
@@ -0,0 +1,389 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final Meta meta;
13+ final List<Object> objects;
14+
15+ TopLevel({
16+ required this.meta,
17+ required this.objects,
18+ });
19+
20+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
21+ meta: Meta.fromJson(json["meta"]),
22+ objects: List<Object>.from(json["objects"].map((x) => Object.fromJson(x))),
23+ );
24+
25+ Map<String, dynamic> toJson() => {
26+ "meta": meta.toJson(),
27+ "objects": List<dynamic>.from(objects.map((x) => x.toJson())),
28+ };
29+}
30+
31+class Meta {
32+ final int limit;
33+ final int offset;
34+ final int totalCount;
35+
36+ Meta({
37+ required this.limit,
38+ required this.offset,
39+ required this.totalCount,
40+ });
41+
42+ factory Meta.fromJson(Map<String, dynamic> json) => Meta(
43+ limit: json["limit"],
44+ offset: json["offset"],
45+ totalCount: json["total_count"],
46+ );
47+
48+ Map<String, dynamic> toJson() => {
49+ "limit": limit,
50+ "offset": offset,
51+ "total_count": totalCount,
52+ };
53+}
54+
55+class Object {
56+ final Party? caucus;
57+ final List<int> congressNumbers;
58+ final bool current;
59+ final String description;
60+ final dynamic district;
61+ final DateTime enddate;
62+ final Extra extra;
63+ final String? leadershipTitle;
64+ final Party party;
65+ final Person person;
66+ final String phone;
67+ final RoleType roleType;
68+ final RoleTypeLabel roleTypeLabel;
69+ final SenatorClass senatorClass;
70+ final SenatorClassLabel senatorClassLabel;
71+ final SenatorRank senatorRank;
72+ final SenatorRankLabel senatorRankLabel;
73+ final DateTime startdate;
74+ final String state;
75+ final Title title;
76+ final RoleTypeLabel titleLong;
77+ final String website;
78+
79+ Object({
80+ required this.caucus,
81+ required this.congressNumbers,
82+ required this.current,
83+ required this.description,
84+ required this.district,
85+ required this.enddate,
86+ required this.extra,
87+ required this.leadershipTitle,
88+ required this.party,
89+ required this.person,
90+ required this.phone,
91+ required this.roleType,
92+ required this.roleTypeLabel,
93+ required this.senatorClass,
94+ required this.senatorClassLabel,
95+ required this.senatorRank,
96+ required this.senatorRankLabel,
97+ required this.startdate,
98+ required this.state,
99+ required this.title,
100+ required this.titleLong,
101+ required this.website,
102+ });
103+
104+ factory Object.fromJson(Map<String, dynamic> json) => Object(
105+ caucus: partyValues.map[json["caucus"]],
106+ congressNumbers: List<int>.from(json["congress_numbers"].map((x) => x)),
107+ current: json["current"],
108+ description: json["description"],
109+ district: json["district"],
110+ enddate: DateTime.parse(json["enddate"]),
111+ extra: Extra.fromJson(json["extra"]),
112+ leadershipTitle: json["leadership_title"],
113+ party: partyValues.map[json["party"]]!,
114+ person: Person.fromJson(json["person"]),
115+ phone: json["phone"],
116+ roleType: roleTypeValues.map[json["role_type"]]!,
117+ roleTypeLabel: roleTypeLabelValues.map[json["role_type_label"]]!,
118+ senatorClass: senatorClassValues.map[json["senator_class"]]!,
119+ senatorClassLabel: senatorClassLabelValues.map[json["senator_class_label"]]!,
120+ senatorRank: senatorRankValues.map[json["senator_rank"]]!,
121+ senatorRankLabel: senatorRankLabelValues.map[json["senator_rank_label"]]!,
122+ startdate: DateTime.parse(json["startdate"]),
123+ state: json["state"],
124+ title: titleValues.map[json["title"]]!,
125+ titleLong: roleTypeLabelValues.map[json["title_long"]]!,
126+ website: json["website"],
127+ );
128+
129+ Map<String, dynamic> toJson() => {
130+ "caucus": partyValues.reverse[caucus],
131+ "congress_numbers": List<dynamic>.from(congressNumbers.map((x) => x)),
132+ "current": current,
133+ "description": description,
134+ "district": district,
135+ "enddate": "${enddate.year.toString().padLeft(4, '0')}-${enddate.month.toString().padLeft(2, '0')}-${enddate.day.toString().padLeft(2, '0')}",
136+ "extra": extra.toJson(),
137+ "leadership_title": leadershipTitle,
138+ "party": partyValues.reverse[party],
139+ "person": person.toJson(),
140+ "phone": phone,
141+ "role_type": roleTypeValues.reverse[roleType],
142+ "role_type_label": roleTypeLabelValues.reverse[roleTypeLabel],
143+ "senator_class": senatorClassValues.reverse[senatorClass],
144+ "senator_class_label": senatorClassLabelValues.reverse[senatorClassLabel],
145+ "senator_rank": senatorRankValues.reverse[senatorRank],
146+ "senator_rank_label": senatorRankLabelValues.reverse[senatorRankLabel],
147+ "startdate": "${startdate.year.toString().padLeft(4, '0')}-${startdate.month.toString().padLeft(2, '0')}-${startdate.day.toString().padLeft(2, '0')}",
148+ "state": state,
149+ "title": titleValues.reverse[title],
150+ "title_long": roleTypeLabelValues.reverse[titleLong],
151+ "website": website,
152+ };
153+}
154+
155+enum Party {
156+ DEMOCRAT,
157+ REPUBLICAN,
158+ INDEPENDENT
159+}
160+
161+final partyValues = EnumValues({
162+ "Democrat": Party.DEMOCRAT,
163+ "Republican": Party.REPUBLICAN,
164+ "Independent": Party.INDEPENDENT
165+});
166+
167+class Extra {
168+ final String address;
169+ final String contactForm;
170+ final String? fax;
171+ final String office;
172+ final String? rssUrl;
173+
174+ Extra({
175+ required this.address,
176+ required this.contactForm,
177+ this.fax,
178+ required this.office,
179+ this.rssUrl,
180+ });
181+
182+ factory Extra.fromJson(Map<String, dynamic> json) => Extra(
183+ address: json["address"],
184+ contactForm: json["contact_form"],
185+ fax: json["fax"],
186+ office: json["office"],
187+ rssUrl: json["rss_url"],
188+ );
189+
190+ Map<String, dynamic> toJson() => {
191+ "address": address,
192+ "contact_form": contactForm,
193+ "fax": fax,
194+ "office": office,
195+ "rss_url": rssUrl,
196+ };
197+}
198+
199+class Person {
200+ final String bioguideid;
201+ final DateTime birthday;
202+ final int cspanid;
203+ final String firstname;
204+ final Gender gender;
205+ final GenderLabel genderLabel;
206+ final String lastname;
207+ final String link;
208+ final String middlename;
209+ final String name;
210+ final Namemod namemod;
211+ final String nickname;
212+ final String osid;
213+ final String pvsid;
214+ final String sortname;
215+ final String? twitterid;
216+ final String? youtubeid;
217+
218+ Person({
219+ required this.bioguideid,
220+ required this.birthday,
221+ required this.cspanid,
222+ required this.firstname,
223+ required this.gender,
224+ required this.genderLabel,
225+ required this.lastname,
226+ required this.link,
227+ required this.middlename,
228+ required this.name,
229+ required this.namemod,
230+ required this.nickname,
231+ required this.osid,
232+ required this.pvsid,
233+ required this.sortname,
234+ required this.twitterid,
235+ required this.youtubeid,
236+ });
237+
238+ factory Person.fromJson(Map<String, dynamic> json) => Person(
239+ bioguideid: json["bioguideid"],
240+ birthday: DateTime.parse(json["birthday"]),
241+ cspanid: json["cspanid"],
242+ firstname: json["firstname"],
243+ gender: genderValues.map[json["gender"]]!,
244+ genderLabel: genderLabelValues.map[json["gender_label"]]!,
245+ lastname: json["lastname"],
246+ link: json["link"],
247+ middlename: json["middlename"],
248+ name: json["name"],
249+ namemod: namemodValues.map[json["namemod"]]!,
250+ nickname: json["nickname"],
251+ osid: json["osid"],
252+ pvsid: json["pvsid"],
253+ sortname: json["sortname"],
254+ twitterid: json["twitterid"],
255+ youtubeid: json["youtubeid"],
256+ );
257+
258+ Map<String, dynamic> toJson() => {
259+ "bioguideid": bioguideid,
260+ "birthday": "${birthday.year.toString().padLeft(4, '0')}-${birthday.month.toString().padLeft(2, '0')}-${birthday.day.toString().padLeft(2, '0')}",
261+ "cspanid": cspanid,
262+ "firstname": firstname,
263+ "gender": genderValues.reverse[gender],
264+ "gender_label": genderLabelValues.reverse[genderLabel],
265+ "lastname": lastname,
266+ "link": link,
267+ "middlename": middlename,
268+ "name": name,
269+ "namemod": namemodValues.reverse[namemod],
270+ "nickname": nickname,
271+ "osid": osid,
272+ "pvsid": pvsid,
273+ "sortname": sortname,
274+ "twitterid": twitterid,
275+ "youtubeid": youtubeid,
276+ };
277+}
278+
279+enum Gender {
280+ FEMALE,
281+ MALE
282+}
283+
284+final genderValues = EnumValues({
285+ "female": Gender.FEMALE,
286+ "male": Gender.MALE
287+});
288+
289+enum GenderLabel {
290+ FEMALE,
291+ MALE
292+}
293+
294+final genderLabelValues = EnumValues({
295+ "Female": GenderLabel.FEMALE,
296+ "Male": GenderLabel.MALE
297+});
298+
299+enum Namemod {
300+ EMPTY,
301+ JR,
302+ III
303+}
304+
305+final namemodValues = EnumValues({
306+ "": Namemod.EMPTY,
307+ "Jr.": Namemod.JR,
308+ "III": Namemod.III
309+});
310+
311+enum RoleType {
312+ SENATOR
313+}
314+
315+final roleTypeValues = EnumValues({
316+ "senator": RoleType.SENATOR
317+});
318+
319+enum RoleTypeLabel {
320+ SENATOR
321+}
322+
323+final roleTypeLabelValues = EnumValues({
324+ "Senator": RoleTypeLabel.SENATOR
325+});
326+
327+enum SenatorClass {
328+ CLASS1,
329+ CLASS2,
330+ CLASS3
331+}
332+
333+final senatorClassValues = EnumValues({
334+ "class1": SenatorClass.CLASS1,
335+ "class2": SenatorClass.CLASS2,
336+ "class3": SenatorClass.CLASS3
337+});
338+
339+enum SenatorClassLabel {
340+ CLASS_1,
341+ CLASS_2,
342+ CLASS_3
343+}
344+
345+final senatorClassLabelValues = EnumValues({
346+ "Class 1": SenatorClassLabel.CLASS_1,
347+ "Class 2": SenatorClassLabel.CLASS_2,
348+ "Class 3": SenatorClassLabel.CLASS_3
349+});
350+
351+enum SenatorRank {
352+ JUNIOR,
353+ SENIOR
354+}
355+
356+final senatorRankValues = EnumValues({
357+ "junior": SenatorRank.JUNIOR,
358+ "senior": SenatorRank.SENIOR
359+});
360+
361+enum SenatorRankLabel {
362+ JUNIOR,
363+ SENIOR
364+}
365+
366+final senatorRankLabelValues = EnumValues({
367+ "Junior": SenatorRankLabel.JUNIOR,
368+ "Senior": SenatorRankLabel.SENIOR
369+});
370+
371+enum Title {
372+ SEN
373+}
374+
375+final titleValues = EnumValues({
376+ "Sen.": Title.SEN
377+});
378+
379+class EnumValues<T> {
380+ Map<String, T> map;
381+ late Map<T, String> reverseMap;
382+
383+ EnumValues(this.map);
384+
385+ Map<T, String> get reverse {
386+ reverseMap = map.map((k, v) => MapEntry(v, k));
387+ return reverseMap;
388+ }
389+}
Test case

test/inputs/schema/bool-string.schema

1 generated file · +49 −0
Aschema-dartdefault / TopLevel.dart+49 −0
@@ -0,0 +1,49 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final List<String?>? arrNullable;
13+ final List<String>? arrOne;
14+ final String? nullable;
15+ final String one;
16+ final String? optional;
17+ final dynamic unionWithBool;
18+ final dynamic unionWithBoolAndEnum;
19+
20+ TopLevel({
21+ this.arrNullable,
22+ this.arrOne,
23+ required this.nullable,
24+ required this.one,
25+ this.optional,
26+ required this.unionWithBool,
27+ required this.unionWithBoolAndEnum,
28+ });
29+
30+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
31+ arrNullable: json["arrNullable"] == null ? null : List<String?>.from(json["arrNullable"]!.map((x) => x)),
32+ arrOne: json["arrOne"] == null ? null : List<String>.from(json["arrOne"]!.map((x) => x)),
33+ nullable: json["nullable"],
34+ one: json["one"],
35+ optional: json["optional"],
36+ unionWithBool: json["unionWithBool"],
37+ unionWithBoolAndEnum: json["unionWithBoolAndEnum"],
38+ );
39+
40+ Map<String, dynamic> toJson() => {
41+ "arrNullable": arrNullable == null ? null : List<dynamic>.from(arrNullable!.map((x) => x)),
42+ "arrOne": arrOne == null ? null : List<dynamic>.from(arrOne!.map((x) => x)),
43+ "nullable": nullable,
44+ "one": one,
45+ "optional": optional,
46+ "unionWithBool": unionWithBool,
47+ "unionWithBoolAndEnum": unionWithBoolAndEnum,
48+ };
49+}
Test case

test/inputs/schema/const-non-string.schema

1 generated file · +61 −0
Aschema-dartdefault / TopLevel.dart+61 −0
@@ -0,0 +1,61 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final int amount;
13+ final bool enabled;
14+ final Kind kind;
15+ final double ratio;
16+ final double version;
17+
18+ TopLevel({
19+ required this.amount,
20+ required this.enabled,
21+ required this.kind,
22+ required this.ratio,
23+ required this.version,
24+ });
25+
26+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
27+ amount: json["amount"],
28+ enabled: json["enabled"],
29+ kind: kindValues.map[json["kind"]]!,
30+ ratio: json["ratio"]?.toDouble(),
31+ version: json["version"]?.toDouble(),
32+ );
33+
34+ Map<String, dynamic> toJson() => {
35+ "amount": amount,
36+ "enabled": enabled,
37+ "kind": kindValues.reverse[kind],
38+ "ratio": ratio,
39+ "version": version,
40+ };
41+}
42+
43+enum Kind {
44+ WIDGET
45+}
46+
47+final kindValues = EnumValues({
48+ "widget": Kind.WIDGET
49+});
50+
51+class EnumValues<T> {
52+ Map<String, T> map;
53+ late Map<T, String> reverseMap;
54+
55+ EnumValues(this.map);
56+
57+ Map<T, String> get reverse {
58+ reverseMap = map.map((k, v) => MapEntry(v, k));
59+ return reverseMap;
60+ }
61+}
Test case

test/inputs/schema/enum-large.schema

1 generated file · +99 −0
Aschema-dartdefault / TopLevel.dart+99 −0
@@ -0,0 +1,99 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final Callsign callsign;
13+ final Priority priority;
14+
15+ TopLevel({
16+ required this.callsign,
17+ required this.priority,
18+ });
19+
20+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
21+ callsign: callsignValues.map[json["callsign"]]!,
22+ priority: priorityValues.map[json["priority"]]!,
23+ );
24+
25+ Map<String, dynamic> toJson() => {
26+ "callsign": callsignValues.reverse[callsign],
27+ "priority": priorityValues.reverse[priority],
28+ };
29+}
30+
31+enum Callsign {
32+ ALPHA,
33+ BRAVO,
34+ CHARLIE,
35+ DELTA,
36+ ECHO,
37+ FOXTROT,
38+ GOLF,
39+ HOTEL,
40+ INDIA,
41+ JULIETT,
42+ KILO,
43+ LIMA,
44+ MIKE,
45+ NOVEMBER,
46+ OSCAR,
47+ PAPA,
48+ QUEBEC,
49+ ROMEO,
50+ SIERRA,
51+ TANGO
52+}
53+
54+final callsignValues = EnumValues({
55+ "alpha": Callsign.ALPHA,
56+ "bravo": Callsign.BRAVO,
57+ "charlie": Callsign.CHARLIE,
58+ "delta": Callsign.DELTA,
59+ "echo": Callsign.ECHO,
60+ "foxtrot": Callsign.FOXTROT,
61+ "golf": Callsign.GOLF,
62+ "hotel": Callsign.HOTEL,
63+ "india": Callsign.INDIA,
64+ "juliett": Callsign.JULIETT,
65+ "kilo": Callsign.KILO,
66+ "lima": Callsign.LIMA,
67+ "mike": Callsign.MIKE,
68+ "november": Callsign.NOVEMBER,
69+ "oscar": Callsign.OSCAR,
70+ "papa": Callsign.PAPA,
71+ "quebec": Callsign.QUEBEC,
72+ "romeo": Callsign.ROMEO,
73+ "sierra": Callsign.SIERRA,
74+ "tango": Callsign.TANGO
75+});
76+
77+enum Priority {
78+ LOW,
79+ MEDIUM,
80+ HIGH
81+}
82+
83+final priorityValues = EnumValues({
84+ "low": Priority.LOW,
85+ "medium": Priority.MEDIUM,
86+ "high": Priority.HIGH
87+});
88+
89+class EnumValues<T> {
90+ Map<String, T> map;
91+ late Map<T, String> reverseMap;
92+
93+ EnumValues(this.map);
94+
95+ Map<T, String> get reverse {
96+ reverseMap = map.map((k, v) => MapEntry(v, k));
97+ return reverseMap;
98+ }
99+}
Test case

test/inputs/schema/enum-with-null.schema

1 generated file · +47 −0
Aschema-dartdefault / TopLevel.dart+47 −0
@@ -0,0 +1,47 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final Enum? topLevelEnum;
13+
14+ TopLevel({
15+ required this.topLevelEnum,
16+ });
17+
18+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
19+ topLevelEnum: enumValues.map[json["enum"]],
20+ );
21+
22+ Map<String, dynamic> toJson() => {
23+ "enum": enumValues.reverse[topLevelEnum],
24+ };
25+}
26+
27+enum Enum {
28+ FOO,
29+ BAR
30+}
31+
32+final enumValues = EnumValues({
33+ "foo": Enum.FOO,
34+ "bar": Enum.BAR
35+});
36+
37+class EnumValues<T> {
38+ Map<String, T> map;
39+ late Map<T, String> reverseMap;
40+
41+ EnumValues(this.map);
42+
43+ Map<T, String> get reverse {
44+ reverseMap = map.map((k, v) => MapEntry(v, k));
45+ return reverseMap;
46+ }
47+}
Test case

test/inputs/schema/enum.schema

1 generated file · +89 −0
Aschema-dartdefault / TopLevel.dart+89 −0
@@ -0,0 +1,89 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final List<dynamic>? arr;
13+ final String? topLevelFor;
14+ final Gve gve;
15+ final Lvc? lvc;
16+ final List<OtherArr>? otherArr;
17+
18+ TopLevel({
19+ this.arr,
20+ this.topLevelFor,
21+ required this.gve,
22+ this.lvc,
23+ this.otherArr,
24+ });
25+
26+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
27+ arr: json["arr"] == null ? null : List<dynamic>.from(json["arr"]!.map((x) => x)),
28+ topLevelFor: json["for"],
29+ gve: gveValues.map[json["gve"]]!,
30+ lvc: lvcValues.map[json["lvc"]],
31+ otherArr: json["otherArr"] == null ? null : List<OtherArr>.from(json["otherArr"]!.map((x) => otherArrValues.map[x]!)),
32+ );
33+
34+ Map<String, dynamic> toJson() => {
35+ "arr": arr == null ? null : List<dynamic>.from(arr!.map((x) => x)),
36+ "for": topLevelFor,
37+ "gve": gveValues.reverse[gve],
38+ "lvc": lvcValues.reverse[lvc],
39+ "otherArr": otherArr == null ? null : List<dynamic>.from(otherArr!.map((x) => otherArrValues.reverse[x])),
40+ };
41+}
42+
43+enum OtherArr {
44+ FOO,
45+ BAR,
46+ IF
47+}
48+
49+final otherArrValues = EnumValues({
50+ "foo": OtherArr.FOO,
51+ "bar": OtherArr.BAR,
52+ "if": OtherArr.IF
53+});
54+
55+enum Gve {
56+ GOOD,
57+ NEUTRAL,
58+ EVIL
59+}
60+
61+final gveValues = EnumValues({
62+ "good": Gve.GOOD,
63+ "neutral": Gve.NEUTRAL,
64+ "evil": Gve.EVIL
65+});
66+
67+enum Lvc {
68+ LAWFUL,
69+ NEUTRAL,
70+ CHAOTIC
71+}
72+
73+final lvcValues = EnumValues({
74+ "lawful": Lvc.LAWFUL,
75+ "neutral": Lvc.NEUTRAL,
76+ "chaotic": Lvc.CHAOTIC
77+});
78+
79+class EnumValues<T> {
80+ Map<String, T> map;
81+ late Map<T, String> reverseMap;
82+
83+ EnumValues(this.map);
84+
85+ Map<T, String> get reverse {
86+ reverseMap = map.map((k, v) => MapEntry(v, k));
87+ return reverseMap;
88+ }
89+}
Test case

test/inputs/schema/integer-string.schema

1 generated file · +49 −0
Aschema-dartdefault / TopLevel.dart+49 −0
@@ -0,0 +1,49 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final List<String?>? arrNullable;
13+ final List<String>? arrOne;
14+ final String? nullable;
15+ final String one;
16+ final String? optional;
17+ final dynamic unionWithInt;
18+ final dynamic unionWithIntAndEnum;
19+
20+ TopLevel({
21+ this.arrNullable,
22+ this.arrOne,
23+ required this.nullable,
24+ required this.one,
25+ this.optional,
26+ required this.unionWithInt,
27+ required this.unionWithIntAndEnum,
28+ });
29+
30+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
31+ arrNullable: json["arrNullable"] == null ? null : List<String?>.from(json["arrNullable"]!.map((x) => x)),
32+ arrOne: json["arrOne"] == null ? null : List<String>.from(json["arrOne"]!.map((x) => x)),
33+ nullable: json["nullable"],
34+ one: json["one"],
35+ optional: json["optional"],
36+ unionWithInt: json["unionWithInt"],
37+ unionWithIntAndEnum: json["unionWithIntAndEnum"],
38+ );
39+
40+ Map<String, dynamic> toJson() => {
41+ "arrNullable": arrNullable == null ? null : List<dynamic>.from(arrNullable!.map((x) => x)),
42+ "arrOne": arrOne == null ? null : List<dynamic>.from(arrOne!.map((x) => x)),
43+ "nullable": nullable,
44+ "one": one,
45+ "optional": optional,
46+ "unionWithInt": unionWithInt,
47+ "unionWithIntAndEnum": unionWithIntAndEnum,
48+ };
49+}
Test case

test/inputs/schema/intersection.schema

1 generated file · +45 −0
Aschema-dartdefault / TopLevel.dart+45 −0
@@ -0,0 +1,45 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final Intersection? intersection;
13+
14+ TopLevel({
15+ this.intersection,
16+ });
17+
18+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
19+ intersection: json["intersection"] == null ? null : Intersection.fromJson(json["intersection"]),
20+ );
21+
22+ Map<String, dynamic> toJson() => {
23+ "intersection": intersection?.toJson(),
24+ };
25+}
26+
27+class Intersection {
28+ final double foo;
29+ final String? bar;
30+
31+ Intersection({
32+ required this.foo,
33+ this.bar,
34+ });
35+
36+ factory Intersection.fromJson(Map<String, dynamic> json) => Intersection(
37+ foo: json["foo"]?.toDouble(),
38+ bar: json["bar"],
39+ );
40+
41+ Map<String, dynamic> toJson() => {
42+ "foo": foo,
43+ "bar": bar,
44+ };
45+}
Test case

test/inputs/schema/keyword-enum.schema

1 generated file · +597 −0
Aschema-dartdefault / TopLevel.dart+597 −0
@@ -0,0 +1,597 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final Enum? topLevelEnum;
13+
14+ TopLevel({
15+ this.topLevelEnum,
16+ });
17+
18+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
19+ topLevelEnum: enumValues.map[json["enum"]],
20+ );
21+
22+ Map<String, dynamic> toJson() => {
23+ "enum": enumValues.reverse[topLevelEnum],
24+ };
25+}
26+
27+enum Enum {
28+ EMPTY,
29+ BOOL,
30+ COMPLEX,
31+ IMAGINERY,
32+ ABSTRACT,
33+ ALIGNAS,
34+ ALIGNOF,
35+ AND,
36+ AND_EQ,
37+ ANY,
38+ ENUM_ANY,
39+ ARRAY,
40+ AS,
41+ ASM,
42+ ASSERT,
43+ ASSOCIATEDTYPE,
44+ ASSOCIATIVITY,
45+ ASYNC,
46+ ATOMIC,
47+ ATOMIC_CANCEL,
48+ ATOMIC_COMMIT,
49+ ATOMIC_NOEXCEPT,
50+ AUTO,
51+ AWAIT,
52+ BASE,
53+ BITAND,
54+ BITOR,
55+ ENUM_BOOL,
56+ PURPLE_BOOL,
57+ BOOLEAN,
58+ BREAK,
59+ BYCOPY,
60+ BYREF,
61+ BYTE,
62+ CASE,
63+ CATCH,
64+ CHAN,
65+ CHAR,
66+ CHAR16_T,
67+ CHAR32_T,
68+ CHECKED,
69+ CLASS,
70+ ENUM_CLASS,
71+ CO_AWAIT,
72+ CO_RETURN,
73+ CO_YIELD,
74+ COMPL,
75+ CONCEPT,
76+ CONSOLE,
77+ CONST,
78+ CONST_CAST,
79+ CONSTEXPR,
80+ CONSTRUCTOR,
81+ CONTINUE,
82+ CONVENIENCE,
83+ CONVERT,
84+ CONVERTER,
85+ DATE,
86+ DATE_PARSE_HANDLING,
87+ DEBUGGER,
88+ DECIMAL,
89+ DECLARE,
90+ DECLTYPE,
91+ DECODE_STRING,
92+ DEF,
93+ DEFAULT,
94+ DEFER,
95+ DEINIT,
96+ DEL,
97+ DELEGATE,
98+ DELETE,
99+ DICT,
100+ DICTIONARY,
101+ DID_SET,
102+ DO,
103+ DOUBLE,
104+ DYNAMIC,
105+ DYNAMIC_CAST,
106+ ELIF,
107+ ELSE,
108+ ENCODE_QUICK_TYPE,
109+ ENUM,
110+ EVENT,
111+ EXCEPT,
112+ EXCEPTION,
113+ EXPLICIT,
114+ EXPORT,
115+ EXPOSING,
116+ EXTENDS,
117+ EXTENSION,
118+ EXTERN,
119+ FALLTHROUGH,
120+ FALSE,
121+ ENUM_FALSE,
122+ FILEPRIVATE,
123+ FINAL,
124+ FINALLY,
125+ FIXED,
126+ FLOAT,
127+ FOR,
128+ FOREACH,
129+ FRIEND,
130+ FROM,
131+ FROM_JSON,
132+ FUNC,
133+ FUNCTION,
134+ GET,
135+ GLOBAL,
136+ GO,
137+ GOTO,
138+ GUARD,
139+ HAS_OWN_PROPERTY,
140+ ID,
141+ IF,
142+ IMP,
143+ IMPLEMENTS,
144+ IMPLICIT,
145+ IMPORT,
146+ IN,
147+ INDIRECT,
148+ INFIX,
149+ INIT,
150+ INLINE,
151+ INOUT,
152+ INSTANCEOF,
153+ INT,
154+ INTERFACE,
155+ INTERNAL,
156+ ITERABLE,
157+ IS,
158+ JDEC,
159+ JENC,
160+ JPIPE,
161+ JSON,
162+ JSON_CONVERTER,
163+ JSON_SERIALIZER,
164+ JSON_TOKEN,
165+ JSON_WRITER,
166+ LAMBDA,
167+ LAZY,
168+ LEFT,
169+ LET,
170+ LIST,
171+ LOCK,
172+ LONG,
173+ MAP,
174+ METADATA_PROPERTY_HANDLING,
175+ MODULE,
176+ MUTABLE,
177+ MUTATING,
178+ NAMESPACE,
179+ NATIVE,
180+ NEW,
181+ NEWTONSOFT,
182+ NIL,
183+ NO,
184+ NOEXCEPT,
185+ NONATOMIC,
186+ NONE,
187+ ENUM_NONE,
188+ NONLOCAL,
189+ NONMUTATING,
190+ NOT,
191+ NOT_EQ,
192+ NS_STRING,
193+ NULL,
194+ ENUM_NULL,
195+ NULLPTR,
196+ NUMBER,
197+ OBJECT,
198+ OF,
199+ ONEWAY,
200+ OPEN,
201+ OPERATOR,
202+ OPTIONAL,
203+ OR,
204+ OR_EQ,
205+ OUT,
206+ OVERRIDE,
207+ PACKAGE,
208+ PARAMS,
209+ PASS,
210+ PORT,
211+ POSTFIX,
212+ PRECEDENCE,
213+ PREFIX,
214+ PRINT,
215+ PRINTF,
216+ PRIVATE,
217+ PROTECTED,
218+ PROTOCOL,
219+ ENUM_PROTOCOL,
220+ PUBLIC,
221+ QUICKTYPE,
222+ RAISE,
223+ RANGE,
224+ READONLY,
225+ REF,
226+ REGISTER,
227+ REINTERPRET_CAST,
228+ REPEAT,
229+ REQUIRE,
230+ REQUIRED,
231+ REQUIRES,
232+ RESTRICT,
233+ RETAIN,
234+ RETHROWS,
235+ RETURN,
236+ RIGHT,
237+ SBYTE,
238+ SEALED,
239+ SEL,
240+ SELECT,
241+ SELF,
242+ ENUM_SELF,
243+ SERIALIZE,
244+ SET,
245+ SHORT,
246+ SIGNED,
247+ SIZEOF,
248+ STACKALLOC,
249+ STATIC,
250+ STATIC_ASSERT,
251+ STATIC_CAST,
252+ STRICTFP,
253+ STRING,
254+ STRUCT,
255+ SUBSCRIPT,
256+ SUPER,
257+ SWITCH,
258+ SYMBOL,
259+ SYNCHRONIZED,
260+ SYSTEM,
261+ TEMPLATE,
262+ THEN,
263+ THIS,
264+ THREAD_LOCAL,
265+ THROW,
266+ THROWS,
267+ TO_JSON,
268+ TOP_LEVEL,
269+ TRANSIENT,
270+ TRUE,
271+ ENUM_TRUE,
272+ TRY,
273+ TYPE,
274+ ENUM_TYPE,
275+ TYPEALIAS,
276+ TYPEDEF,
277+ TYPEID,
278+ TYPENAME,
279+ TYPEOF,
280+ UINT,
281+ ULONG,
282+ UNCHECKED,
283+ UNDEFINED,
284+ UNION,
285+ UNOWNED,
286+ UNSAFE,
287+ UNSIGNED,
288+ USHORT,
289+ USING,
290+ VAR,
291+ VIRTUAL,
292+ VOID,
293+ VOLATILE,
294+ WCHAR_T,
295+ WEAK,
296+ WHERE,
297+ WHILE,
298+ WILL_SET,
299+ WITH,
300+ XOR,
301+ XOR_EQ,
302+ YES,
303+ YIELD,
304+ DUMMY
305+}
306+
307+final enumValues = EnumValues({
308+ "_": Enum.EMPTY,
309+ "_Bool": Enum.BOOL,
310+ "_Complex": Enum.COMPLEX,
311+ "_Imaginery": Enum.IMAGINERY,
312+ "abstract": Enum.ABSTRACT,
313+ "alignas": Enum.ALIGNAS,
314+ "alignof": Enum.ALIGNOF,
315+ "and": Enum.AND,
316+ "and_eq": Enum.AND_EQ,
317+ "any": Enum.ANY,
318+ "Any": Enum.ENUM_ANY,
319+ "array": Enum.ARRAY,
320+ "as": Enum.AS,
321+ "asm": Enum.ASM,
322+ "assert": Enum.ASSERT,
323+ "associatedtype": Enum.ASSOCIATEDTYPE,
324+ "associativity": Enum.ASSOCIATIVITY,
325+ "async": Enum.ASYNC,
326+ "atomic": Enum.ATOMIC,
327+ "atomic_cancel": Enum.ATOMIC_CANCEL,
328+ "atomic_commit": Enum.ATOMIC_COMMIT,
329+ "atomic_noexcept": Enum.ATOMIC_NOEXCEPT,
330+ "auto": Enum.AUTO,
331+ "await": Enum.AWAIT,
332+ "base": Enum.BASE,
333+ "bitand": Enum.BITAND,
334+ "bitor": Enum.BITOR,
335+ "BOOL": Enum.ENUM_BOOL,
336+ "bool": Enum.PURPLE_BOOL,
337+ "boolean": Enum.BOOLEAN,
338+ "break": Enum.BREAK,
339+ "bycopy": Enum.BYCOPY,
340+ "byref": Enum.BYREF,
341+ "byte": Enum.BYTE,
342+ "case": Enum.CASE,
343+ "catch": Enum.CATCH,
344+ "chan": Enum.CHAN,
345+ "char": Enum.CHAR,
346+ "char16_t": Enum.CHAR16_T,
347+ "char32_t": Enum.CHAR32_T,
348+ "checked": Enum.CHECKED,
349+ "class": Enum.CLASS,
350+ "Class": Enum.ENUM_CLASS,
351+ "co_await": Enum.CO_AWAIT,
352+ "co_return": Enum.CO_RETURN,
353+ "co_yield": Enum.CO_YIELD,
354+ "compl": Enum.COMPL,
355+ "concept": Enum.CONCEPT,
356+ "console": Enum.CONSOLE,
357+ "const": Enum.CONST,
358+ "const_cast": Enum.CONST_CAST,
359+ "constexpr": Enum.CONSTEXPR,
360+ "constructor": Enum.CONSTRUCTOR,
361+ "continue": Enum.CONTINUE,
362+ "convenience": Enum.CONVENIENCE,
363+ "convert": Enum.CONVERT,
364+ "converter": Enum.CONVERTER,
365+ "date": Enum.DATE,
366+ "date_parse_handling": Enum.DATE_PARSE_HANDLING,
367+ "debugger": Enum.DEBUGGER,
368+ "decimal": Enum.DECIMAL,
369+ "declare": Enum.DECLARE,
370+ "decltype": Enum.DECLTYPE,
371+ "decode_string": Enum.DECODE_STRING,
372+ "def": Enum.DEF,
373+ "default": Enum.DEFAULT,
374+ "defer": Enum.DEFER,
375+ "deinit": Enum.DEINIT,
376+ "del": Enum.DEL,
377+ "delegate": Enum.DELEGATE,
378+ "delete": Enum.DELETE,
379+ "dict": Enum.DICT,
380+ "dictionary": Enum.DICTIONARY,
381+ "didSet": Enum.DID_SET,
382+ "do": Enum.DO,
383+ "double": Enum.DOUBLE,
384+ "dynamic": Enum.DYNAMIC,
385+ "dynamic_cast": Enum.DYNAMIC_CAST,
386+ "elif": Enum.ELIF,
387+ "else": Enum.ELSE,
388+ "encode_quick_type": Enum.ENCODE_QUICK_TYPE,
389+ "enum": Enum.ENUM,
390+ "event": Enum.EVENT,
391+ "except": Enum.EXCEPT,
392+ "exception": Enum.EXCEPTION,
393+ "explicit": Enum.EXPLICIT,
394+ "export": Enum.EXPORT,
395+ "exposing": Enum.EXPOSING,
396+ "extends": Enum.EXTENDS,
397+ "extension": Enum.EXTENSION,
398+ "extern": Enum.EXTERN,
399+ "fallthrough": Enum.FALLTHROUGH,
400+ "false": Enum.FALSE,
401+ "False": Enum.ENUM_FALSE,
402+ "fileprivate": Enum.FILEPRIVATE,
403+ "final": Enum.FINAL,
404+ "finally": Enum.FINALLY,
405+ "fixed": Enum.FIXED,
406+ "float": Enum.FLOAT,
407+ "for": Enum.FOR,
408+ "foreach": Enum.FOREACH,
409+ "friend": Enum.FRIEND,
410+ "from": Enum.FROM,
411+ "from_json": Enum.FROM_JSON,
412+ "func": Enum.FUNC,
413+ "function": Enum.FUNCTION,
414+ "get": Enum.GET,
415+ "global": Enum.GLOBAL,
416+ "go": Enum.GO,
417+ "goto": Enum.GOTO,
418+ "guard": Enum.GUARD,
419+ "hasOwnProperty": Enum.HAS_OWN_PROPERTY,
420+ "id": Enum.ID,
421+ "if": Enum.IF,
422+ "IMP": Enum.IMP,
423+ "implements": Enum.IMPLEMENTS,
424+ "implicit": Enum.IMPLICIT,
425+ "import": Enum.IMPORT,
426+ "in": Enum.IN,
427+ "indirect": Enum.INDIRECT,
428+ "infix": Enum.INFIX,
429+ "init": Enum.INIT,
430+ "inline": Enum.INLINE,
431+ "inout": Enum.INOUT,
432+ "instanceof": Enum.INSTANCEOF,
433+ "int": Enum.INT,
434+ "interface": Enum.INTERFACE,
435+ "internal": Enum.INTERNAL,
436+ "iterable": Enum.ITERABLE,
437+ "is": Enum.IS,
438+ "jdec": Enum.JDEC,
439+ "jenc": Enum.JENC,
440+ "jpipe": Enum.JPIPE,
441+ "json": Enum.JSON,
442+ "json_converter": Enum.JSON_CONVERTER,
443+ "json_serializer": Enum.JSON_SERIALIZER,
444+ "json_token": Enum.JSON_TOKEN,
445+ "json_writer": Enum.JSON_WRITER,
446+ "lambda": Enum.LAMBDA,
447+ "lazy": Enum.LAZY,
448+ "left": Enum.LEFT,
449+ "let": Enum.LET,
450+ "list": Enum.LIST,
451+ "lock": Enum.LOCK,
452+ "long": Enum.LONG,
453+ "map": Enum.MAP,
454+ "metadata_property_handling": Enum.METADATA_PROPERTY_HANDLING,
455+ "module": Enum.MODULE,
456+ "mutable": Enum.MUTABLE,
457+ "mutating": Enum.MUTATING,
458+ "namespace": Enum.NAMESPACE,
459+ "native": Enum.NATIVE,
460+ "new": Enum.NEW,
461+ "newtonsoft": Enum.NEWTONSOFT,
462+ "nil": Enum.NIL,
463+ "NO": Enum.NO,
464+ "noexcept": Enum.NOEXCEPT,
465+ "nonatomic": Enum.NONATOMIC,
466+ "none": Enum.NONE,
467+ "None": Enum.ENUM_NONE,
468+ "nonlocal": Enum.NONLOCAL,
469+ "nonmutating": Enum.NONMUTATING,
470+ "not": Enum.NOT,
471+ "not_eq": Enum.NOT_EQ,
472+ "NSString": Enum.NS_STRING,
473+ "NULL": Enum.NULL,
474+ "null": Enum.ENUM_NULL,
475+ "nullptr": Enum.NULLPTR,
476+ "number": Enum.NUMBER,
477+ "object": Enum.OBJECT,
478+ "of": Enum.OF,
479+ "oneway": Enum.ONEWAY,
480+ "open": Enum.OPEN,
481+ "operator": Enum.OPERATOR,
482+ "optional": Enum.OPTIONAL,
483+ "or": Enum.OR,
484+ "or_eq": Enum.OR_EQ,
485+ "out": Enum.OUT,
486+ "override": Enum.OVERRIDE,
487+ "package": Enum.PACKAGE,
488+ "params": Enum.PARAMS,
489+ "pass": Enum.PASS,
490+ "port": Enum.PORT,
491+ "postfix": Enum.POSTFIX,
492+ "precedence": Enum.PRECEDENCE,
493+ "prefix": Enum.PREFIX,
494+ "print": Enum.PRINT,
495+ "printf": Enum.PRINTF,
496+ "private": Enum.PRIVATE,
497+ "protected": Enum.PROTECTED,
498+ "Protocol": Enum.PROTOCOL,
499+ "protocol": Enum.ENUM_PROTOCOL,
500+ "public": Enum.PUBLIC,
501+ "quicktype": Enum.QUICKTYPE,
502+ "raise": Enum.RAISE,
503+ "range": Enum.RANGE,
504+ "readonly": Enum.READONLY,
505+ "ref": Enum.REF,
506+ "register": Enum.REGISTER,
507+ "reinterpret_cast": Enum.REINTERPRET_CAST,
508+ "repeat": Enum.REPEAT,
509+ "require": Enum.REQUIRE,
510+ "required": Enum.REQUIRED,
511+ "requires": Enum.REQUIRES,
512+ "restrict": Enum.RESTRICT,
513+ "retain": Enum.RETAIN,
514+ "rethrows": Enum.RETHROWS,
515+ "return": Enum.RETURN,
516+ "right": Enum.RIGHT,
517+ "sbyte": Enum.SBYTE,
518+ "sealed": Enum.SEALED,
519+ "SEL": Enum.SEL,
520+ "select": Enum.SELECT,
521+ "Self": Enum.SELF,
522+ "self": Enum.ENUM_SELF,
523+ "serialize": Enum.SERIALIZE,
524+ "set": Enum.SET,
525+ "short": Enum.SHORT,
526+ "signed": Enum.SIGNED,
527+ "sizeof": Enum.SIZEOF,
528+ "stackalloc": Enum.STACKALLOC,
529+ "static": Enum.STATIC,
530+ "static_assert": Enum.STATIC_ASSERT,
531+ "static_cast": Enum.STATIC_CAST,
532+ "strictfp": Enum.STRICTFP,
533+ "string": Enum.STRING,
534+ "struct": Enum.STRUCT,
535+ "subscript": Enum.SUBSCRIPT,
536+ "super": Enum.SUPER,
537+ "switch": Enum.SWITCH,
538+ "symbol": Enum.SYMBOL,
539+ "synchronized": Enum.SYNCHRONIZED,
540+ "system": Enum.SYSTEM,
541+ "template": Enum.TEMPLATE,
542+ "then": Enum.THEN,
543+ "this": Enum.THIS,
544+ "thread_local": Enum.THREAD_LOCAL,
545+ "throw": Enum.THROW,
546+ "throws": Enum.THROWS,
547+ "to_json": Enum.TO_JSON,
548+ "top_level": Enum.TOP_LEVEL,
549+ "transient": Enum.TRANSIENT,
550+ "True": Enum.TRUE,
551+ "true": Enum.ENUM_TRUE,
552+ "try": Enum.TRY,
553+ "Type": Enum.TYPE,
554+ "type": Enum.ENUM_TYPE,
555+ "typealias": Enum.TYPEALIAS,
556+ "typedef": Enum.TYPEDEF,
557+ "typeid": Enum.TYPEID,
558+ "typename": Enum.TYPENAME,
559+ "typeof": Enum.TYPEOF,
560+ "uint": Enum.UINT,
561+ "ulong": Enum.ULONG,
562+ "unchecked": Enum.UNCHECKED,
563+ "undefined": Enum.UNDEFINED,
564+ "union": Enum.UNION,
565+ "unowned": Enum.UNOWNED,
566+ "unsafe": Enum.UNSAFE,
567+ "unsigned": Enum.UNSIGNED,
568+ "ushort": Enum.USHORT,
569+ "using": Enum.USING,
570+ "var": Enum.VAR,
571+ "virtual": Enum.VIRTUAL,
572+ "void": Enum.VOID,
573+ "volatile": Enum.VOLATILE,
574+ "wchar_t": Enum.WCHAR_T,
575+ "weak": Enum.WEAK,
576+ "where": Enum.WHERE,
577+ "while": Enum.WHILE,
578+ "willSet": Enum.WILL_SET,
579+ "with": Enum.WITH,
580+ "xor": Enum.XOR,
581+ "xor_eq": Enum.XOR_EQ,
582+ "YES": Enum.YES,
583+ "yield": Enum.YIELD,
584+ "dummy": Enum.DUMMY
585+});
586+
587+class EnumValues<T> {
588+ Map<String, T> map;
589+ late Map<T, String> reverseMap;
590+
591+ EnumValues(this.map);
592+
593+ Map<T, String> get reverse {
594+ reverseMap = map.map((k, v) => MapEntry(v, k));
595+ return reverseMap;
596+ }
597+}
Test case

test/inputs/schema/list.schema

1 generated file · +27 −0
Aschema-dartdefault / TopLevel.dart+27 −0
@@ -0,0 +1,27 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+
12+///A recursive class type
13+class TopLevel {
14+ final TopLevel? next;
15+
16+ TopLevel({
17+ this.next,
18+ });
19+
20+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
21+ next: json["next"] == null ? null : TopLevel.fromJson(json["next"]),
22+ );
23+
24+ Map<String, dynamic> toJson() => {
25+ "next": next?.toJson(),
26+ };
27+}
Test case

test/inputs/schema/mutually-recursive.schema

1 generated file · +41 −0
Aschema-dartdefault / TopLevel.dart+41 −0
@@ -0,0 +1,41 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class Bar {
12+ final dynamic foo;
13+
14+ Bar({
15+ required this.foo,
16+ });
17+
18+ factory Bar.fromJson(Map<String, dynamic> json) => Bar(
19+ foo: json["foo"],
20+ );
21+
22+ Map<String, dynamic> toJson() => {
23+ "foo": foo,
24+ };
25+}
26+
27+class TopLevel {
28+ final Bar? bar;
29+
30+ TopLevel({
31+ this.bar,
32+ });
33+
34+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
35+ bar: json["bar"] == null ? null : Bar.fromJson(json["bar"]),
36+ );
37+
38+ Map<String, dynamic> toJson() => {
39+ "bar": bar?.toJson(),
40+ };
41+}
Test case

test/inputs/schema/postman-collection.schema

1 generated file · +51 −0
Aschema-dartdefault / TopLevel.dart+51 −0
@@ -0,0 +1,51 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+
12+///Postman collection
13+class TopLevel {
14+ final List<TopLevel>? item;
15+ final String? name;
16+ final List<Response>? response;
17+
18+ TopLevel({
19+ this.item,
20+ this.name,
21+ this.response,
22+ });
23+
24+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
25+ item: json["item"] == null ? null : List<TopLevel>.from(json["item"]!.map((x) => TopLevel.fromJson(x))),
26+ name: json["name"],
27+ response: json["response"] == null ? null : List<Response>.from(json["response"]!.map((x) => Response.fromJson(x))),
28+ );
29+
30+ Map<String, dynamic> toJson() => {
31+ "item": item == null ? null : List<dynamic>.from(item!.map((x) => x.toJson())),
32+ "name": name,
33+ "response": response == null ? null : List<dynamic>.from(response!.map((x) => x.toJson())),
34+ };
35+}
36+
37+class Response {
38+ final String? body;
39+
40+ Response({
41+ this.body,
42+ });
43+
44+ factory Response.fromJson(Map<String, dynamic> json) => Response(
45+ body: json["body"],
46+ );
47+
48+ Map<String, dynamic> toJson() => {
49+ "body": body,
50+ };
51+}
Test case

test/inputs/schema/ref-remote.schema

1 generated file · +27 −0
Aschema-dartdefault / TopLevel.dart+27 −0
@@ -0,0 +1,27 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+
12+///A recursive class type
13+class TopLevel {
14+ final TopLevel? next;
15+
16+ TopLevel({
17+ this.next,
18+ });
19+
20+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
21+ next: json["next"] == null ? null : TopLevel.fromJson(json["next"]),
22+ );
23+
24+ Map<String, dynamic> toJson() => {
25+ "next": next?.toJson(),
26+ };
27+}
Test case

test/inputs/schema/simple-ref.schema

1 generated file · +27 −0
Aschema-dartdefault / TopLevel.dart+27 −0
@@ -0,0 +1,27 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+
12+///A recursive class type
13+class TopLevel {
14+ final TopLevel? next;
15+
16+ TopLevel({
17+ this.next,
18+ });
19+
20+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
21+ next: json["next"] == null ? null : TopLevel.fromJson(json["next"]),
22+ );
23+
24+ Map<String, dynamic> toJson() => {
25+ "next": next?.toJson(),
26+ };
27+}
Test case

test/inputs/schema/uuid.schema

1 generated file · +45 −0
Aschema-dartdefault / TopLevel.dart+45 −0
@@ -0,0 +1,45 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final List<String?>? arrNullable;
13+ final List<String>? arrOne;
14+ final String? nullable;
15+ final String one;
16+ final String? optional;
17+ final String unionWithEnum;
18+
19+ TopLevel({
20+ this.arrNullable,
21+ this.arrOne,
22+ required this.nullable,
23+ required this.one,
24+ this.optional,
25+ required this.unionWithEnum,
26+ });
27+
28+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
29+ arrNullable: json["arrNullable"] == null ? null : List<String?>.from(json["arrNullable"]!.map((x) => x)),
30+ arrOne: json["arrOne"] == null ? null : List<String>.from(json["arrOne"]!.map((x) => x)),
31+ nullable: json["nullable"],
32+ one: json["one"],
33+ optional: json["optional"],
34+ unionWithEnum: json["unionWithEnum"],
35+ );
36+
37+ Map<String, dynamic> toJson() => {
38+ "arrNullable": arrNullable == null ? null : List<dynamic>.from(arrNullable!.map((x) => x)),
39+ "arrOne": arrOne == null ? null : List<dynamic>.from(arrOne!.map((x) => x)),
40+ "nullable": nullable,
41+ "one": one,
42+ "optional": optional,
43+ "unionWithEnum": unionWithEnum,
44+ };
45+}
No generated files match these filters.