diff --git a/head/dart/test/inputs/json/priority/bug427.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/bug427.json/default/TopLevel.dart new file mode 100644 index 0000000..30d3770 --- /dev/null +++ b/head/dart/test/inputs/json/priority/bug427.json/default/TopLevel.dart @@ -0,0 +1,2361 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + final List children; + final GetSignatureFlags flags; + final List groups; + final int id; + final int kind; + final String name; + + TopLevel({ + required this.children, + required this.flags, + required this.groups, + required this.id, + required this.kind, + required this.name, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + children: List.from(json["children"].map((x) => TopLevelChild.fromJson(x))), + flags: GetSignatureFlags.fromJson(json["flags"]), + groups: List.from(json["groups"].map((x) => Group.fromJson(x))), + id: json["id"], + kind: json["kind"], + name: json["name"], + ); + + Map toJson() => { + "children": List.from(children.map((x) => x.toJson())), + "flags": flags.toJson(), + "groups": List.from(groups.map((x) => x.toJson())), + "id": id, + "kind": kind, + "name": name, + }; +} + +class TopLevelChild { + final List children; + final IndecentComment? comment; + final PurpleFlags flags; + final List groups; + final int id; + final int kind; + final TentacledKindString kindString; + final String name; + final String originalName; + final List sources; + + TopLevelChild({ + required this.children, + this.comment, + required this.flags, + required this.groups, + required this.id, + required this.kind, + required this.kindString, + required this.name, + required this.originalName, + required this.sources, + }); + + factory TopLevelChild.fromJson(Map json) => TopLevelChild( + children: List.from(json["children"].map((x) => PurpleChild.fromJson(x))), + comment: json["comment"] == null ? null : IndecentComment.fromJson(json["comment"]), + flags: PurpleFlags.fromJson(json["flags"]), + groups: List.from(json["groups"].map((x) => Group.fromJson(x))), + id: json["id"], + kind: json["kind"], + kindString: tentacledKindStringValues.map[json["kindString"]]!, + name: json["name"], + originalName: json["originalName"], + sources: List.from(json["sources"].map((x) => Source.fromJson(x))), + ); + + Map toJson() => { + "children": List.from(children.map((x) => x.toJson())), + "comment": comment?.toJson(), + "flags": flags.toJson(), + "groups": List.from(groups.map((x) => x.toJson())), + "id": id, + "kind": kind, + "kindString": tentacledKindStringValues.reverse[kindString], + "name": name, + "originalName": originalName, + "sources": List.from(sources.map((x) => x.toJson())), + }; +} + +class PurpleChild { + final List? children; + final StickyComment? comment; + final String? defaultValue; + final List? extendedBy; + final List? extendedTypes; + final IndecentFlags flags; + final List? groups; + final int id; + final List? implementedBy; + final List? implementedTypes; + final int kind; + final FluffyKindString kindString; + final String name; + final List? signatures; + final List sources; + final MagentaType? type; + final List? typeParameter; + + PurpleChild({ + this.children, + this.comment, + this.defaultValue, + this.extendedBy, + this.extendedTypes, + required this.flags, + this.groups, + required this.id, + this.implementedBy, + this.implementedTypes, + required this.kind, + required this.kindString, + required this.name, + this.signatures, + required this.sources, + this.type, + this.typeParameter, + }); + + factory PurpleChild.fromJson(Map json) => PurpleChild( + children: json["children"] == null ? null : List.from(json["children"]!.map((x) => FluffyChild.fromJson(x))), + comment: json["comment"] == null ? null : StickyComment.fromJson(json["comment"]), + defaultValue: json["defaultValue"], + extendedBy: json["extendedBy"] == null ? null : List.from(json["extendedBy"]!.map((x) => ExtendedBy.fromJson(x))), + extendedTypes: json["extendedTypes"] == null ? null : List.from(json["extendedTypes"]!.map((x) => ExtendedBy.fromJson(x))), + flags: IndecentFlags.fromJson(json["flags"]), + groups: json["groups"] == null ? null : List.from(json["groups"]!.map((x) => Group.fromJson(x))), + id: json["id"], + implementedBy: json["implementedBy"] == null ? null : List.from(json["implementedBy"]!.map((x) => ExtendedBy.fromJson(x))), + implementedTypes: json["implementedTypes"] == null ? null : List.from(json["implementedTypes"]!.map((x) => ExtendedBy.fromJson(x))), + kind: json["kind"], + kindString: fluffyKindStringValues.map[json["kindString"]]!, + name: json["name"], + signatures: json["signatures"] == null ? null : List.from(json["signatures"]!.map((x) => StickySignature.fromJson(x))), + sources: List.from(json["sources"].map((x) => Source.fromJson(x))), + type: json["type"] == null ? null : MagentaType.fromJson(json["type"]), + typeParameter: json["typeParameter"] == null ? null : List.from(json["typeParameter"]!.map((x) => TypeParameter.fromJson(x))), + ); + + Map toJson() => { + "children": children == null ? null : List.from(children!.map((x) => x.toJson())), + "comment": comment?.toJson(), + "defaultValue": defaultValue, + "extendedBy": extendedBy == null ? null : List.from(extendedBy!.map((x) => x.toJson())), + "extendedTypes": extendedTypes == null ? null : List.from(extendedTypes!.map((x) => x.toJson())), + "flags": flags.toJson(), + "groups": groups == null ? null : List.from(groups!.map((x) => x.toJson())), + "id": id, + "implementedBy": implementedBy == null ? null : List.from(implementedBy!.map((x) => x.toJson())), + "implementedTypes": implementedTypes == null ? null : List.from(implementedTypes!.map((x) => x.toJson())), + "kind": kind, + "kindString": fluffyKindStringValues.reverse[kindString], + "name": name, + "signatures": signatures == null ? null : List.from(signatures!.map((x) => x.toJson())), + "sources": List.from(sources.map((x) => x.toJson())), + "type": type?.toJson(), + "typeParameter": typeParameter == null ? null : List.from(typeParameter!.map((x) => x.toJson())), + }; +} + +class FluffyChild { + final List? children; + final StickyComment? comment; + final String? defaultValue; + final StickyFlags flags; + final GetSignature? getSignature; + final List? groups; + final int id; + final ExtendedBy? implementationOf; + final ExtendedBy? inheritedFrom; + final int kind; + final PurpleKindString kindString; + final String name; + final ExtendedBy? overwrites; + final GetSignature? setSignature; + final List? signatures; + final List sources; + final IndigoType? type; + + FluffyChild({ + this.children, + this.comment, + this.defaultValue, + required this.flags, + this.getSignature, + this.groups, + required this.id, + this.implementationOf, + this.inheritedFrom, + required this.kind, + required this.kindString, + required this.name, + this.overwrites, + this.setSignature, + this.signatures, + required this.sources, + this.type, + }); + + factory FluffyChild.fromJson(Map json) => FluffyChild( + children: json["children"] == null ? null : List.from(json["children"]!.map((x) => TentacledChild.fromJson(x))), + comment: json["comment"] == null ? null : StickyComment.fromJson(json["comment"]), + defaultValue: json["defaultValue"], + flags: StickyFlags.fromJson(json["flags"]), + getSignature: json["getSignature"] == null ? null : GetSignature.fromJson(json["getSignature"]), + groups: json["groups"] == null ? null : List.from(json["groups"]!.map((x) => Group.fromJson(x))), + id: json["id"], + implementationOf: json["implementationOf"] == null ? null : ExtendedBy.fromJson(json["implementationOf"]), + inheritedFrom: json["inheritedFrom"] == null ? null : ExtendedBy.fromJson(json["inheritedFrom"]), + kind: json["kind"], + kindString: purpleKindStringValues.map[json["kindString"]]!, + name: json["name"], + overwrites: json["overwrites"] == null ? null : ExtendedBy.fromJson(json["overwrites"]), + setSignature: json["setSignature"] == null ? null : GetSignature.fromJson(json["setSignature"]), + signatures: json["signatures"] == null ? null : List.from(json["signatures"]!.map((x) => FluffySignature.fromJson(x))), + sources: List.from(json["sources"].map((x) => Source.fromJson(x))), + type: json["type"] == null ? null : IndigoType.fromJson(json["type"]), + ); + + Map toJson() => { + "children": children == null ? null : List.from(children!.map((x) => x.toJson())), + "comment": comment?.toJson(), + "defaultValue": defaultValue, + "flags": flags.toJson(), + "getSignature": getSignature?.toJson(), + "groups": groups == null ? null : List.from(groups!.map((x) => x.toJson())), + "id": id, + "implementationOf": implementationOf?.toJson(), + "inheritedFrom": inheritedFrom?.toJson(), + "kind": kind, + "kindString": purpleKindStringValues.reverse[kindString], + "name": name, + "overwrites": overwrites?.toJson(), + "setSignature": setSignature?.toJson(), + "signatures": signatures == null ? null : List.from(signatures!.map((x) => x.toJson())), + "sources": List.from(sources.map((x) => x.toJson())), + "type": type?.toJson(), + }; +} + +class TentacledChild { + final PurpleComment? comment; + final String? defaultValue; + final PurpleFlags flags; + final int id; + final int kind; + final PurpleKindString kindString; + final String name; + final List? signatures; + final List sources; + final TypeElement? type; + + TentacledChild({ + this.comment, + this.defaultValue, + required this.flags, + required this.id, + required this.kind, + required this.kindString, + required this.name, + this.signatures, + required this.sources, + this.type, + }); + + factory TentacledChild.fromJson(Map json) => TentacledChild( + comment: json["comment"] == null ? null : PurpleComment.fromJson(json["comment"]), + defaultValue: json["defaultValue"], + flags: PurpleFlags.fromJson(json["flags"]), + id: json["id"], + kind: json["kind"], + kindString: purpleKindStringValues.map[json["kindString"]]!, + name: json["name"], + signatures: json["signatures"] == null ? null : List.from(json["signatures"]!.map((x) => PurpleSignature.fromJson(x))), + sources: List.from(json["sources"].map((x) => Source.fromJson(x))), + type: json["type"] == null ? null : TypeElement.fromJson(json["type"]), + ); + + Map toJson() => { + "comment": comment?.toJson(), + "defaultValue": defaultValue, + "flags": flags.toJson(), + "id": id, + "kind": kind, + "kindString": purpleKindStringValues.reverse[kindString], + "name": name, + "signatures": signatures == null ? null : List.from(signatures!.map((x) => x.toJson())), + "sources": List.from(sources.map((x) => x.toJson())), + "type": type?.toJson(), + }; +} + +class PurpleComment { + final String shortText; + + PurpleComment({ + required this.shortText, + }); + + factory PurpleComment.fromJson(Map json) => PurpleComment( + shortText: json["shortText"], + ); + + Map toJson() => { + "shortText": shortText, + }; +} + +class PurpleFlags { + final bool? isExported; + + PurpleFlags({ + this.isExported, + }); + + factory PurpleFlags.fromJson(Map json) => PurpleFlags( + isExported: json["isExported"], + ); + + Map toJson() => { + "isExported": isExported, + }; +} + +enum PurpleKindString { + VARIABLE, + FUNCTION, + PROPERTY, + METHOD, + CONSTRUCTOR, + ACCESSOR, + ENUMERATION_MEMBER, + MODULE, + OBJECT_LITERAL +} + +final purpleKindStringValues = EnumValues({ + "Variable": PurpleKindString.VARIABLE, + "Function": PurpleKindString.FUNCTION, + "Property": PurpleKindString.PROPERTY, + "Method": PurpleKindString.METHOD, + "Constructor": PurpleKindString.CONSTRUCTOR, + "Accessor": PurpleKindString.ACCESSOR, + "Enumeration member": PurpleKindString.ENUMERATION_MEMBER, + "Module": PurpleKindString.MODULE, + "Object literal": PurpleKindString.OBJECT_LITERAL +}); + +class PurpleSignature { + final PurpleComment? comment; + final GetSignatureFlags flags; + final int id; + final int kind; + final SignatureKindString kindString; + final String name; + final List parameters; + final TentacledType type; + + PurpleSignature({ + this.comment, + required this.flags, + required this.id, + required this.kind, + required this.kindString, + required this.name, + required this.parameters, + required this.type, + }); + + factory PurpleSignature.fromJson(Map json) => PurpleSignature( + comment: json["comment"] == null ? null : PurpleComment.fromJson(json["comment"]), + flags: GetSignatureFlags.fromJson(json["flags"]), + id: json["id"], + kind: json["kind"], + kindString: signatureKindStringValues.map[json["kindString"]]!, + name: json["name"], + parameters: List.from(json["parameters"].map((x) => GetSignature.fromJson(x))), + type: TentacledType.fromJson(json["type"]), + ); + + Map toJson() => { + "comment": comment?.toJson(), + "flags": flags.toJson(), + "id": id, + "kind": kind, + "kindString": signatureKindStringValues.reverse[kindString], + "name": name, + "parameters": List.from(parameters.map((x) => x.toJson())), + "type": type.toJson(), + }; +} + +class GetSignatureFlags { + GetSignatureFlags(); + + factory GetSignatureFlags.fromJson(Map json) => GetSignatureFlags( + ); + + Map toJson() => { + }; +} + +enum SignatureKindString { + CALL_SIGNATURE, + CONSTRUCTOR_SIGNATURE +} + +final signatureKindStringValues = EnumValues({ + "Call signature": SignatureKindString.CALL_SIGNATURE, + "Constructor signature": SignatureKindString.CONSTRUCTOR_SIGNATURE +}); + +class GetSignatureType { + final GetSignature? declaration; + final ElementType? elementType; + final Name? name; + final TypeEnum type; + + GetSignatureType({ + this.declaration, + this.elementType, + this.name, + required this.type, + }); + + factory GetSignatureType.fromJson(Map json) => GetSignatureType( + declaration: json["declaration"] == null ? null : GetSignature.fromJson(json["declaration"]), + elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]), + name: nameValues.map[json["name"]], + type: typeEnumValues.map[json["type"]]!, + ); + + Map toJson() => { + "declaration": declaration?.toJson(), + "elementType": elementType?.toJson(), + "name": nameValues.reverse[name], + "type": typeEnumValues.reverse[type], + }; +} + +class IndexSignatureElement { + final GetSignatureFlags flags; + final int id; + final int kind; + final String kindString; + final String name; + final List? parameters; + final PurpleType type; + + IndexSignatureElement({ + required this.flags, + required this.id, + required this.kind, + required this.kindString, + required this.name, + this.parameters, + required this.type, + }); + + factory IndexSignatureElement.fromJson(Map json) => IndexSignatureElement( + flags: GetSignatureFlags.fromJson(json["flags"]), + id: json["id"], + kind: json["kind"], + kindString: json["kindString"], + name: json["name"], + parameters: json["parameters"] == null ? null : List.from(json["parameters"]!.map((x) => GetSignature.fromJson(x))), + type: PurpleType.fromJson(json["type"]), + ); + + Map toJson() => { + "flags": flags.toJson(), + "id": id, + "kind": kind, + "kindString": kindString, + "name": name, + "parameters": parameters == null ? null : List.from(parameters!.map((x) => x.toJson())), + "type": type.toJson(), + }; +} + +class PurpleType { + final GetSignature? declaration; + final Name? name; + final TypeEnum type; + + PurpleType({ + this.declaration, + this.name, + required this.type, + }); + + factory PurpleType.fromJson(Map json) => PurpleType( + declaration: json["declaration"] == null ? null : GetSignature.fromJson(json["declaration"]), + name: nameValues.map[json["name"]], + type: typeEnumValues.map[json["type"]]!, + ); + + Map toJson() => { + "declaration": declaration?.toJson(), + "name": nameValues.reverse[name], + "type": typeEnumValues.reverse[type], + }; +} + +class GetSignatureChild { + final FluffyComment? comment; + final FluffyFlags flags; + final int id; + final int kind; + final PurpleKindString kindString; + final String name; + final List sources; + final PurpleType type; + + GetSignatureChild({ + this.comment, + required this.flags, + required this.id, + required this.kind, + required this.kindString, + required this.name, + required this.sources, + required this.type, + }); + + factory GetSignatureChild.fromJson(Map json) => GetSignatureChild( + comment: json["comment"] == null ? null : FluffyComment.fromJson(json["comment"]), + flags: FluffyFlags.fromJson(json["flags"]), + id: json["id"], + kind: json["kind"], + kindString: purpleKindStringValues.map[json["kindString"]]!, + name: json["name"], + sources: List.from(json["sources"].map((x) => Source.fromJson(x))), + type: PurpleType.fromJson(json["type"]), + ); + + Map toJson() => { + "comment": comment?.toJson(), + "flags": flags.toJson(), + "id": id, + "kind": kind, + "kindString": purpleKindStringValues.reverse[kindString], + "name": name, + "sources": List.from(sources.map((x) => x.toJson())), + "type": type.toJson(), + }; +} + +class GetSignature { + final List? children; + final GetSignatureComment? comment; + final String? defaultValue; + final GetSignatureFlags flags; + final List? groups; + final int id; + final int kind; + final String kindString; + final String name; + final List? parameters; + final List? signatures; + final List? sources; + final GetSignatureType? type; + final List? typeParameter; + + GetSignature({ + this.children, + this.comment, + this.defaultValue, + required this.flags, + this.groups, + required this.id, + required this.kind, + required this.kindString, + required this.name, + this.parameters, + this.signatures, + this.sources, + this.type, + this.typeParameter, + }); + + factory GetSignature.fromJson(Map json) => GetSignature( + children: json["children"] == null ? null : List.from(json["children"]!.map((x) => GetSignatureChild.fromJson(x))), + comment: json["comment"] == null ? null : GetSignatureComment.fromJson(json["comment"]), + defaultValue: json["defaultValue"], + flags: GetSignatureFlags.fromJson(json["flags"]), + groups: json["groups"] == null ? null : List.from(json["groups"]!.map((x) => Group.fromJson(x))), + id: json["id"], + kind: json["kind"], + kindString: json["kindString"], + name: json["name"], + parameters: json["parameters"] == null ? null : List.from(json["parameters"]!.map((x) => GetSignatureParameter.fromJson(x))), + signatures: json["signatures"] == null ? null : List.from(json["signatures"]!.map((x) => IndexSignatureElement.fromJson(x))), + sources: json["sources"] == null ? null : List.from(json["sources"]!.map((x) => Source.fromJson(x))), + type: json["type"] == null ? null : GetSignatureType.fromJson(json["type"]), + typeParameter: json["typeParameter"] == null ? null : List.from(json["typeParameter"]!.map((x) => GetSignature.fromJson(x))), + ); + + Map toJson() => { + "children": children == null ? null : List.from(children!.map((x) => x.toJson())), + "comment": comment?.toJson(), + "defaultValue": defaultValue, + "flags": flags.toJson(), + "groups": groups == null ? null : List.from(groups!.map((x) => x.toJson())), + "id": id, + "kind": kind, + "kindString": kindString, + "name": name, + "parameters": parameters == null ? null : List.from(parameters!.map((x) => x.toJson())), + "signatures": signatures == null ? null : List.from(signatures!.map((x) => x.toJson())), + "sources": sources == null ? null : List.from(sources!.map((x) => x.toJson())), + "type": type?.toJson(), + "typeParameter": typeParameter == null ? null : List.from(typeParameter!.map((x) => x.toJson())), + }; +} + +class ElementType { + final Name name; + final TypeEnum type; + + ElementType({ + required this.name, + required this.type, + }); + + factory ElementType.fromJson(Map json) => ElementType( + name: nameValues.map[json["name"]]!, + type: typeEnumValues.map[json["type"]]!, + ); + + Map toJson() => { + "name": nameValues.reverse[name], + "type": typeEnumValues.reverse[type], + }; +} + +enum Name { + STRING, + NUMBER, + VOID, + T, + BOOLEAN, + BASE_CLASS, + ANY, + ARRAY, + MY_NUMBER +} + +final nameValues = EnumValues({ + "string": Name.STRING, + "number": Name.NUMBER, + "void": Name.VOID, + "T": Name.T, + "boolean": Name.BOOLEAN, + "BaseClass": Name.BASE_CLASS, + "any": Name.ANY, + "Array": Name.ARRAY, + "MyNumber": Name.MY_NUMBER +}); + +enum TypeEnum { + INTRINSIC, + REFLECTION, + ARRAY, + REFERENCE, + TYPE_PARAMETER, + TUPLE, + UNION, + STRING_LITERAL +} + +final typeEnumValues = EnumValues({ + "intrinsic": TypeEnum.INTRINSIC, + "reflection": TypeEnum.REFLECTION, + "array": TypeEnum.ARRAY, + "reference": TypeEnum.REFERENCE, + "typeParameter": TypeEnum.TYPE_PARAMETER, + "tuple": TypeEnum.TUPLE, + "union": TypeEnum.UNION, + "stringLiteral": TypeEnum.STRING_LITERAL +}); + +class FluffyComment { + final String text; + + FluffyComment({ + required this.text, + }); + + factory FluffyComment.fromJson(Map json) => FluffyComment( + text: json["text"], + ); + + Map toJson() => { + "text": text, + }; +} + +class FluffyFlags { + final bool? isOptional; + + FluffyFlags({ + this.isOptional, + }); + + factory FluffyFlags.fromJson(Map json) => FluffyFlags( + isOptional: json["isOptional"], + ); + + Map toJson() => { + "isOptional": isOptional, + }; +} + +class Source { + final int character; + final FileName fileName; + final int line; + + Source({ + required this.character, + required this.fileName, + required this.line, + }); + + factory Source.fromJson(Map json) => Source( + character: json["character"], + fileName: fileNameValues.map[json["fileName"]]!, + line: json["line"], + ); + + Map toJson() => { + "character": character, + "fileName": fileNameValues.reverse[fileName], + "line": line, + }; +} + +enum FileName { + MODULES_TS, + CLASSES_TS, + FLATTENED_TS, + ACCESS_TS, + DEFAULT_EXPORT_TS, + ENUMERATIONS_TS, + FUNCTIONS_TS, + GENERICS_TS, + SINGLE_EXPORT_TS, + TYPESCRIPT_13_TS, + TYPESCRIPT_14_TS, + TYPESCRIPT_15_TS, + VARIABLES_TS +} + +final fileNameValues = EnumValues({ + "modules.ts": FileName.MODULES_TS, + "classes.ts": FileName.CLASSES_TS, + "flattened.ts": FileName.FLATTENED_TS, + "access.ts": FileName.ACCESS_TS, + "default-export.ts": FileName.DEFAULT_EXPORT_TS, + "enumerations.ts": FileName.ENUMERATIONS_TS, + "functions.ts": FileName.FUNCTIONS_TS, + "generics.ts": FileName.GENERICS_TS, + "single-export.ts": FileName.SINGLE_EXPORT_TS, + "typescript-1.3.ts": FileName.TYPESCRIPT_13_TS, + "typescript-1.4.ts": FileName.TYPESCRIPT_14_TS, + "typescript-1.5.ts": FileName.TYPESCRIPT_15_TS, + "variables.ts": FileName.VARIABLES_TS +}); + +class GetSignatureComment { + final String? returns; + final String? shortText; + final String? text; + + GetSignatureComment({ + this.returns, + this.shortText, + this.text, + }); + + factory GetSignatureComment.fromJson(Map json) => GetSignatureComment( + returns: json["returns"], + shortText: json["shortText"], + text: json["text"], + ); + + Map toJson() => { + "returns": returns, + "shortText": shortText, + "text": text, + }; +} + +class Group { + final List children; + final int kind; + final String title; + + Group({ + required this.children, + required this.kind, + required this.title, + }); + + factory Group.fromJson(Map json) => Group( + children: List.from(json["children"].map((x) => x)), + kind: json["kind"], + title: json["title"], + ); + + Map toJson() => { + "children": List.from(children.map((x) => x)), + "kind": kind, + "title": title, + }; +} + +class GetSignatureParameter { + final TentacledComment? comment; + final TentacledFlags flags; + final int id; + final int kind; + final ParameterKindString kindString; + final String name; + final FluffyType type; + + GetSignatureParameter({ + this.comment, + required this.flags, + required this.id, + required this.kind, + required this.kindString, + required this.name, + required this.type, + }); + + factory GetSignatureParameter.fromJson(Map json) => GetSignatureParameter( + comment: json["comment"] == null ? null : TentacledComment.fromJson(json["comment"]), + flags: TentacledFlags.fromJson(json["flags"]), + id: json["id"], + kind: json["kind"], + kindString: parameterKindStringValues.map[json["kindString"]]!, + name: json["name"], + type: FluffyType.fromJson(json["type"]), + ); + + Map toJson() => { + "comment": comment?.toJson(), + "flags": flags.toJson(), + "id": id, + "kind": kind, + "kindString": parameterKindStringValues.reverse[kindString], + "name": name, + "type": type.toJson(), + }; +} + +class TentacledComment { + final String? shortText; + final String? text; + + TentacledComment({ + this.shortText, + this.text, + }); + + factory TentacledComment.fromJson(Map json) => TentacledComment( + shortText: json["shortText"], + text: json["text"], + ); + + Map toJson() => { + "shortText": shortText, + "text": text, + }; +} + +class TentacledFlags { + final bool? isOptional; + final bool? isRest; + + TentacledFlags({ + this.isOptional, + this.isRest, + }); + + factory TentacledFlags.fromJson(Map json) => TentacledFlags( + isOptional: json["isOptional"], + isRest: json["isRest"], + ); + + Map toJson() => { + "isOptional": isOptional, + "isRest": isRest, + }; +} + +enum ParameterKindString { + PARAMETER +} + +final parameterKindStringValues = EnumValues({ + "Parameter": ParameterKindString.PARAMETER +}); + +class FluffyType { + final ElementType? elementType; + final Name? name; + final TypeEnum type; + final List? typeArguments; + + FluffyType({ + this.elementType, + this.name, + required this.type, + this.typeArguments, + }); + + factory FluffyType.fromJson(Map json) => FluffyType( + elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]), + name: nameValues.map[json["name"]], + type: typeEnumValues.map[json["type"]]!, + typeArguments: json["typeArguments"] == null ? null : List.from(json["typeArguments"]!.map((x) => ElementType.fromJson(x))), + ); + + Map toJson() => { + "elementType": elementType?.toJson(), + "name": nameValues.reverse[name], + "type": typeEnumValues.reverse[type], + "typeArguments": typeArguments == null ? null : List.from(typeArguments!.map((x) => x.toJson())), + }; +} + +class TentacledType { + final PurpleDeclaration? declaration; + final Name? name; + final TypeEnum type; + + TentacledType({ + this.declaration, + this.name, + required this.type, + }); + + factory TentacledType.fromJson(Map json) => TentacledType( + declaration: json["declaration"] == null ? null : PurpleDeclaration.fromJson(json["declaration"]), + name: nameValues.map[json["name"]], + type: typeEnumValues.map[json["type"]]!, + ); + + Map toJson() => { + "declaration": declaration?.toJson(), + "name": nameValues.reverse[name], + "type": typeEnumValues.reverse[type], + }; +} + +class PurpleDeclaration { + final List children; + final GetSignatureFlags flags; + final List groups; + final int id; + final int kind; + final String kindString; + final String name; + + PurpleDeclaration({ + required this.children, + required this.flags, + required this.groups, + required this.id, + required this.kind, + required this.kindString, + required this.name, + }); + + factory PurpleDeclaration.fromJson(Map json) => PurpleDeclaration( + children: List.from(json["children"].map((x) => GetSignature.fromJson(x))), + flags: GetSignatureFlags.fromJson(json["flags"]), + groups: List.from(json["groups"].map((x) => Group.fromJson(x))), + id: json["id"], + kind: json["kind"], + kindString: json["kindString"], + name: json["name"], + ); + + Map toJson() => { + "children": List.from(children.map((x) => x.toJson())), + "flags": flags.toJson(), + "groups": List.from(groups.map((x) => x.toJson())), + "id": id, + "kind": kind, + "kindString": kindString, + "name": name, + }; +} + +class TypeElement { + final GetSignature? declaration; + final ElementType? elementType; + final Name? name; + final TypeEnum type; + final List? typeArguments; + + TypeElement({ + this.declaration, + this.elementType, + this.name, + required this.type, + this.typeArguments, + }); + + factory TypeElement.fromJson(Map json) => TypeElement( + declaration: json["declaration"] == null ? null : GetSignature.fromJson(json["declaration"]), + elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]), + name: nameValues.map[json["name"]], + type: typeEnumValues.map[json["type"]]!, + typeArguments: json["typeArguments"] == null ? null : List.from(json["typeArguments"]!.map((x) => ElementType.fromJson(x))), + ); + + Map toJson() => { + "declaration": declaration?.toJson(), + "elementType": elementType?.toJson(), + "name": nameValues.reverse[name], + "type": typeEnumValues.reverse[type], + "typeArguments": typeArguments == null ? null : List.from(typeArguments!.map((x) => x.toJson())), + }; +} + +class StickyComment { + final String? returns; + final String? shortText; + final List? tags; + final String? text; + + StickyComment({ + this.returns, + this.shortText, + this.tags, + this.text, + }); + + factory StickyComment.fromJson(Map json) => StickyComment( + returns: json["returns"], + shortText: json["shortText"], + tags: json["tags"] == null ? null : List.from(json["tags"]!.map((x) => Tag.fromJson(x))), + text: json["text"], + ); + + Map toJson() => { + "returns": returns, + "shortText": shortText, + "tags": tags == null ? null : List.from(tags!.map((x) => x.toJson())), + "text": text, + }; +} + +class Tag { + final String tag; + final String text; + + Tag({ + required this.tag, + required this.text, + }); + + factory Tag.fromJson(Map json) => Tag( + tag: json["tag"], + text: json["text"], + ); + + Map toJson() => { + "tag": tag, + "text": text, + }; +} + +class StickyFlags { + final bool? isAbstract; + final bool? isConstructorProperty; + final bool? isExported; + final bool? isPrivate; + final bool? isProtected; + final bool? isPublic; + final bool? isStatic; + + StickyFlags({ + this.isAbstract, + this.isConstructorProperty, + this.isExported, + this.isPrivate, + this.isProtected, + this.isPublic, + this.isStatic, + }); + + factory StickyFlags.fromJson(Map json) => StickyFlags( + isAbstract: json["isAbstract"], + isConstructorProperty: json["isConstructorProperty"], + isExported: json["isExported"], + isPrivate: json["isPrivate"], + isProtected: json["isProtected"], + isPublic: json["isPublic"], + isStatic: json["isStatic"], + ); + + Map toJson() => { + "isAbstract": isAbstract, + "isConstructorProperty": isConstructorProperty, + "isExported": isExported, + "isPrivate": isPrivate, + "isProtected": isProtected, + "isPublic": isPublic, + "isStatic": isStatic, + }; +} + +class ExtendedBy { + final ExtendedBy? constraint; + final int? id; + final String name; + final TypeEnum type; + final List? typeArguments; + + ExtendedBy({ + this.constraint, + this.id, + required this.name, + required this.type, + this.typeArguments, + }); + + factory ExtendedBy.fromJson(Map json) => ExtendedBy( + constraint: json["constraint"] == null ? null : ExtendedBy.fromJson(json["constraint"]), + id: json["id"], + name: json["name"], + type: typeEnumValues.map[json["type"]]!, + typeArguments: json["typeArguments"] == null ? null : List.from(json["typeArguments"]!.map((x) => ExtendedBy.fromJson(x))), + ); + + Map toJson() => { + "constraint": constraint?.toJson(), + "id": id, + "name": name, + "type": typeEnumValues.reverse[type], + "typeArguments": typeArguments == null ? null : List.from(typeArguments!.map((x) => x.toJson())), + }; +} + +class FluffySignature { + final StickyComment? comment; + final IndigoFlags flags; + final int id; + final ExtendedBy? implementationOf; + final ExtendedBy? inheritedFrom; + final int kind; + final SignatureKindString kindString; + final String name; + final ExtendedBy? overwrites; + final List? parameters; + final ExtendedBy type; + final List? typeParameter; + + FluffySignature({ + this.comment, + required this.flags, + required this.id, + this.implementationOf, + this.inheritedFrom, + required this.kind, + required this.kindString, + required this.name, + this.overwrites, + this.parameters, + required this.type, + this.typeParameter, + }); + + factory FluffySignature.fromJson(Map json) => FluffySignature( + comment: json["comment"] == null ? null : StickyComment.fromJson(json["comment"]), + flags: IndigoFlags.fromJson(json["flags"]), + id: json["id"], + implementationOf: json["implementationOf"] == null ? null : ExtendedBy.fromJson(json["implementationOf"]), + inheritedFrom: json["inheritedFrom"] == null ? null : ExtendedBy.fromJson(json["inheritedFrom"]), + kind: json["kind"], + kindString: signatureKindStringValues.map[json["kindString"]]!, + name: json["name"], + overwrites: json["overwrites"] == null ? null : ExtendedBy.fromJson(json["overwrites"]), + parameters: json["parameters"] == null ? null : List.from(json["parameters"]!.map((x) => PurpleParameter.fromJson(x))), + type: ExtendedBy.fromJson(json["type"]), + typeParameter: json["typeParameter"] == null ? null : List.from(json["typeParameter"]!.map((x) => GetSignature.fromJson(x))), + ); + + Map toJson() => { + "comment": comment?.toJson(), + "flags": flags.toJson(), + "id": id, + "implementationOf": implementationOf?.toJson(), + "inheritedFrom": inheritedFrom?.toJson(), + "kind": kind, + "kindString": signatureKindStringValues.reverse[kindString], + "name": name, + "overwrites": overwrites?.toJson(), + "parameters": parameters == null ? null : List.from(parameters!.map((x) => x.toJson())), + "type": type.toJson(), + "typeParameter": typeParameter == null ? null : List.from(typeParameter!.map((x) => x.toJson())), + }; +} + +class IndigoFlags { + final bool? isPrivate; + final bool? isProtected; + + IndigoFlags({ + this.isPrivate, + this.isProtected, + }); + + factory IndigoFlags.fromJson(Map json) => IndigoFlags( + isPrivate: json["isPrivate"], + isProtected: json["isProtected"], + ); + + Map toJson() => { + "isPrivate": isPrivate, + "isProtected": isProtected, + }; +} + +class PurpleParameter { + final TentacledComment? comment; + final GetSignatureFlags flags; + final int id; + final int kind; + final ParameterKindString kindString; + final String name; + final StickyType type; + + PurpleParameter({ + this.comment, + required this.flags, + required this.id, + required this.kind, + required this.kindString, + required this.name, + required this.type, + }); + + factory PurpleParameter.fromJson(Map json) => PurpleParameter( + comment: json["comment"] == null ? null : TentacledComment.fromJson(json["comment"]), + flags: GetSignatureFlags.fromJson(json["flags"]), + id: json["id"], + kind: json["kind"], + kindString: parameterKindStringValues.map[json["kindString"]]!, + name: json["name"], + type: StickyType.fromJson(json["type"]), + ); + + Map toJson() => { + "comment": comment?.toJson(), + "flags": flags.toJson(), + "id": id, + "kind": kind, + "kindString": parameterKindStringValues.reverse[kindString], + "name": name, + "type": type.toJson(), + }; +} + +class StickyType { + final ExtendedBy? constraint; + final GetSignature? declaration; + final ElementType? elementType; + final List? elements; + final int? id; + final String? name; + final TypeEnum type; + final List? typeArguments; + + StickyType({ + this.constraint, + this.declaration, + this.elementType, + this.elements, + this.id, + this.name, + required this.type, + this.typeArguments, + }); + + factory StickyType.fromJson(Map json) => StickyType( + constraint: json["constraint"] == null ? null : ExtendedBy.fromJson(json["constraint"]), + declaration: json["declaration"] == null ? null : GetSignature.fromJson(json["declaration"]), + elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]), + elements: json["elements"] == null ? null : List.from(json["elements"]!.map((x) => ExtendedBy.fromJson(x))), + id: json["id"], + name: json["name"], + type: typeEnumValues.map[json["type"]]!, + typeArguments: json["typeArguments"] == null ? null : List.from(json["typeArguments"]!.map((x) => ElementType.fromJson(x))), + ); + + Map toJson() => { + "constraint": constraint?.toJson(), + "declaration": declaration?.toJson(), + "elementType": elementType?.toJson(), + "elements": elements == null ? null : List.from(elements!.map((x) => x.toJson())), + "id": id, + "name": name, + "type": typeEnumValues.reverse[type], + "typeArguments": typeArguments == null ? null : List.from(typeArguments!.map((x) => x.toJson())), + }; +} + +class IndigoType { + final ExtendedBy? constraint; + final FluffyDeclaration? declaration; + final ExtendedBy? elementType; + final List? elements; + final int? id; + final String? name; + final TypeEnum type; + final List? typeArguments; + final List? types; + + IndigoType({ + this.constraint, + this.declaration, + this.elementType, + this.elements, + this.id, + this.name, + required this.type, + this.typeArguments, + this.types, + }); + + factory IndigoType.fromJson(Map json) => IndigoType( + constraint: json["constraint"] == null ? null : ExtendedBy.fromJson(json["constraint"]), + declaration: json["declaration"] == null ? null : FluffyDeclaration.fromJson(json["declaration"]), + elementType: json["elementType"] == null ? null : ExtendedBy.fromJson(json["elementType"]), + elements: json["elements"] == null ? null : List.from(json["elements"]!.map((x) => ElementType.fromJson(x))), + id: json["id"], + name: json["name"], + type: typeEnumValues.map[json["type"]]!, + typeArguments: json["typeArguments"] == null ? null : List.from(json["typeArguments"]!.map((x) => PurpleTypeArgument.fromJson(x))), + types: json["types"] == null ? null : List.from(json["types"]!.map((x) => TypeElement.fromJson(x))), + ); + + Map toJson() => { + "constraint": constraint?.toJson(), + "declaration": declaration?.toJson(), + "elementType": elementType?.toJson(), + "elements": elements == null ? null : List.from(elements!.map((x) => x.toJson())), + "id": id, + "name": name, + "type": typeEnumValues.reverse[type], + "typeArguments": typeArguments == null ? null : List.from(typeArguments!.map((x) => x.toJson())), + "types": types == null ? null : List.from(types!.map((x) => x.toJson())), + }; +} + +class FluffyDeclaration { + final List? children; + final GetSignatureFlags flags; + final List? groups; + final int id; + final IndexSignature? indexSignature; + final int kind; + final String kindString; + final String name; + final List? signatures; + final List sources; + + FluffyDeclaration({ + this.children, + required this.flags, + this.groups, + required this.id, + this.indexSignature, + required this.kind, + required this.kindString, + required this.name, + this.signatures, + required this.sources, + }); + + factory FluffyDeclaration.fromJson(Map json) => FluffyDeclaration( + children: json["children"] == null ? null : List.from(json["children"]!.map((x) => StickyChild.fromJson(x))), + flags: GetSignatureFlags.fromJson(json["flags"]), + groups: json["groups"] == null ? null : List.from(json["groups"]!.map((x) => Group.fromJson(x))), + id: json["id"], + indexSignature: json["indexSignature"] == null ? null : IndexSignature.fromJson(json["indexSignature"]), + kind: json["kind"], + kindString: json["kindString"], + name: json["name"], + signatures: json["signatures"] == null ? null : List.from(json["signatures"]!.map((x) => TentacledSignature.fromJson(x))), + sources: List.from(json["sources"].map((x) => Source.fromJson(x))), + ); + + Map toJson() => { + "children": children == null ? null : List.from(children!.map((x) => x.toJson())), + "flags": flags.toJson(), + "groups": groups == null ? null : List.from(groups!.map((x) => x.toJson())), + "id": id, + "indexSignature": indexSignature?.toJson(), + "kind": kind, + "kindString": kindString, + "name": name, + "signatures": signatures == null ? null : List.from(signatures!.map((x) => x.toJson())), + "sources": List.from(sources.map((x) => x.toJson())), + }; +} + +class StickyChild { + final FluffyComment? comment; + final FluffyFlags flags; + final int id; + final int kind; + final PurpleKindString kindString; + final String name; + final List sources; + final IndecentType type; + + StickyChild({ + this.comment, + required this.flags, + required this.id, + required this.kind, + required this.kindString, + required this.name, + required this.sources, + required this.type, + }); + + factory StickyChild.fromJson(Map json) => StickyChild( + comment: json["comment"] == null ? null : FluffyComment.fromJson(json["comment"]), + flags: FluffyFlags.fromJson(json["flags"]), + id: json["id"], + kind: json["kind"], + kindString: purpleKindStringValues.map[json["kindString"]]!, + name: json["name"], + sources: List.from(json["sources"].map((x) => Source.fromJson(x))), + type: IndecentType.fromJson(json["type"]), + ); + + Map toJson() => { + "comment": comment?.toJson(), + "flags": flags.toJson(), + "id": id, + "kind": kind, + "kindString": purpleKindStringValues.reverse[kindString], + "name": name, + "sources": List.from(sources.map((x) => x.toJson())), + "type": type.toJson(), + }; +} + +class IndecentType { + final GetSignature? declaration; + final List? elements; + final Name? name; + final TypeEnum type; + + IndecentType({ + this.declaration, + this.elements, + this.name, + required this.type, + }); + + factory IndecentType.fromJson(Map json) => IndecentType( + declaration: json["declaration"] == null ? null : GetSignature.fromJson(json["declaration"]), + elements: json["elements"] == null ? null : List.from(json["elements"]!.map((x) => ElementType.fromJson(x))), + name: nameValues.map[json["name"]], + type: typeEnumValues.map[json["type"]]!, + ); + + Map toJson() => { + "declaration": declaration?.toJson(), + "elements": elements == null ? null : List.from(elements!.map((x) => x.toJson())), + "name": nameValues.reverse[name], + "type": typeEnumValues.reverse[type], + }; +} + +class IndexSignature { + final GetSignatureFlags flags; + final int id; + final int kind; + final String kindString; + final String name; + final List parameters; + final HilariousType type; + + IndexSignature({ + required this.flags, + required this.id, + required this.kind, + required this.kindString, + required this.name, + required this.parameters, + required this.type, + }); + + factory IndexSignature.fromJson(Map json) => IndexSignature( + flags: GetSignatureFlags.fromJson(json["flags"]), + id: json["id"], + kind: json["kind"], + kindString: json["kindString"], + name: json["name"], + parameters: List.from(json["parameters"].map((x) => GetSignature.fromJson(x))), + type: HilariousType.fromJson(json["type"]), + ); + + Map toJson() => { + "flags": flags.toJson(), + "id": id, + "kind": kind, + "kindString": kindString, + "name": name, + "parameters": List.from(parameters.map((x) => x.toJson())), + "type": type.toJson(), + }; +} + +class HilariousType { + final GetSignature declaration; + final TypeEnum type; + + HilariousType({ + required this.declaration, + required this.type, + }); + + factory HilariousType.fromJson(Map json) => HilariousType( + declaration: GetSignature.fromJson(json["declaration"]), + type: typeEnumValues.map[json["type"]]!, + ); + + Map toJson() => { + "declaration": declaration.toJson(), + "type": typeEnumValues.reverse[type], + }; +} + +class TentacledSignature { + final IndigoComment? comment; + final GetSignatureFlags flags; + final int id; + final int kind; + final SignatureKindString kindString; + final String name; + final List? parameters; + final ExtendedBy type; + + TentacledSignature({ + this.comment, + required this.flags, + required this.id, + required this.kind, + required this.kindString, + required this.name, + this.parameters, + required this.type, + }); + + factory TentacledSignature.fromJson(Map json) => TentacledSignature( + comment: json["comment"] == null ? null : IndigoComment.fromJson(json["comment"]), + flags: GetSignatureFlags.fromJson(json["flags"]), + id: json["id"], + kind: json["kind"], + kindString: signatureKindStringValues.map[json["kindString"]]!, + name: json["name"], + parameters: json["parameters"] == null ? null : List.from(json["parameters"]!.map((x) => FluffyParameter.fromJson(x))), + type: ExtendedBy.fromJson(json["type"]), + ); + + Map toJson() => { + "comment": comment?.toJson(), + "flags": flags.toJson(), + "id": id, + "kind": kind, + "kindString": signatureKindStringValues.reverse[kindString], + "name": name, + "parameters": parameters == null ? null : List.from(parameters!.map((x) => x.toJson())), + "type": type.toJson(), + }; +} + +class IndigoComment { + final String returns; + final String shortText; + + IndigoComment({ + required this.returns, + required this.shortText, + }); + + factory IndigoComment.fromJson(Map json) => IndigoComment( + returns: json["returns"], + shortText: json["shortText"], + ); + + Map toJson() => { + "returns": returns, + "shortText": shortText, + }; +} + +class FluffyParameter { + final FluffyComment? comment; + final FluffyFlags flags; + final int id; + final int kind; + final String kindString; + final String name; + final List? sources; + final ElementType type; + + FluffyParameter({ + this.comment, + required this.flags, + required this.id, + required this.kind, + required this.kindString, + required this.name, + this.sources, + required this.type, + }); + + factory FluffyParameter.fromJson(Map json) => FluffyParameter( + comment: json["comment"] == null ? null : FluffyComment.fromJson(json["comment"]), + flags: FluffyFlags.fromJson(json["flags"]), + id: json["id"], + kind: json["kind"], + kindString: json["kindString"], + name: json["name"], + sources: json["sources"] == null ? null : List.from(json["sources"]!.map((x) => Source.fromJson(x))), + type: ElementType.fromJson(json["type"]), + ); + + Map toJson() => { + "comment": comment?.toJson(), + "flags": flags.toJson(), + "id": id, + "kind": kind, + "kindString": kindString, + "name": name, + "sources": sources == null ? null : List.from(sources!.map((x) => x.toJson())), + "type": type.toJson(), + }; +} + +class PurpleTypeArgument { + final ElementType target; + final String type; + final String typeArgumentOperator; + + PurpleTypeArgument({ + required this.target, + required this.type, + required this.typeArgumentOperator, + }); + + factory PurpleTypeArgument.fromJson(Map json) => PurpleTypeArgument( + target: ElementType.fromJson(json["target"]), + type: json["type"], + typeArgumentOperator: json["operator"], + ); + + Map toJson() => { + "target": target.toJson(), + "type": type, + "operator": typeArgumentOperator, + }; +} + +class IndecentFlags { + final bool? hasExportAssignment; + final bool? isAbstract; + final bool? isConst; + final bool? isExported; + final bool? isLet; + final bool? isPrivate; + final bool? isProtected; + + IndecentFlags({ + this.hasExportAssignment, + this.isAbstract, + this.isConst, + this.isExported, + this.isLet, + this.isPrivate, + this.isProtected, + }); + + factory IndecentFlags.fromJson(Map json) => IndecentFlags( + hasExportAssignment: json["hasExportAssignment"], + isAbstract: json["isAbstract"], + isConst: json["isConst"], + isExported: json["isExported"], + isLet: json["isLet"], + isPrivate: json["isPrivate"], + isProtected: json["isProtected"], + ); + + Map toJson() => { + "hasExportAssignment": hasExportAssignment, + "isAbstract": isAbstract, + "isConst": isConst, + "isExported": isExported, + "isLet": isLet, + "isPrivate": isPrivate, + "isProtected": isProtected, + }; +} + +enum FluffyKindString { + MODULE, + CLASS, + VARIABLE, + FUNCTION, + INTERFACE, + ENUMERATION, + OBJECT_LITERAL, + TYPE_ALIAS +} + +final fluffyKindStringValues = EnumValues({ + "Module": FluffyKindString.MODULE, + "Class": FluffyKindString.CLASS, + "Variable": FluffyKindString.VARIABLE, + "Function": FluffyKindString.FUNCTION, + "Interface": FluffyKindString.INTERFACE, + "Enumeration": FluffyKindString.ENUMERATION, + "Object literal": FluffyKindString.OBJECT_LITERAL, + "Type alias": FluffyKindString.TYPE_ALIAS +}); + +class StickySignature { + final StickyComment comment; + final IndigoFlags flags; + final int id; + final int kind; + final SignatureKindString kindString; + final String name; + final List? parameters; + final CunningType type; + final List? typeParameter; + + StickySignature({ + required this.comment, + required this.flags, + required this.id, + required this.kind, + required this.kindString, + required this.name, + this.parameters, + required this.type, + this.typeParameter, + }); + + factory StickySignature.fromJson(Map json) => StickySignature( + comment: StickyComment.fromJson(json["comment"]), + flags: IndigoFlags.fromJson(json["flags"]), + id: json["id"], + kind: json["kind"], + kindString: signatureKindStringValues.map[json["kindString"]]!, + name: json["name"], + parameters: json["parameters"] == null ? null : List.from(json["parameters"]!.map((x) => TentacledParameter.fromJson(x))), + type: CunningType.fromJson(json["type"]), + typeParameter: json["typeParameter"] == null ? null : List.from(json["typeParameter"]!.map((x) => GetSignature.fromJson(x))), + ); + + Map toJson() => { + "comment": comment.toJson(), + "flags": flags.toJson(), + "id": id, + "kind": kind, + "kindString": signatureKindStringValues.reverse[kindString], + "name": name, + "parameters": parameters == null ? null : List.from(parameters!.map((x) => x.toJson())), + "type": type.toJson(), + "typeParameter": typeParameter == null ? null : List.from(typeParameter!.map((x) => x.toJson())), + }; +} + +class TentacledParameter { + final TentacledComment? comment; + final String? defaultValue; + final TentacledFlags flags; + final int id; + final int kind; + final ParameterKindString kindString; + final String name; + final String? originalName; + final AmbitiousType type; + + TentacledParameter({ + this.comment, + this.defaultValue, + required this.flags, + required this.id, + required this.kind, + required this.kindString, + required this.name, + this.originalName, + required this.type, + }); + + factory TentacledParameter.fromJson(Map json) => TentacledParameter( + comment: json["comment"] == null ? null : TentacledComment.fromJson(json["comment"]), + defaultValue: json["defaultValue"], + flags: TentacledFlags.fromJson(json["flags"]), + id: json["id"], + kind: json["kind"], + kindString: parameterKindStringValues.map[json["kindString"]]!, + name: json["name"], + originalName: json["originalName"], + type: AmbitiousType.fromJson(json["type"]), + ); + + Map toJson() => { + "comment": comment?.toJson(), + "defaultValue": defaultValue, + "flags": flags.toJson(), + "id": id, + "kind": kind, + "kindString": parameterKindStringValues.reverse[kindString], + "name": name, + "originalName": originalName, + "type": type.toJson(), + }; +} + +class AmbitiousType { + final TentacledDeclaration? declaration; + final ElementType? elementType; + final int? id; + final String? name; + final TypeEnum type; + final List? typeArguments; + + AmbitiousType({ + this.declaration, + this.elementType, + this.id, + this.name, + required this.type, + this.typeArguments, + }); + + factory AmbitiousType.fromJson(Map json) => AmbitiousType( + declaration: json["declaration"] == null ? null : TentacledDeclaration.fromJson(json["declaration"]), + elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]), + id: json["id"], + name: json["name"], + type: typeEnumValues.map[json["type"]]!, + typeArguments: json["typeArguments"] == null ? null : List.from(json["typeArguments"]!.map((x) => ElementType.fromJson(x))), + ); + + Map toJson() => { + "declaration": declaration?.toJson(), + "elementType": elementType?.toJson(), + "id": id, + "name": name, + "type": typeEnumValues.reverse[type], + "typeArguments": typeArguments == null ? null : List.from(typeArguments!.map((x) => x.toJson())), + }; +} + +class TentacledDeclaration { + final List? children; + final GetSignatureFlags flags; + final List? groups; + final int id; + final IndexSignatureElement? indexSignature; + final int kind; + final String kindString; + final String name; + final List? signatures; + final List sources; + + TentacledDeclaration({ + this.children, + required this.flags, + this.groups, + required this.id, + this.indexSignature, + required this.kind, + required this.kindString, + required this.name, + this.signatures, + required this.sources, + }); + + factory TentacledDeclaration.fromJson(Map json) => TentacledDeclaration( + children: json["children"] == null ? null : List.from(json["children"]!.map((x) => IndigoChild.fromJson(x))), + flags: GetSignatureFlags.fromJson(json["flags"]), + groups: json["groups"] == null ? null : List.from(json["groups"]!.map((x) => Group.fromJson(x))), + id: json["id"], + indexSignature: json["indexSignature"] == null ? null : IndexSignatureElement.fromJson(json["indexSignature"]), + kind: json["kind"], + kindString: json["kindString"], + name: json["name"], + signatures: json["signatures"] == null ? null : List.from(json["signatures"]!.map((x) => GetSignature.fromJson(x))), + sources: List.from(json["sources"].map((x) => Source.fromJson(x))), + ); + + Map toJson() => { + "children": children == null ? null : List.from(children!.map((x) => x.toJson())), + "flags": flags.toJson(), + "groups": groups == null ? null : List.from(groups!.map((x) => x.toJson())), + "id": id, + "indexSignature": indexSignature?.toJson(), + "kind": kind, + "kindString": kindString, + "name": name, + "signatures": signatures == null ? null : List.from(signatures!.map((x) => x.toJson())), + "sources": List.from(sources.map((x) => x.toJson())), + }; +} + +class IndigoChild { + final FluffyComment comment; + final String? defaultValue; + final FluffyFlags flags; + final int id; + final int kind; + final PurpleKindString kindString; + final String name; + final List sources; + final IndecentType type; + + IndigoChild({ + required this.comment, + this.defaultValue, + required this.flags, + required this.id, + required this.kind, + required this.kindString, + required this.name, + required this.sources, + required this.type, + }); + + factory IndigoChild.fromJson(Map json) => IndigoChild( + comment: FluffyComment.fromJson(json["comment"]), + defaultValue: json["defaultValue"], + flags: FluffyFlags.fromJson(json["flags"]), + id: json["id"], + kind: json["kind"], + kindString: purpleKindStringValues.map[json["kindString"]]!, + name: json["name"], + sources: List.from(json["sources"].map((x) => Source.fromJson(x))), + type: IndecentType.fromJson(json["type"]), + ); + + Map toJson() => { + "comment": comment.toJson(), + "defaultValue": defaultValue, + "flags": flags.toJson(), + "id": id, + "kind": kind, + "kindString": purpleKindStringValues.reverse[kindString], + "name": name, + "sources": List.from(sources.map((x) => x.toJson())), + "type": type.toJson(), + }; +} + +class CunningType { + final PurpleDeclaration? declaration; + final int? id; + final Name? name; + final TypeEnum type; + final List? typeArguments; + + CunningType({ + this.declaration, + this.id, + this.name, + required this.type, + this.typeArguments, + }); + + factory CunningType.fromJson(Map json) => CunningType( + declaration: json["declaration"] == null ? null : PurpleDeclaration.fromJson(json["declaration"]), + id: json["id"], + name: nameValues.map[json["name"]], + type: typeEnumValues.map[json["type"]]!, + typeArguments: json["typeArguments"] == null ? null : List.from(json["typeArguments"]!.map((x) => ElementType.fromJson(x))), + ); + + Map toJson() => { + "declaration": declaration?.toJson(), + "id": id, + "name": nameValues.reverse[name], + "type": typeEnumValues.reverse[type], + "typeArguments": typeArguments == null ? null : List.from(typeArguments!.map((x) => x.toJson())), + }; +} + +class MagentaType { + final StickyDeclaration? declaration; + final ElementType? elementType; + final List? elements; + final int? id; + final String? name; + final TypeEnum type; + final List? typeArguments; + final List? types; + final String? value; + + MagentaType({ + this.declaration, + this.elementType, + this.elements, + this.id, + this.name, + required this.type, + this.typeArguments, + this.types, + this.value, + }); + + factory MagentaType.fromJson(Map json) => MagentaType( + declaration: json["declaration"] == null ? null : StickyDeclaration.fromJson(json["declaration"]), + elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]), + elements: json["elements"] == null ? null : List.from(json["elements"]!.map((x) => ExtendedBy.fromJson(x))), + id: json["id"], + name: json["name"], + type: typeEnumValues.map[json["type"]]!, + typeArguments: json["typeArguments"] == null ? null : List.from(json["typeArguments"]!.map((x) => FluffyTypeArgument.fromJson(x))), + types: json["types"] == null ? null : List.from(json["types"]!.map((x) => ExtendedBy.fromJson(x))), + value: json["value"], + ); + + Map toJson() => { + "declaration": declaration?.toJson(), + "elementType": elementType?.toJson(), + "elements": elements == null ? null : List.from(elements!.map((x) => x.toJson())), + "id": id, + "name": name, + "type": typeEnumValues.reverse[type], + "typeArguments": typeArguments == null ? null : List.from(typeArguments!.map((x) => x.toJson())), + "types": types == null ? null : List.from(types!.map((x) => x.toJson())), + "value": value, + }; +} + +class StickyDeclaration { + final List? children; + final GetSignatureFlags flags; + final List? groups; + final int id; + final int kind; + final String kindString; + final String name; + final List signatures; + final List sources; + + StickyDeclaration({ + this.children, + required this.flags, + this.groups, + required this.id, + required this.kind, + required this.kindString, + required this.name, + required this.signatures, + required this.sources, + }); + + factory StickyDeclaration.fromJson(Map json) => StickyDeclaration( + children: json["children"] == null ? null : List.from(json["children"]!.map((x) => IndecentChild.fromJson(x))), + flags: GetSignatureFlags.fromJson(json["flags"]), + groups: json["groups"] == null ? null : List.from(json["groups"]!.map((x) => Group.fromJson(x))), + id: json["id"], + kind: json["kind"], + kindString: json["kindString"], + name: json["name"], + signatures: List.from(json["signatures"].map((x) => GetSignature.fromJson(x))), + sources: List.from(json["sources"].map((x) => Source.fromJson(x))), + ); + + Map toJson() => { + "children": children == null ? null : List.from(children!.map((x) => x.toJson())), + "flags": flags.toJson(), + "groups": groups == null ? null : List.from(groups!.map((x) => x.toJson())), + "id": id, + "kind": kind, + "kindString": kindString, + "name": name, + "signatures": List.from(signatures.map((x) => x.toJson())), + "sources": List.from(sources.map((x) => x.toJson())), + }; +} + +class IndecentChild { + final FluffyFlags flags; + final int id; + final int kind; + final PurpleKindString kindString; + final String name; + final List sources; + final FriskyType type; + + IndecentChild({ + required this.flags, + required this.id, + required this.kind, + required this.kindString, + required this.name, + required this.sources, + required this.type, + }); + + factory IndecentChild.fromJson(Map json) => IndecentChild( + flags: FluffyFlags.fromJson(json["flags"]), + id: json["id"], + kind: json["kind"], + kindString: purpleKindStringValues.map[json["kindString"]]!, + name: json["name"], + sources: List.from(json["sources"].map((x) => Source.fromJson(x))), + type: FriskyType.fromJson(json["type"]), + ); + + Map toJson() => { + "flags": flags.toJson(), + "id": id, + "kind": kind, + "kindString": purpleKindStringValues.reverse[kindString], + "name": name, + "sources": List.from(sources.map((x) => x.toJson())), + "type": type.toJson(), + }; +} + +class FriskyType { + final IndigoDeclaration? declaration; + final Name? name; + final TypeEnum type; + + FriskyType({ + this.declaration, + this.name, + required this.type, + }); + + factory FriskyType.fromJson(Map json) => FriskyType( + declaration: json["declaration"] == null ? null : IndigoDeclaration.fromJson(json["declaration"]), + name: nameValues.map[json["name"]], + type: typeEnumValues.map[json["type"]]!, + ); + + Map toJson() => { + "declaration": declaration?.toJson(), + "name": nameValues.reverse[name], + "type": typeEnumValues.reverse[type], + }; +} + +class IndigoDeclaration { + final List? children; + final GetSignatureFlags flags; + final List? groups; + final int id; + final int kind; + final String kindString; + final String name; + final List? signatures; + final List sources; + + IndigoDeclaration({ + this.children, + required this.flags, + this.groups, + required this.id, + required this.kind, + required this.kindString, + required this.name, + this.signatures, + required this.sources, + }); + + factory IndigoDeclaration.fromJson(Map json) => IndigoDeclaration( + children: json["children"] == null ? null : List.from(json["children"]!.map((x) => GetSignature.fromJson(x))), + flags: GetSignatureFlags.fromJson(json["flags"]), + groups: json["groups"] == null ? null : List.from(json["groups"]!.map((x) => Group.fromJson(x))), + id: json["id"], + kind: json["kind"], + kindString: json["kindString"], + name: json["name"], + signatures: json["signatures"] == null ? null : List.from(json["signatures"]!.map((x) => GetSignature.fromJson(x))), + sources: List.from(json["sources"].map((x) => Source.fromJson(x))), + ); + + Map toJson() => { + "children": children == null ? null : List.from(children!.map((x) => x.toJson())), + "flags": flags.toJson(), + "groups": groups == null ? null : List.from(groups!.map((x) => x.toJson())), + "id": id, + "kind": kind, + "kindString": kindString, + "name": name, + "signatures": signatures == null ? null : List.from(signatures!.map((x) => x.toJson())), + "sources": List.from(sources.map((x) => x.toJson())), + }; +} + +class FluffyTypeArgument { + final TypeEnum type; + final List types; + + FluffyTypeArgument({ + required this.type, + required this.types, + }); + + factory FluffyTypeArgument.fromJson(Map json) => FluffyTypeArgument( + type: typeEnumValues.map[json["type"]]!, + types: List.from(json["types"].map((x) => ElementType.fromJson(x))), + ); + + Map toJson() => { + "type": typeEnumValues.reverse[type], + "types": List.from(types.map((x) => x.toJson())), + }; +} + +class TypeParameter { + final PurpleComment? comment; + final GetSignatureFlags flags; + final int id; + final int kind; + final String kindString; + final String name; + final MischievousType? type; + + TypeParameter({ + this.comment, + required this.flags, + required this.id, + required this.kind, + required this.kindString, + required this.name, + this.type, + }); + + factory TypeParameter.fromJson(Map json) => TypeParameter( + comment: json["comment"] == null ? null : PurpleComment.fromJson(json["comment"]), + flags: GetSignatureFlags.fromJson(json["flags"]), + id: json["id"], + kind: json["kind"], + kindString: json["kindString"], + name: json["name"], + type: json["type"] == null ? null : MischievousType.fromJson(json["type"]), + ); + + Map toJson() => { + "comment": comment?.toJson(), + "flags": flags.toJson(), + "id": id, + "kind": kind, + "kindString": kindString, + "name": name, + "type": type?.toJson(), + }; +} + +class MischievousType { + final int? id; + final Name? name; + final ElementType? target; + final String type; + final String? typeOperator; + + MischievousType({ + this.id, + this.name, + this.target, + required this.type, + this.typeOperator, + }); + + factory MischievousType.fromJson(Map json) => MischievousType( + id: json["id"], + name: nameValues.map[json["name"]], + target: json["target"] == null ? null : ElementType.fromJson(json["target"]), + type: json["type"], + typeOperator: json["operator"], + ); + + Map toJson() => { + "id": id, + "name": nameValues.reverse[name], + "target": target?.toJson(), + "type": type, + "operator": typeOperator, + }; +} + +class IndecentComment { + final String shortText; + final List? tags; + + IndecentComment({ + required this.shortText, + this.tags, + }); + + factory IndecentComment.fromJson(Map json) => IndecentComment( + shortText: json["shortText"], + tags: json["tags"] == null ? null : List.from(json["tags"]!.map((x) => Tag.fromJson(x))), + ); + + Map toJson() => { + "shortText": shortText, + "tags": tags == null ? null : List.from(tags!.map((x) => x.toJson())), + }; +} + +enum TentacledKindString { + EXTERNAL_MODULE +} + +final tentacledKindStringValues = EnumValues({ + "External module": TentacledKindString.EXTERNAL_MODULE +}); + +class EnumValues { + Map map; + late Map reverseMap; + + EnumValues(this.map); + + Map get reverse { + reverseMap = map.map((k, v) => MapEntry(v, k)); + return reverseMap; + } +} diff --git a/head/dart/test/inputs/json/priority/combinations3.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations3.json/default/TopLevel.dart new file mode 100644 index 0000000..f08aef7 --- /dev/null +++ b/head/dart/test/inputs/json/priority/combinations3.json/default/TopLevel.dart @@ -0,0 +1,1537 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + final List juror; + final List kongoni; + final List ladronism; + final List landlubberly; + final List listener; + final List lupus; + final List maslin; + final List monazite; + final List monoliteral; + final List monotheistically; + final List montage; + final List moralness; + final List mowra; + final List mulishly; + final List myoscope; + final List?> nach; + final List neuromastic; + final List noncontributing; + final List nonnervous; + final List nonvaluation; + final List occupationalist; + final List outrival; + final List paleographically; + final List pamphletwise; + final List pediatrics; + final List perceptive; + final List piaculum; + final List piccadilly; + final List piffler; + final List pithful; + final List placuntitis; + final List plectopterous; + final List pneumocele; + final List poliorcetic; + final List poormaster; + final List potwhisky; + final List practicalizer; + final List prefreshman; + final List prehensility; + final List prevoidance; + final List> probant; + final List protext; + + TopLevel({ + required this.juror, + required this.kongoni, + required this.ladronism, + required this.landlubberly, + required this.listener, + required this.lupus, + required this.maslin, + required this.monazite, + required this.monoliteral, + required this.monotheistically, + required this.montage, + required this.moralness, + required this.mowra, + required this.mulishly, + required this.myoscope, + required this.nach, + required this.neuromastic, + required this.noncontributing, + required this.nonnervous, + required this.nonvaluation, + required this.occupationalist, + required this.outrival, + required this.paleographically, + required this.pamphletwise, + required this.pediatrics, + required this.perceptive, + required this.piaculum, + required this.piccadilly, + required this.piffler, + required this.pithful, + required this.placuntitis, + required this.plectopterous, + required this.pneumocele, + required this.poliorcetic, + required this.poormaster, + required this.potwhisky, + required this.practicalizer, + required this.prefreshman, + required this.prehensility, + required this.prevoidance, + required this.probant, + required this.protext, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + juror: List.from(json["juror"].map((x) => x)), + kongoni: List.from(json["kongoni"].map((x) => x)), + ladronism: List.from(json["ladronism"].map((x) => x)), + landlubberly: List.from(json["landlubberly"].map((x) => x)), + listener: List.from(json["listener"].map((x) => x)), + lupus: List.from(json["lupus"].map((x) => x)), + maslin: List.from(json["maslin"].map((x) => Maslin.fromJson(x))), + monazite: List.from(json["monazite"].map((x) => x)), + monoliteral: List.from(json["monoliteral"].map((x) => x)), + monotheistically: List.from(json["monotheistically"].map((x) => x)), + montage: List.from(json["montage"].map((x) => x)), + moralness: List.from(json["moralness"].map((x) => x)), + mowra: List.from(json["mowra"].map((x) => x == null ? null : MonaziteClass.fromJson(x))), + mulishly: List.from(json["mulishly"].map((x) => x)), + myoscope: List.from(json["myoscope"].map((x) => x)), + nach: List?>.from(json["nach"].map((x) => x == null ? null : List.from(x!.map((x) => x)))), + neuromastic: List.from(json["neuromastic"].map((x) => x)), + noncontributing: List.from(json["noncontributing"].map((x) => Noncontributing.fromJson(x))), + nonnervous: List.from(json["nonnervous"].map((x) => x)), + nonvaluation: List.from(json["nonvaluation"].map((x) => x)), + occupationalist: List.from(json["occupationalist"].map((x) => x)), + outrival: List.from(json["outrival"].map((x) => x)), + paleographically: List.from(json["paleographically"].map((x) => x)), + pamphletwise: List.from(json["pamphletwise"].map((x) => x)), + pediatrics: List.from(json["pediatrics"].map((x) => x)), + perceptive: List.from(json["perceptive"].map((x) => x)), + piaculum: List.from(json["piaculum"].map((x) => x)), + piccadilly: List.from(json["piccadilly"].map((x) => x)), + piffler: List.from(json["piffler"].map((x) => x)), + pithful: List.from(json["pithful"].map((x) => x)), + placuntitis: List.from(json["placuntitis"].map((x) => x)), + plectopterous: List.from(json["plectopterous"].map((x) => x)), + pneumocele: List.from(json["pneumocele"].map((x) => x == null ? null : Pneumocele.fromJson(x))), + poliorcetic: List.from(json["poliorcetic"].map((x) => x)), + poormaster: List.from(json["poormaster"].map((x) => x)), + potwhisky: List.from(json["potwhisky"].map((x) => x)), + practicalizer: List.from(json["practicalizer"].map((x) => x)), + prefreshman: List.from(json["prefreshman"].map((x) => x)), + prehensility: List.from(json["prehensility"].map((x) => x)), + prevoidance: List.from(json["prevoidance"].map((x) => x)), + probant: List>.from(json["probant"].map((x) => Map.from(x).map((k, v) => MapEntry(k, v)))), + protext: List.from(json["protext"].map((x) => x)), + ); + + Map toJson() => { + "juror": List.from(juror.map((x) => x)), + "kongoni": List.from(kongoni.map((x) => x)), + "ladronism": List.from(ladronism.map((x) => x)), + "landlubberly": List.from(landlubberly.map((x) => x)), + "listener": List.from(listener.map((x) => x)), + "lupus": List.from(lupus.map((x) => x)), + "maslin": List.from(maslin.map((x) => x.toJson())), + "monazite": List.from(monazite.map((x) => x)), + "monoliteral": List.from(monoliteral.map((x) => x)), + "monotheistically": List.from(monotheistically.map((x) => x)), + "montage": List.from(montage.map((x) => x)), + "moralness": List.from(moralness.map((x) => x)), + "mowra": List.from(mowra.map((x) => x?.toJson())), + "mulishly": List.from(mulishly.map((x) => x)), + "myoscope": List.from(myoscope.map((x) => x)), + "nach": List.from(nach.map((x) => x == null ? null : List.from(x!.map((x) => x)))), + "neuromastic": List.from(neuromastic.map((x) => x)), + "noncontributing": List.from(noncontributing.map((x) => x.toJson())), + "nonnervous": List.from(nonnervous.map((x) => x)), + "nonvaluation": List.from(nonvaluation.map((x) => x)), + "occupationalist": List.from(occupationalist.map((x) => x)), + "outrival": List.from(outrival.map((x) => x)), + "paleographically": List.from(paleographically.map((x) => x)), + "pamphletwise": List.from(pamphletwise.map((x) => x)), + "pediatrics": List.from(pediatrics.map((x) => x)), + "perceptive": List.from(perceptive.map((x) => x)), + "piaculum": List.from(piaculum.map((x) => x)), + "piccadilly": List.from(piccadilly.map((x) => x)), + "piffler": List.from(piffler.map((x) => x)), + "pithful": List.from(pithful.map((x) => x)), + "placuntitis": List.from(placuntitis.map((x) => x)), + "plectopterous": List.from(plectopterous.map((x) => x)), + "pneumocele": List.from(pneumocele.map((x) => x?.toJson())), + "poliorcetic": List.from(poliorcetic.map((x) => x)), + "poormaster": List.from(poormaster.map((x) => x)), + "potwhisky": List.from(potwhisky.map((x) => x)), + "practicalizer": List.from(practicalizer.map((x) => x)), + "prefreshman": List.from(prefreshman.map((x) => x)), + "prehensility": List.from(prehensility.map((x) => x)), + "prevoidance": List.from(prevoidance.map((x) => x)), + "probant": List.from(probant.map((x) => Map.from(x).map((k, v) => MapEntry(k, v)))), + "protext": List.from(protext.map((x) => x)), + }; +} + +class JurorClass { + final dynamic adipsy; + final dynamic auxiliator; + final dynamic benda; + final dynamic benjamin; + final dynamic brandling; + final dynamic epicurishly; + final dynamic eremochaetous; + final dynamic marten; + final dynamic monocline; + final dynamic olea; + final dynamic palgat; + final dynamic pennyworth; + final dynamic pioury; + final dynamic pragmatistic; + final dynamic stylelessness; + final dynamic systematical; + final dynamic thready; + final dynamic uncontemporary; + final dynamic uncouched; + final dynamic uninhabitedness; + + JurorClass({ + required this.adipsy, + required this.auxiliator, + required this.benda, + required this.benjamin, + required this.brandling, + required this.epicurishly, + required this.eremochaetous, + required this.marten, + required this.monocline, + required this.olea, + required this.palgat, + required this.pennyworth, + required this.pioury, + required this.pragmatistic, + required this.stylelessness, + required this.systematical, + required this.thready, + required this.uncontemporary, + required this.uncouched, + required this.uninhabitedness, + }); + + factory JurorClass.fromJson(Map json) => JurorClass( + adipsy: json["adipsy"], + auxiliator: json["auxiliator"], + benda: json["benda"], + benjamin: json["benjamin"], + brandling: json["brandling"], + epicurishly: json["epicurishly"], + eremochaetous: json["eremochaetous"], + marten: json["marten"], + monocline: json["monocline"], + olea: json["Olea"], + palgat: json["palgat"], + pennyworth: json["pennyworth"], + pioury: json["pioury"], + pragmatistic: json["pragmatistic"], + stylelessness: json["stylelessness"], + systematical: json["systematical"], + thready: json["thready"], + uncontemporary: json["uncontemporary"], + uncouched: json["uncouched"], + uninhabitedness: json["uninhabitedness"], + ); + + Map toJson() => { + "adipsy": adipsy, + "auxiliator": auxiliator, + "benda": benda, + "benjamin": benjamin, + "brandling": brandling, + "epicurishly": epicurishly, + "eremochaetous": eremochaetous, + "marten": marten, + "monocline": monocline, + "Olea": olea, + "palgat": palgat, + "pennyworth": pennyworth, + "pioury": pioury, + "pragmatistic": pragmatistic, + "stylelessness": stylelessness, + "systematical": systematical, + "thready": thready, + "uncontemporary": uncontemporary, + "uncouched": uncouched, + "uninhabitedness": uninhabitedness, + }; +} + +class LadronismClass { + final dynamic acclaimer; + final dynamic achree; + final dynamic base; + final dynamic conundrumize; + final dynamic degerminator; + final dynamic describable; + final dynamic exasperatedly; + final dynamic heroine; + final dynamic indazin; + final dynamic luteous; + final dynamic papular; + final dynamic pritch; + final dynamic prodenia; + final dynamic seege; + final dynamic shopgirl; + final dynamic tragedietta; + final dynamic unsparse; + final dynamic uplook; + final dynamic vermiformis; + final dynamic whafabout; + + LadronismClass({ + required this.acclaimer, + required this.achree, + required this.base, + required this.conundrumize, + required this.degerminator, + required this.describable, + required this.exasperatedly, + required this.heroine, + required this.indazin, + required this.luteous, + required this.papular, + required this.pritch, + required this.prodenia, + required this.seege, + required this.shopgirl, + required this.tragedietta, + required this.unsparse, + required this.uplook, + required this.vermiformis, + required this.whafabout, + }); + + factory LadronismClass.fromJson(Map json) => LadronismClass( + acclaimer: json["acclaimer"], + achree: json["achree"], + base: json["base"], + conundrumize: json["conundrumize"], + degerminator: json["degerminator"], + describable: json["describable"], + exasperatedly: json["exasperatedly"], + heroine: json["heroine"], + indazin: json["indazin"], + luteous: json["luteous"], + papular: json["papular"], + pritch: json["pritch"], + prodenia: json["Prodenia"], + seege: json["seege"], + shopgirl: json["shopgirl"], + tragedietta: json["tragedietta"], + unsparse: json["unsparse"], + uplook: json["uplook"], + vermiformis: json["vermiformis"], + whafabout: json["whafabout"], + ); + + Map toJson() => { + "acclaimer": acclaimer, + "achree": achree, + "base": base, + "conundrumize": conundrumize, + "degerminator": degerminator, + "describable": describable, + "exasperatedly": exasperatedly, + "heroine": heroine, + "indazin": indazin, + "luteous": luteous, + "papular": papular, + "pritch": pritch, + "Prodenia": prodenia, + "seege": seege, + "shopgirl": shopgirl, + "tragedietta": tragedietta, + "unsparse": unsparse, + "uplook": uplook, + "vermiformis": vermiformis, + "whafabout": whafabout, + }; +} + +class LandlubberlyClass { + final dynamic acropoleis; + final dynamic aminate; + final dynamic amyraldism; + final dynamic bipenniform; + final dynamic bugre; + final dynamic calycule; + final dynamic caoutchouc; + final dynamic disprover; + final dynamic fitroot; + final dynamic fulgently; + final dynamic kickup; + final dynamic laevoversion; + final dynamic moter; + final dynamic objectivity; + final dynamic posterity; + final dynamic postnuptial; + final dynamic precedentary; + final dynamic saddling; + final dynamic subcurrent; + final dynamic unrecriminative; + + LandlubberlyClass({ + required this.acropoleis, + required this.aminate, + required this.amyraldism, + required this.bipenniform, + required this.bugre, + required this.calycule, + required this.caoutchouc, + required this.disprover, + required this.fitroot, + required this.fulgently, + required this.kickup, + required this.laevoversion, + required this.moter, + required this.objectivity, + required this.posterity, + required this.postnuptial, + required this.precedentary, + required this.saddling, + required this.subcurrent, + required this.unrecriminative, + }); + + factory LandlubberlyClass.fromJson(Map json) => LandlubberlyClass( + acropoleis: json["acropoleis"], + aminate: json["aminate"], + amyraldism: json["Amyraldism"], + bipenniform: json["bipenniform"], + bugre: json["bugre"], + calycule: json["calycule"], + caoutchouc: json["caoutchouc"], + disprover: json["disprover"], + fitroot: json["fitroot"], + fulgently: json["fulgently"], + kickup: json["kickup"], + laevoversion: json["laevoversion"], + moter: json["moter"], + objectivity: json["objectivity"], + posterity: json["posterity"], + postnuptial: json["postnuptial"], + precedentary: json["precedentary"], + saddling: json["saddling"], + subcurrent: json["subcurrent"], + unrecriminative: json["unrecriminative"], + ); + + Map toJson() => { + "acropoleis": acropoleis, + "aminate": aminate, + "Amyraldism": amyraldism, + "bipenniform": bipenniform, + "bugre": bugre, + "calycule": calycule, + "caoutchouc": caoutchouc, + "disprover": disprover, + "fitroot": fitroot, + "fulgently": fulgently, + "kickup": kickup, + "laevoversion": laevoversion, + "moter": moter, + "objectivity": objectivity, + "posterity": posterity, + "postnuptial": postnuptial, + "precedentary": precedentary, + "saddling": saddling, + "subcurrent": subcurrent, + "unrecriminative": unrecriminative, + }; +} + +class LupusClass { + final double? catharticalness; + final int? chirotherium; + final int? chlorioninae; + final int? corvinae; + final int? crassina; + final String? disdiapason; + final int? exiguity; + final int? farcist; + final int? holographical; + final bool? homocerc; + final int? ichthyophagan; + final int? implacable; + final dynamic nonbookish; + final int? outshiner; + final int? overweather; + final int? protonegroid; + final int? shallowish; + final int? snoke; + final int? snout; + final int? surveillance; + final int? threshingtime; + final int? thysanocarpus; + final int? unsignificantly; + final int? unsnap; + final int? vendible; + + LupusClass({ + this.catharticalness, + this.chirotherium, + this.chlorioninae, + this.corvinae, + this.crassina, + this.disdiapason, + this.exiguity, + this.farcist, + this.holographical, + this.homocerc, + this.ichthyophagan, + this.implacable, + this.nonbookish, + this.outshiner, + this.overweather, + this.protonegroid, + this.shallowish, + this.snoke, + this.snout, + this.surveillance, + this.threshingtime, + this.thysanocarpus, + this.unsignificantly, + this.unsnap, + this.vendible, + }); + + factory LupusClass.fromJson(Map json) => LupusClass( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + chlorioninae: json["Chlorioninae"], + corvinae: json["Corvinae"], + crassina: json["Crassina"], + disdiapason: json["disdiapason"], + exiguity: json["exiguity"], + farcist: json["farcist"], + holographical: json["holographical"], + homocerc: json["homocerc"], + ichthyophagan: json["ichthyophagan"], + implacable: json["implacable"], + nonbookish: json["nonbookish"], + outshiner: json["outshiner"], + overweather: json["overweather"], + protonegroid: json["protonegroid"], + shallowish: json["shallowish"], + snoke: json["snoke"], + snout: json["snout"], + surveillance: json["surveillance"], + threshingtime: json["threshingtime"], + thysanocarpus: json["Thysanocarpus"], + unsignificantly: json["unsignificantly"], + unsnap: json["unsnap"], + vendible: json["vendible"], + ); + + Map toJson() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "Chlorioninae": chlorioninae, + "Corvinae": corvinae, + "Crassina": crassina, + "disdiapason": disdiapason, + "exiguity": exiguity, + "farcist": farcist, + "holographical": holographical, + "homocerc": homocerc, + "ichthyophagan": ichthyophagan, + "implacable": implacable, + "nonbookish": nonbookish, + "outshiner": outshiner, + "overweather": overweather, + "protonegroid": protonegroid, + "shallowish": shallowish, + "snoke": snoke, + "snout": snout, + "surveillance": surveillance, + "threshingtime": threshingtime, + "Thysanocarpus": thysanocarpus, + "unsignificantly": unsignificantly, + "unsnap": unsnap, + "vendible": vendible, + }; +} + +class Maslin { + final int? alicant; + final dynamic antiatonement; + final int? anticorrosive; + final dynamic aphidozer; + final dynamic bakuninist; + final int? be; + final double? catharticalness; + final int? chirotherium; + final int? chub; + final int? cuprosilicon; + final int? curtailedly; + final int? dellenite; + final int? dimitry; + final String? disdiapason; + final dynamic edifying; + final int? ethmoiditis; + final dynamic gastralgy; + final int? goatherd; + final int? hammerdress; + final dynamic hangfire; + final bool? homocerc; + final int? lacunosity; + final dynamic longiloquence; + final int? mameliere; + final dynamic motherless; + final dynamic nonbookish; + final dynamic noncorrodible; + final dynamic nonsensicality; + final int? oafishly; + final dynamic pfund; + final dynamic preadvisory; + final dynamic retroflexed; + final int? saccharulmic; + final int? scowlful; + final dynamic secluded; + final dynamic slackage; + final int? sphaeridial; + final dynamic spondulics; + final int? subsecive; + final dynamic swellmobsman; + final int? trachyglossate; + final dynamic trialogue; + final int? unassuaged; + final dynamic ungross; + final dynamic unjudiciously; + + Maslin({ + this.alicant, + this.antiatonement, + this.anticorrosive, + this.aphidozer, + this.bakuninist, + this.be, + this.catharticalness, + this.chirotherium, + this.chub, + this.cuprosilicon, + this.curtailedly, + this.dellenite, + this.dimitry, + this.disdiapason, + this.edifying, + this.ethmoiditis, + this.gastralgy, + this.goatherd, + this.hammerdress, + this.hangfire, + this.homocerc, + this.lacunosity, + this.longiloquence, + this.mameliere, + this.motherless, + this.nonbookish, + this.noncorrodible, + this.nonsensicality, + this.oafishly, + this.pfund, + this.preadvisory, + this.retroflexed, + this.saccharulmic, + this.scowlful, + this.secluded, + this.slackage, + this.sphaeridial, + this.spondulics, + this.subsecive, + this.swellmobsman, + this.trachyglossate, + this.trialogue, + this.unassuaged, + this.ungross, + this.unjudiciously, + }); + + factory Maslin.fromJson(Map json) => Maslin( + alicant: json["Alicant"], + antiatonement: json["antiatonement"], + anticorrosive: json["anticorrosive"], + aphidozer: json["aphidozer"], + bakuninist: json["Bakuninist"], + be: json["be"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + chub: json["chub"], + cuprosilicon: json["cuprosilicon"], + curtailedly: json["curtailedly"], + dellenite: json["dellenite"], + dimitry: json["Dimitry"], + disdiapason: json["disdiapason"], + edifying: json["edifying"], + ethmoiditis: json["ethmoiditis"], + gastralgy: json["gastralgy"], + goatherd: json["goatherd"], + hammerdress: json["hammerdress"], + hangfire: json["hangfire"], + homocerc: json["homocerc"], + lacunosity: json["lacunosity"], + longiloquence: json["longiloquence"], + mameliere: json["mameliere"], + motherless: json["motherless"], + nonbookish: json["nonbookish"], + noncorrodible: json["noncorrodible"], + nonsensicality: json["nonsensicality"], + oafishly: json["oafishly"], + pfund: json["pfund"], + preadvisory: json["preadvisory"], + retroflexed: json["retroflexed"], + saccharulmic: json["saccharulmic"], + scowlful: json["scowlful"], + secluded: json["secluded"], + slackage: json["slackage"], + sphaeridial: json["sphaeridial"], + spondulics: json["spondulics"], + subsecive: json["subsecive"], + swellmobsman: json["swellmobsman"], + trachyglossate: json["trachyglossate"], + trialogue: json["trialogue"], + unassuaged: json["unassuaged"], + ungross: json["ungross"], + unjudiciously: json["unjudiciously"], + ); + + Map toJson() => { + "Alicant": alicant, + "antiatonement": antiatonement, + "anticorrosive": anticorrosive, + "aphidozer": aphidozer, + "Bakuninist": bakuninist, + "be": be, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "chub": chub, + "cuprosilicon": cuprosilicon, + "curtailedly": curtailedly, + "dellenite": dellenite, + "Dimitry": dimitry, + "disdiapason": disdiapason, + "edifying": edifying, + "ethmoiditis": ethmoiditis, + "gastralgy": gastralgy, + "goatherd": goatherd, + "hammerdress": hammerdress, + "hangfire": hangfire, + "homocerc": homocerc, + "lacunosity": lacunosity, + "longiloquence": longiloquence, + "mameliere": mameliere, + "motherless": motherless, + "nonbookish": nonbookish, + "noncorrodible": noncorrodible, + "nonsensicality": nonsensicality, + "oafishly": oafishly, + "pfund": pfund, + "preadvisory": preadvisory, + "retroflexed": retroflexed, + "saccharulmic": saccharulmic, + "scowlful": scowlful, + "secluded": secluded, + "slackage": slackage, + "sphaeridial": sphaeridial, + "spondulics": spondulics, + "subsecive": subsecive, + "swellmobsman": swellmobsman, + "trachyglossate": trachyglossate, + "trialogue": trialogue, + "unassuaged": unassuaged, + "ungross": ungross, + "unjudiciously": unjudiciously, + }; +} + +class MonaziteClass { + final double catharticalness; + final int chirotherium; + final String disdiapason; + final bool homocerc; + final dynamic nonbookish; + + MonaziteClass({ + required this.catharticalness, + required this.chirotherium, + required this.disdiapason, + required this.homocerc, + required this.nonbookish, + }); + + factory MonaziteClass.fromJson(Map json) => MonaziteClass( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + homocerc: json["homocerc"], + nonbookish: json["nonbookish"], + ); + + Map toJson() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "homocerc": homocerc, + "nonbookish": nonbookish, + }; +} + +class MonotheisticallyClass { + final dynamic blaspheme; + final double? catharticalness; + final dynamic celiosalpingectomy; + final int? chirotherium; + final dynamic consummativeness; + final String? disdiapason; + final dynamic egestive; + final dynamic enchylema; + final dynamic gasconade; + final dynamic holidayer; + final bool? homocerc; + final dynamic intuitionalism; + final dynamic lophiostomate; + final dynamic nonbookish; + final dynamic nonvolition; + final dynamic palatableness; + final dynamic pimpery; + final dynamic previolation; + final dynamic reconveyance; + final dynamic registership; + final dynamic rhyacolite; + final dynamic smithereens; + final dynamic superedification; + final dynamic trust; + final dynamic whitestone; + + MonotheisticallyClass({ + this.blaspheme, + this.catharticalness, + this.celiosalpingectomy, + this.chirotherium, + this.consummativeness, + this.disdiapason, + this.egestive, + this.enchylema, + this.gasconade, + this.holidayer, + this.homocerc, + this.intuitionalism, + this.lophiostomate, + this.nonbookish, + this.nonvolition, + this.palatableness, + this.pimpery, + this.previolation, + this.reconveyance, + this.registership, + this.rhyacolite, + this.smithereens, + this.superedification, + this.trust, + this.whitestone, + }); + + factory MonotheisticallyClass.fromJson(Map json) => MonotheisticallyClass( + blaspheme: json["blaspheme"], + catharticalness: json["catharticalness"]?.toDouble(), + celiosalpingectomy: json["celiosalpingectomy"], + chirotherium: json["Chirotherium"], + consummativeness: json["consummativeness"], + disdiapason: json["disdiapason"], + egestive: json["egestive"], + enchylema: json["enchylema"], + gasconade: json["gasconade"], + holidayer: json["holidayer"], + homocerc: json["homocerc"], + intuitionalism: json["intuitionalism"], + lophiostomate: json["lophiostomate"], + nonbookish: json["nonbookish"], + nonvolition: json["nonvolition"], + palatableness: json["palatableness"], + pimpery: json["pimpery"], + previolation: json["previolation"], + reconveyance: json["reconveyance"], + registership: json["registership"], + rhyacolite: json["rhyacolite"], + smithereens: json["smithereens"], + superedification: json["superedification"], + trust: json["trust"], + whitestone: json["whitestone"], + ); + + Map toJson() => { + "blaspheme": blaspheme, + "catharticalness": catharticalness, + "celiosalpingectomy": celiosalpingectomy, + "Chirotherium": chirotherium, + "consummativeness": consummativeness, + "disdiapason": disdiapason, + "egestive": egestive, + "enchylema": enchylema, + "gasconade": gasconade, + "holidayer": holidayer, + "homocerc": homocerc, + "intuitionalism": intuitionalism, + "lophiostomate": lophiostomate, + "nonbookish": nonbookish, + "nonvolition": nonvolition, + "palatableness": palatableness, + "pimpery": pimpery, + "previolation": previolation, + "reconveyance": reconveyance, + "registership": registership, + "rhyacolite": rhyacolite, + "smithereens": smithereens, + "superedification": superedification, + "trust": trust, + "whitestone": whitestone, + }; +} + +class Noncontributing { + final String estevin; + final double jolterhead; + final int sauternes; + final bool sparsely; + final dynamic unrequested; + + Noncontributing({ + required this.estevin, + required this.jolterhead, + required this.sauternes, + required this.sparsely, + required this.unrequested, + }); + + factory Noncontributing.fromJson(Map json) => Noncontributing( + estevin: json["estevin"], + jolterhead: json["jolterhead"]?.toDouble(), + sauternes: json["sauternes"], + sparsely: json["sparsely"], + unrequested: json["unrequested"], + ); + + Map toJson() => { + "estevin": estevin, + "jolterhead": jolterhead, + "sauternes": sauternes, + "sparsely": sparsely, + "unrequested": unrequested, + }; +} + +class OccupationalistClass { + final dynamic beholdable; + final dynamic brotuliform; + final dynamic chimakum; + final dynamic doodler; + final dynamic emulsin; + final dynamic fin; + final dynamic flourishing; + final dynamic flueless; + final dynamic furtively; + final dynamic gritter; + final dynamic interwish; + final dynamic monoxylic; + final dynamic myristic; + final dynamic nightwear; + final dynamic peruser; + final dynamic theoastrological; + final dynamic thumby; + final dynamic tingitid; + final dynamic trailless; + final dynamic unpocketed; + + OccupationalistClass({ + required this.beholdable, + required this.brotuliform, + required this.chimakum, + required this.doodler, + required this.emulsin, + required this.fin, + required this.flourishing, + required this.flueless, + required this.furtively, + required this.gritter, + required this.interwish, + required this.monoxylic, + required this.myristic, + required this.nightwear, + required this.peruser, + required this.theoastrological, + required this.thumby, + required this.tingitid, + required this.trailless, + required this.unpocketed, + }); + + factory OccupationalistClass.fromJson(Map json) => OccupationalistClass( + beholdable: json["beholdable"], + brotuliform: json["brotuliform"], + chimakum: json["Chimakum"], + doodler: json["doodler"], + emulsin: json["emulsin"], + fin: json["Fin"], + flourishing: json["flourishing"], + flueless: json["flueless"], + furtively: json["furtively"], + gritter: json["gritter"], + interwish: json["interwish"], + monoxylic: json["monoxylic"], + myristic: json["myristic"], + nightwear: json["nightwear"], + peruser: json["peruser"], + theoastrological: json["theoastrological"], + thumby: json["thumby"], + tingitid: json["tingitid"], + trailless: json["trailless"], + unpocketed: json["unpocketed"], + ); + + Map toJson() => { + "beholdable": beholdable, + "brotuliform": brotuliform, + "Chimakum": chimakum, + "doodler": doodler, + "emulsin": emulsin, + "Fin": fin, + "flourishing": flourishing, + "flueless": flueless, + "furtively": furtively, + "gritter": gritter, + "interwish": interwish, + "monoxylic": monoxylic, + "myristic": myristic, + "nightwear": nightwear, + "peruser": peruser, + "theoastrological": theoastrological, + "thumby": thumby, + "tingitid": tingitid, + "trailless": trailless, + "unpocketed": unpocketed, + }; +} + +class OutrivalClass { + final dynamic adroitly; + final dynamic bridehood; + final dynamic castoroides; + final dynamic czechoslovak; + final dynamic diagenesis; + final dynamic dihexahedron; + final dynamic dopester; + final dynamic eumerism; + final dynamic flyness; + final dynamic fouler; + final dynamic laudanosine; + final dynamic lingulidae; + final dynamic minutary; + final dynamic mitra; + final dynamic opisthorchiasis; + final dynamic pensively; + final dynamic pubigerous; + final dynamic rebellious; + final dynamic recodify; + final dynamic unpaced; + + OutrivalClass({ + required this.adroitly, + required this.bridehood, + required this.castoroides, + required this.czechoslovak, + required this.diagenesis, + required this.dihexahedron, + required this.dopester, + required this.eumerism, + required this.flyness, + required this.fouler, + required this.laudanosine, + required this.lingulidae, + required this.minutary, + required this.mitra, + required this.opisthorchiasis, + required this.pensively, + required this.pubigerous, + required this.rebellious, + required this.recodify, + required this.unpaced, + }); + + factory OutrivalClass.fromJson(Map json) => OutrivalClass( + adroitly: json["adroitly"], + bridehood: json["bridehood"], + castoroides: json["Castoroides"], + czechoslovak: json["Czechoslovak"], + diagenesis: json["diagenesis"], + dihexahedron: json["dihexahedron"], + dopester: json["dopester"], + eumerism: json["eumerism"], + flyness: json["flyness"], + fouler: json["fouler"], + laudanosine: json["laudanosine"], + lingulidae: json["Lingulidae"], + minutary: json["minutary"], + mitra: json["mitra"], + opisthorchiasis: json["opisthorchiasis"], + pensively: json["pensively"], + pubigerous: json["pubigerous"], + rebellious: json["rebellious"], + recodify: json["recodify"], + unpaced: json["unpaced"], + ); + + Map toJson() => { + "adroitly": adroitly, + "bridehood": bridehood, + "Castoroides": castoroides, + "Czechoslovak": czechoslovak, + "diagenesis": diagenesis, + "dihexahedron": dihexahedron, + "dopester": dopester, + "eumerism": eumerism, + "flyness": flyness, + "fouler": fouler, + "laudanosine": laudanosine, + "Lingulidae": lingulidae, + "minutary": minutary, + "mitra": mitra, + "opisthorchiasis": opisthorchiasis, + "pensively": pensively, + "pubigerous": pubigerous, + "rebellious": rebellious, + "recodify": recodify, + "unpaced": unpaced, + }; +} + +class PiaculumClass { + final int? alada; + final int? amphistomous; + final int? boysenberry; + final double? catharticalness; + final int? chirotherium; + final int? decardinalize; + final int? discouragement; + final String? disdiapason; + final int? doitrified; + final int? hexaspermous; + final bool? homocerc; + final int? insinking; + final int? loathfulness; + final int? miasmatical; + final int? neurofibril; + final dynamic nonbookish; + final int? phonendoscope; + final int? pilferment; + final int? predismissory; + final int? preinscription; + final int? quotative; + final int? sienna; + final int? thorax; + final int? yachting; + final int? zipper; + + PiaculumClass({ + this.alada, + this.amphistomous, + this.boysenberry, + this.catharticalness, + this.chirotherium, + this.decardinalize, + this.discouragement, + this.disdiapason, + this.doitrified, + this.hexaspermous, + this.homocerc, + this.insinking, + this.loathfulness, + this.miasmatical, + this.neurofibril, + this.nonbookish, + this.phonendoscope, + this.pilferment, + this.predismissory, + this.preinscription, + this.quotative, + this.sienna, + this.thorax, + this.yachting, + this.zipper, + }); + + factory PiaculumClass.fromJson(Map json) => PiaculumClass( + alada: json["alada"], + amphistomous: json["amphistomous"], + boysenberry: json["boysenberry"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + decardinalize: json["decardinalize"], + discouragement: json["discouragement"], + disdiapason: json["disdiapason"], + doitrified: json["doitrified"], + hexaspermous: json["hexaspermous"], + homocerc: json["homocerc"], + insinking: json["insinking"], + loathfulness: json["loathfulness"], + miasmatical: json["miasmatical"], + neurofibril: json["neurofibril"], + nonbookish: json["nonbookish"], + phonendoscope: json["phonendoscope"], + pilferment: json["pilferment"], + predismissory: json["predismissory"], + preinscription: json["preinscription"], + quotative: json["quotative"], + sienna: json["sienna"], + thorax: json["thorax"], + yachting: json["yachting"], + zipper: json["Zipper"], + ); + + Map toJson() => { + "alada": alada, + "amphistomous": amphistomous, + "boysenberry": boysenberry, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "decardinalize": decardinalize, + "discouragement": discouragement, + "disdiapason": disdiapason, + "doitrified": doitrified, + "hexaspermous": hexaspermous, + "homocerc": homocerc, + "insinking": insinking, + "loathfulness": loathfulness, + "miasmatical": miasmatical, + "neurofibril": neurofibril, + "nonbookish": nonbookish, + "phonendoscope": phonendoscope, + "pilferment": pilferment, + "predismissory": predismissory, + "preinscription": preinscription, + "quotative": quotative, + "sienna": sienna, + "thorax": thorax, + "yachting": yachting, + "Zipper": zipper, + }; +} + +class Pneumocele { + final dynamic carbonarism; + final double? catharticalness; + final int? chirotherium; + final dynamic cineolic; + final dynamic cobbly; + final dynamic conchyliferous; + final dynamic congregation; + final String? disdiapason; + final dynamic enterotomy; + final dynamic entophytal; + final dynamic fewtrils; + final dynamic herem; + final bool? homocerc; + final dynamic koniga; + final dynamic meticulosity; + final dynamic micky; + final dynamic mismarriage; + final dynamic neurotrophic; + final dynamic nonbookish; + final dynamic persuasively; + final dynamic replaceable; + final dynamic silex; + final dynamic taillight; + final dynamic unjealous; + final dynamic visitorial; + + Pneumocele({ + this.carbonarism, + this.catharticalness, + this.chirotherium, + this.cineolic, + this.cobbly, + this.conchyliferous, + this.congregation, + this.disdiapason, + this.enterotomy, + this.entophytal, + this.fewtrils, + this.herem, + this.homocerc, + this.koniga, + this.meticulosity, + this.micky, + this.mismarriage, + this.neurotrophic, + this.nonbookish, + this.persuasively, + this.replaceable, + this.silex, + this.taillight, + this.unjealous, + this.visitorial, + }); + + factory Pneumocele.fromJson(Map json) => Pneumocele( + carbonarism: json["Carbonarism"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + cineolic: json["cineolic"], + cobbly: json["cobbly"], + conchyliferous: json["conchyliferous"], + congregation: json["congregation"], + disdiapason: json["disdiapason"], + enterotomy: json["enterotomy"], + entophytal: json["entophytal"], + fewtrils: json["fewtrils"], + herem: json["herem"], + homocerc: json["homocerc"], + koniga: json["Koniga"], + meticulosity: json["meticulosity"], + micky: json["Micky"], + mismarriage: json["mismarriage"], + neurotrophic: json["neurotrophic"], + nonbookish: json["nonbookish"], + persuasively: json["persuasively"], + replaceable: json["replaceable"], + silex: json["silex"], + taillight: json["taillight"], + unjealous: json["unjealous"], + visitorial: json["visitorial"], + ); + + Map toJson() => { + "Carbonarism": carbonarism, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "cineolic": cineolic, + "cobbly": cobbly, + "conchyliferous": conchyliferous, + "congregation": congregation, + "disdiapason": disdiapason, + "enterotomy": enterotomy, + "entophytal": entophytal, + "fewtrils": fewtrils, + "herem": herem, + "homocerc": homocerc, + "Koniga": koniga, + "meticulosity": meticulosity, + "Micky": micky, + "mismarriage": mismarriage, + "neurotrophic": neurotrophic, + "nonbookish": nonbookish, + "persuasively": persuasively, + "replaceable": replaceable, + "silex": silex, + "taillight": taillight, + "unjealous": unjealous, + "visitorial": visitorial, + }; +} + +class PotwhiskyClass { + final dynamic arciform; + final dynamic cresolin; + final dynamic disheartener; + final dynamic disproportionable; + final dynamic euchorda; + final dynamic ferryway; + final dynamic filamentiferous; + final dynamic flemish; + final dynamic forgainst; + final dynamic grainering; + final dynamic irrevoluble; + final dynamic kindredship; + final dynamic pinguitudinous; + final dynamic simpletonic; + final dynamic singsong; + final dynamic submergement; + final dynamic supraoesophagal; + final dynamic thrashel; + final dynamic tyremesis; + final dynamic yoruba; + + PotwhiskyClass({ + required this.arciform, + required this.cresolin, + required this.disheartener, + required this.disproportionable, + required this.euchorda, + required this.ferryway, + required this.filamentiferous, + required this.flemish, + required this.forgainst, + required this.grainering, + required this.irrevoluble, + required this.kindredship, + required this.pinguitudinous, + required this.simpletonic, + required this.singsong, + required this.submergement, + required this.supraoesophagal, + required this.thrashel, + required this.tyremesis, + required this.yoruba, + }); + + factory PotwhiskyClass.fromJson(Map json) => PotwhiskyClass( + arciform: json["arciform"], + cresolin: json["cresolin"], + disheartener: json["disheartener"], + disproportionable: json["disproportionable"], + euchorda: json["Euchorda"], + ferryway: json["ferryway"], + filamentiferous: json["filamentiferous"], + flemish: json["flemish"], + forgainst: json["forgainst"], + grainering: json["grainering"], + irrevoluble: json["irrevoluble"], + kindredship: json["kindredship"], + pinguitudinous: json["pinguitudinous"], + simpletonic: json["simpletonic"], + singsong: json["singsong"], + submergement: json["submergement"], + supraoesophagal: json["supraoesophagal"], + thrashel: json["thrashel"], + tyremesis: json["tyremesis"], + yoruba: json["Yoruba"], + ); + + Map toJson() => { + "arciform": arciform, + "cresolin": cresolin, + "disheartener": disheartener, + "disproportionable": disproportionable, + "Euchorda": euchorda, + "ferryway": ferryway, + "filamentiferous": filamentiferous, + "flemish": flemish, + "forgainst": forgainst, + "grainering": grainering, + "irrevoluble": irrevoluble, + "kindredship": kindredship, + "pinguitudinous": pinguitudinous, + "simpletonic": simpletonic, + "singsong": singsong, + "submergement": submergement, + "supraoesophagal": supraoesophagal, + "thrashel": thrashel, + "tyremesis": tyremesis, + "Yoruba": yoruba, + }; +} + +class PrefreshmanClass { + final dynamic azorubine; + final dynamic choroiditis; + final dynamic coagulatory; + final dynamic cyclorama; + final dynamic dolphus; + final dynamic duckhearted; + final dynamic ficus; + final dynamic gemaric; + final dynamic jugation; + final dynamic myoliposis; + final dynamic nonnomination; + final dynamic palay; + final dynamic pentactinal; + final dynamic phaet; + final dynamic piquant; + final dynamic registration; + final dynamic remancipation; + final dynamic scutatiform; + final dynamic theodolite; + final dynamic underward; + + PrefreshmanClass({ + required this.azorubine, + required this.choroiditis, + required this.coagulatory, + required this.cyclorama, + required this.dolphus, + required this.duckhearted, + required this.ficus, + required this.gemaric, + required this.jugation, + required this.myoliposis, + required this.nonnomination, + required this.palay, + required this.pentactinal, + required this.phaet, + required this.piquant, + required this.registration, + required this.remancipation, + required this.scutatiform, + required this.theodolite, + required this.underward, + }); + + factory PrefreshmanClass.fromJson(Map json) => PrefreshmanClass( + azorubine: json["azorubine"], + choroiditis: json["choroiditis"], + coagulatory: json["coagulatory"], + cyclorama: json["cyclorama"], + dolphus: json["Dolphus"], + duckhearted: json["duckhearted"], + ficus: json["Ficus"], + gemaric: json["Gemaric"], + jugation: json["jugation"], + myoliposis: json["myoliposis"], + nonnomination: json["nonnomination"], + palay: json["palay"], + pentactinal: json["pentactinal"], + phaet: json["Phaet"], + piquant: json["piquant"], + registration: json["registration"], + remancipation: json["remancipation"], + scutatiform: json["scutatiform"], + theodolite: json["theodolite"], + underward: json["underward"], + ); + + Map toJson() => { + "azorubine": azorubine, + "choroiditis": choroiditis, + "coagulatory": coagulatory, + "cyclorama": cyclorama, + "Dolphus": dolphus, + "duckhearted": duckhearted, + "Ficus": ficus, + "Gemaric": gemaric, + "jugation": jugation, + "myoliposis": myoliposis, + "nonnomination": nonnomination, + "palay": palay, + "pentactinal": pentactinal, + "Phaet": phaet, + "piquant": piquant, + "registration": registration, + "remancipation": remancipation, + "scutatiform": scutatiform, + "theodolite": theodolite, + "underward": underward, + }; +} diff --git a/head/dart/test/inputs/json/priority/combinations3.json/final-props-false--58a791807e0c/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations3.json/final-props-false--58a791807e0c/TopLevel.dart new file mode 100644 index 0000000..e603106 --- /dev/null +++ b/head/dart/test/inputs/json/priority/combinations3.json/final-props-false--58a791807e0c/TopLevel.dart @@ -0,0 +1,1537 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + List juror; + List kongoni; + List ladronism; + List landlubberly; + List listener; + List lupus; + List maslin; + List monazite; + List monoliteral; + List monotheistically; + List montage; + List moralness; + List mowra; + List mulishly; + List myoscope; + List?> nach; + List neuromastic; + List noncontributing; + List nonnervous; + List nonvaluation; + List occupationalist; + List outrival; + List paleographically; + List pamphletwise; + List pediatrics; + List perceptive; + List piaculum; + List piccadilly; + List piffler; + List pithful; + List placuntitis; + List plectopterous; + List pneumocele; + List poliorcetic; + List poormaster; + List potwhisky; + List practicalizer; + List prefreshman; + List prehensility; + List prevoidance; + List> probant; + List protext; + + TopLevel({ + required this.juror, + required this.kongoni, + required this.ladronism, + required this.landlubberly, + required this.listener, + required this.lupus, + required this.maslin, + required this.monazite, + required this.monoliteral, + required this.monotheistically, + required this.montage, + required this.moralness, + required this.mowra, + required this.mulishly, + required this.myoscope, + required this.nach, + required this.neuromastic, + required this.noncontributing, + required this.nonnervous, + required this.nonvaluation, + required this.occupationalist, + required this.outrival, + required this.paleographically, + required this.pamphletwise, + required this.pediatrics, + required this.perceptive, + required this.piaculum, + required this.piccadilly, + required this.piffler, + required this.pithful, + required this.placuntitis, + required this.plectopterous, + required this.pneumocele, + required this.poliorcetic, + required this.poormaster, + required this.potwhisky, + required this.practicalizer, + required this.prefreshman, + required this.prehensility, + required this.prevoidance, + required this.probant, + required this.protext, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + juror: List.from(json["juror"].map((x) => x)), + kongoni: List.from(json["kongoni"].map((x) => x)), + ladronism: List.from(json["ladronism"].map((x) => x)), + landlubberly: List.from(json["landlubberly"].map((x) => x)), + listener: List.from(json["listener"].map((x) => x)), + lupus: List.from(json["lupus"].map((x) => x)), + maslin: List.from(json["maslin"].map((x) => Maslin.fromJson(x))), + monazite: List.from(json["monazite"].map((x) => x)), + monoliteral: List.from(json["monoliteral"].map((x) => x)), + monotheistically: List.from(json["monotheistically"].map((x) => x)), + montage: List.from(json["montage"].map((x) => x)), + moralness: List.from(json["moralness"].map((x) => x)), + mowra: List.from(json["mowra"].map((x) => x == null ? null : MonaziteClass.fromJson(x))), + mulishly: List.from(json["mulishly"].map((x) => x)), + myoscope: List.from(json["myoscope"].map((x) => x)), + nach: List?>.from(json["nach"].map((x) => x == null ? null : List.from(x!.map((x) => x)))), + neuromastic: List.from(json["neuromastic"].map((x) => x)), + noncontributing: List.from(json["noncontributing"].map((x) => Noncontributing.fromJson(x))), + nonnervous: List.from(json["nonnervous"].map((x) => x)), + nonvaluation: List.from(json["nonvaluation"].map((x) => x)), + occupationalist: List.from(json["occupationalist"].map((x) => x)), + outrival: List.from(json["outrival"].map((x) => x)), + paleographically: List.from(json["paleographically"].map((x) => x)), + pamphletwise: List.from(json["pamphletwise"].map((x) => x)), + pediatrics: List.from(json["pediatrics"].map((x) => x)), + perceptive: List.from(json["perceptive"].map((x) => x)), + piaculum: List.from(json["piaculum"].map((x) => x)), + piccadilly: List.from(json["piccadilly"].map((x) => x)), + piffler: List.from(json["piffler"].map((x) => x)), + pithful: List.from(json["pithful"].map((x) => x)), + placuntitis: List.from(json["placuntitis"].map((x) => x)), + plectopterous: List.from(json["plectopterous"].map((x) => x)), + pneumocele: List.from(json["pneumocele"].map((x) => x == null ? null : Pneumocele.fromJson(x))), + poliorcetic: List.from(json["poliorcetic"].map((x) => x)), + poormaster: List.from(json["poormaster"].map((x) => x)), + potwhisky: List.from(json["potwhisky"].map((x) => x)), + practicalizer: List.from(json["practicalizer"].map((x) => x)), + prefreshman: List.from(json["prefreshman"].map((x) => x)), + prehensility: List.from(json["prehensility"].map((x) => x)), + prevoidance: List.from(json["prevoidance"].map((x) => x)), + probant: List>.from(json["probant"].map((x) => Map.from(x).map((k, v) => MapEntry(k, v)))), + protext: List.from(json["protext"].map((x) => x)), + ); + + Map toJson() => { + "juror": List.from(juror.map((x) => x)), + "kongoni": List.from(kongoni.map((x) => x)), + "ladronism": List.from(ladronism.map((x) => x)), + "landlubberly": List.from(landlubberly.map((x) => x)), + "listener": List.from(listener.map((x) => x)), + "lupus": List.from(lupus.map((x) => x)), + "maslin": List.from(maslin.map((x) => x.toJson())), + "monazite": List.from(monazite.map((x) => x)), + "monoliteral": List.from(monoliteral.map((x) => x)), + "monotheistically": List.from(monotheistically.map((x) => x)), + "montage": List.from(montage.map((x) => x)), + "moralness": List.from(moralness.map((x) => x)), + "mowra": List.from(mowra.map((x) => x?.toJson())), + "mulishly": List.from(mulishly.map((x) => x)), + "myoscope": List.from(myoscope.map((x) => x)), + "nach": List.from(nach.map((x) => x == null ? null : List.from(x!.map((x) => x)))), + "neuromastic": List.from(neuromastic.map((x) => x)), + "noncontributing": List.from(noncontributing.map((x) => x.toJson())), + "nonnervous": List.from(nonnervous.map((x) => x)), + "nonvaluation": List.from(nonvaluation.map((x) => x)), + "occupationalist": List.from(occupationalist.map((x) => x)), + "outrival": List.from(outrival.map((x) => x)), + "paleographically": List.from(paleographically.map((x) => x)), + "pamphletwise": List.from(pamphletwise.map((x) => x)), + "pediatrics": List.from(pediatrics.map((x) => x)), + "perceptive": List.from(perceptive.map((x) => x)), + "piaculum": List.from(piaculum.map((x) => x)), + "piccadilly": List.from(piccadilly.map((x) => x)), + "piffler": List.from(piffler.map((x) => x)), + "pithful": List.from(pithful.map((x) => x)), + "placuntitis": List.from(placuntitis.map((x) => x)), + "plectopterous": List.from(plectopterous.map((x) => x)), + "pneumocele": List.from(pneumocele.map((x) => x?.toJson())), + "poliorcetic": List.from(poliorcetic.map((x) => x)), + "poormaster": List.from(poormaster.map((x) => x)), + "potwhisky": List.from(potwhisky.map((x) => x)), + "practicalizer": List.from(practicalizer.map((x) => x)), + "prefreshman": List.from(prefreshman.map((x) => x)), + "prehensility": List.from(prehensility.map((x) => x)), + "prevoidance": List.from(prevoidance.map((x) => x)), + "probant": List.from(probant.map((x) => Map.from(x).map((k, v) => MapEntry(k, v)))), + "protext": List.from(protext.map((x) => x)), + }; +} + +class JurorClass { + dynamic adipsy; + dynamic auxiliator; + dynamic benda; + dynamic benjamin; + dynamic brandling; + dynamic epicurishly; + dynamic eremochaetous; + dynamic marten; + dynamic monocline; + dynamic olea; + dynamic palgat; + dynamic pennyworth; + dynamic pioury; + dynamic pragmatistic; + dynamic stylelessness; + dynamic systematical; + dynamic thready; + dynamic uncontemporary; + dynamic uncouched; + dynamic uninhabitedness; + + JurorClass({ + required this.adipsy, + required this.auxiliator, + required this.benda, + required this.benjamin, + required this.brandling, + required this.epicurishly, + required this.eremochaetous, + required this.marten, + required this.monocline, + required this.olea, + required this.palgat, + required this.pennyworth, + required this.pioury, + required this.pragmatistic, + required this.stylelessness, + required this.systematical, + required this.thready, + required this.uncontemporary, + required this.uncouched, + required this.uninhabitedness, + }); + + factory JurorClass.fromJson(Map json) => JurorClass( + adipsy: json["adipsy"], + auxiliator: json["auxiliator"], + benda: json["benda"], + benjamin: json["benjamin"], + brandling: json["brandling"], + epicurishly: json["epicurishly"], + eremochaetous: json["eremochaetous"], + marten: json["marten"], + monocline: json["monocline"], + olea: json["Olea"], + palgat: json["palgat"], + pennyworth: json["pennyworth"], + pioury: json["pioury"], + pragmatistic: json["pragmatistic"], + stylelessness: json["stylelessness"], + systematical: json["systematical"], + thready: json["thready"], + uncontemporary: json["uncontemporary"], + uncouched: json["uncouched"], + uninhabitedness: json["uninhabitedness"], + ); + + Map toJson() => { + "adipsy": adipsy, + "auxiliator": auxiliator, + "benda": benda, + "benjamin": benjamin, + "brandling": brandling, + "epicurishly": epicurishly, + "eremochaetous": eremochaetous, + "marten": marten, + "monocline": monocline, + "Olea": olea, + "palgat": palgat, + "pennyworth": pennyworth, + "pioury": pioury, + "pragmatistic": pragmatistic, + "stylelessness": stylelessness, + "systematical": systematical, + "thready": thready, + "uncontemporary": uncontemporary, + "uncouched": uncouched, + "uninhabitedness": uninhabitedness, + }; +} + +class LadronismClass { + dynamic acclaimer; + dynamic achree; + dynamic base; + dynamic conundrumize; + dynamic degerminator; + dynamic describable; + dynamic exasperatedly; + dynamic heroine; + dynamic indazin; + dynamic luteous; + dynamic papular; + dynamic pritch; + dynamic prodenia; + dynamic seege; + dynamic shopgirl; + dynamic tragedietta; + dynamic unsparse; + dynamic uplook; + dynamic vermiformis; + dynamic whafabout; + + LadronismClass({ + required this.acclaimer, + required this.achree, + required this.base, + required this.conundrumize, + required this.degerminator, + required this.describable, + required this.exasperatedly, + required this.heroine, + required this.indazin, + required this.luteous, + required this.papular, + required this.pritch, + required this.prodenia, + required this.seege, + required this.shopgirl, + required this.tragedietta, + required this.unsparse, + required this.uplook, + required this.vermiformis, + required this.whafabout, + }); + + factory LadronismClass.fromJson(Map json) => LadronismClass( + acclaimer: json["acclaimer"], + achree: json["achree"], + base: json["base"], + conundrumize: json["conundrumize"], + degerminator: json["degerminator"], + describable: json["describable"], + exasperatedly: json["exasperatedly"], + heroine: json["heroine"], + indazin: json["indazin"], + luteous: json["luteous"], + papular: json["papular"], + pritch: json["pritch"], + prodenia: json["Prodenia"], + seege: json["seege"], + shopgirl: json["shopgirl"], + tragedietta: json["tragedietta"], + unsparse: json["unsparse"], + uplook: json["uplook"], + vermiformis: json["vermiformis"], + whafabout: json["whafabout"], + ); + + Map toJson() => { + "acclaimer": acclaimer, + "achree": achree, + "base": base, + "conundrumize": conundrumize, + "degerminator": degerminator, + "describable": describable, + "exasperatedly": exasperatedly, + "heroine": heroine, + "indazin": indazin, + "luteous": luteous, + "papular": papular, + "pritch": pritch, + "Prodenia": prodenia, + "seege": seege, + "shopgirl": shopgirl, + "tragedietta": tragedietta, + "unsparse": unsparse, + "uplook": uplook, + "vermiformis": vermiformis, + "whafabout": whafabout, + }; +} + +class LandlubberlyClass { + dynamic acropoleis; + dynamic aminate; + dynamic amyraldism; + dynamic bipenniform; + dynamic bugre; + dynamic calycule; + dynamic caoutchouc; + dynamic disprover; + dynamic fitroot; + dynamic fulgently; + dynamic kickup; + dynamic laevoversion; + dynamic moter; + dynamic objectivity; + dynamic posterity; + dynamic postnuptial; + dynamic precedentary; + dynamic saddling; + dynamic subcurrent; + dynamic unrecriminative; + + LandlubberlyClass({ + required this.acropoleis, + required this.aminate, + required this.amyraldism, + required this.bipenniform, + required this.bugre, + required this.calycule, + required this.caoutchouc, + required this.disprover, + required this.fitroot, + required this.fulgently, + required this.kickup, + required this.laevoversion, + required this.moter, + required this.objectivity, + required this.posterity, + required this.postnuptial, + required this.precedentary, + required this.saddling, + required this.subcurrent, + required this.unrecriminative, + }); + + factory LandlubberlyClass.fromJson(Map json) => LandlubberlyClass( + acropoleis: json["acropoleis"], + aminate: json["aminate"], + amyraldism: json["Amyraldism"], + bipenniform: json["bipenniform"], + bugre: json["bugre"], + calycule: json["calycule"], + caoutchouc: json["caoutchouc"], + disprover: json["disprover"], + fitroot: json["fitroot"], + fulgently: json["fulgently"], + kickup: json["kickup"], + laevoversion: json["laevoversion"], + moter: json["moter"], + objectivity: json["objectivity"], + posterity: json["posterity"], + postnuptial: json["postnuptial"], + precedentary: json["precedentary"], + saddling: json["saddling"], + subcurrent: json["subcurrent"], + unrecriminative: json["unrecriminative"], + ); + + Map toJson() => { + "acropoleis": acropoleis, + "aminate": aminate, + "Amyraldism": amyraldism, + "bipenniform": bipenniform, + "bugre": bugre, + "calycule": calycule, + "caoutchouc": caoutchouc, + "disprover": disprover, + "fitroot": fitroot, + "fulgently": fulgently, + "kickup": kickup, + "laevoversion": laevoversion, + "moter": moter, + "objectivity": objectivity, + "posterity": posterity, + "postnuptial": postnuptial, + "precedentary": precedentary, + "saddling": saddling, + "subcurrent": subcurrent, + "unrecriminative": unrecriminative, + }; +} + +class LupusClass { + double? catharticalness; + int? chirotherium; + int? chlorioninae; + int? corvinae; + int? crassina; + String? disdiapason; + int? exiguity; + int? farcist; + int? holographical; + bool? homocerc; + int? ichthyophagan; + int? implacable; + dynamic nonbookish; + int? outshiner; + int? overweather; + int? protonegroid; + int? shallowish; + int? snoke; + int? snout; + int? surveillance; + int? threshingtime; + int? thysanocarpus; + int? unsignificantly; + int? unsnap; + int? vendible; + + LupusClass({ + this.catharticalness, + this.chirotherium, + this.chlorioninae, + this.corvinae, + this.crassina, + this.disdiapason, + this.exiguity, + this.farcist, + this.holographical, + this.homocerc, + this.ichthyophagan, + this.implacable, + this.nonbookish, + this.outshiner, + this.overweather, + this.protonegroid, + this.shallowish, + this.snoke, + this.snout, + this.surveillance, + this.threshingtime, + this.thysanocarpus, + this.unsignificantly, + this.unsnap, + this.vendible, + }); + + factory LupusClass.fromJson(Map json) => LupusClass( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + chlorioninae: json["Chlorioninae"], + corvinae: json["Corvinae"], + crassina: json["Crassina"], + disdiapason: json["disdiapason"], + exiguity: json["exiguity"], + farcist: json["farcist"], + holographical: json["holographical"], + homocerc: json["homocerc"], + ichthyophagan: json["ichthyophagan"], + implacable: json["implacable"], + nonbookish: json["nonbookish"], + outshiner: json["outshiner"], + overweather: json["overweather"], + protonegroid: json["protonegroid"], + shallowish: json["shallowish"], + snoke: json["snoke"], + snout: json["snout"], + surveillance: json["surveillance"], + threshingtime: json["threshingtime"], + thysanocarpus: json["Thysanocarpus"], + unsignificantly: json["unsignificantly"], + unsnap: json["unsnap"], + vendible: json["vendible"], + ); + + Map toJson() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "Chlorioninae": chlorioninae, + "Corvinae": corvinae, + "Crassina": crassina, + "disdiapason": disdiapason, + "exiguity": exiguity, + "farcist": farcist, + "holographical": holographical, + "homocerc": homocerc, + "ichthyophagan": ichthyophagan, + "implacable": implacable, + "nonbookish": nonbookish, + "outshiner": outshiner, + "overweather": overweather, + "protonegroid": protonegroid, + "shallowish": shallowish, + "snoke": snoke, + "snout": snout, + "surveillance": surveillance, + "threshingtime": threshingtime, + "Thysanocarpus": thysanocarpus, + "unsignificantly": unsignificantly, + "unsnap": unsnap, + "vendible": vendible, + }; +} + +class Maslin { + int? alicant; + dynamic antiatonement; + int? anticorrosive; + dynamic aphidozer; + dynamic bakuninist; + int? be; + double? catharticalness; + int? chirotherium; + int? chub; + int? cuprosilicon; + int? curtailedly; + int? dellenite; + int? dimitry; + String? disdiapason; + dynamic edifying; + int? ethmoiditis; + dynamic gastralgy; + int? goatherd; + int? hammerdress; + dynamic hangfire; + bool? homocerc; + int? lacunosity; + dynamic longiloquence; + int? mameliere; + dynamic motherless; + dynamic nonbookish; + dynamic noncorrodible; + dynamic nonsensicality; + int? oafishly; + dynamic pfund; + dynamic preadvisory; + dynamic retroflexed; + int? saccharulmic; + int? scowlful; + dynamic secluded; + dynamic slackage; + int? sphaeridial; + dynamic spondulics; + int? subsecive; + dynamic swellmobsman; + int? trachyglossate; + dynamic trialogue; + int? unassuaged; + dynamic ungross; + dynamic unjudiciously; + + Maslin({ + this.alicant, + this.antiatonement, + this.anticorrosive, + this.aphidozer, + this.bakuninist, + this.be, + this.catharticalness, + this.chirotherium, + this.chub, + this.cuprosilicon, + this.curtailedly, + this.dellenite, + this.dimitry, + this.disdiapason, + this.edifying, + this.ethmoiditis, + this.gastralgy, + this.goatherd, + this.hammerdress, + this.hangfire, + this.homocerc, + this.lacunosity, + this.longiloquence, + this.mameliere, + this.motherless, + this.nonbookish, + this.noncorrodible, + this.nonsensicality, + this.oafishly, + this.pfund, + this.preadvisory, + this.retroflexed, + this.saccharulmic, + this.scowlful, + this.secluded, + this.slackage, + this.sphaeridial, + this.spondulics, + this.subsecive, + this.swellmobsman, + this.trachyglossate, + this.trialogue, + this.unassuaged, + this.ungross, + this.unjudiciously, + }); + + factory Maslin.fromJson(Map json) => Maslin( + alicant: json["Alicant"], + antiatonement: json["antiatonement"], + anticorrosive: json["anticorrosive"], + aphidozer: json["aphidozer"], + bakuninist: json["Bakuninist"], + be: json["be"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + chub: json["chub"], + cuprosilicon: json["cuprosilicon"], + curtailedly: json["curtailedly"], + dellenite: json["dellenite"], + dimitry: json["Dimitry"], + disdiapason: json["disdiapason"], + edifying: json["edifying"], + ethmoiditis: json["ethmoiditis"], + gastralgy: json["gastralgy"], + goatherd: json["goatherd"], + hammerdress: json["hammerdress"], + hangfire: json["hangfire"], + homocerc: json["homocerc"], + lacunosity: json["lacunosity"], + longiloquence: json["longiloquence"], + mameliere: json["mameliere"], + motherless: json["motherless"], + nonbookish: json["nonbookish"], + noncorrodible: json["noncorrodible"], + nonsensicality: json["nonsensicality"], + oafishly: json["oafishly"], + pfund: json["pfund"], + preadvisory: json["preadvisory"], + retroflexed: json["retroflexed"], + saccharulmic: json["saccharulmic"], + scowlful: json["scowlful"], + secluded: json["secluded"], + slackage: json["slackage"], + sphaeridial: json["sphaeridial"], + spondulics: json["spondulics"], + subsecive: json["subsecive"], + swellmobsman: json["swellmobsman"], + trachyglossate: json["trachyglossate"], + trialogue: json["trialogue"], + unassuaged: json["unassuaged"], + ungross: json["ungross"], + unjudiciously: json["unjudiciously"], + ); + + Map toJson() => { + "Alicant": alicant, + "antiatonement": antiatonement, + "anticorrosive": anticorrosive, + "aphidozer": aphidozer, + "Bakuninist": bakuninist, + "be": be, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "chub": chub, + "cuprosilicon": cuprosilicon, + "curtailedly": curtailedly, + "dellenite": dellenite, + "Dimitry": dimitry, + "disdiapason": disdiapason, + "edifying": edifying, + "ethmoiditis": ethmoiditis, + "gastralgy": gastralgy, + "goatherd": goatherd, + "hammerdress": hammerdress, + "hangfire": hangfire, + "homocerc": homocerc, + "lacunosity": lacunosity, + "longiloquence": longiloquence, + "mameliere": mameliere, + "motherless": motherless, + "nonbookish": nonbookish, + "noncorrodible": noncorrodible, + "nonsensicality": nonsensicality, + "oafishly": oafishly, + "pfund": pfund, + "preadvisory": preadvisory, + "retroflexed": retroflexed, + "saccharulmic": saccharulmic, + "scowlful": scowlful, + "secluded": secluded, + "slackage": slackage, + "sphaeridial": sphaeridial, + "spondulics": spondulics, + "subsecive": subsecive, + "swellmobsman": swellmobsman, + "trachyglossate": trachyglossate, + "trialogue": trialogue, + "unassuaged": unassuaged, + "ungross": ungross, + "unjudiciously": unjudiciously, + }; +} + +class MonaziteClass { + double catharticalness; + int chirotherium; + String disdiapason; + bool homocerc; + dynamic nonbookish; + + MonaziteClass({ + required this.catharticalness, + required this.chirotherium, + required this.disdiapason, + required this.homocerc, + required this.nonbookish, + }); + + factory MonaziteClass.fromJson(Map json) => MonaziteClass( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + homocerc: json["homocerc"], + nonbookish: json["nonbookish"], + ); + + Map toJson() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "homocerc": homocerc, + "nonbookish": nonbookish, + }; +} + +class MonotheisticallyClass { + dynamic blaspheme; + double? catharticalness; + dynamic celiosalpingectomy; + int? chirotherium; + dynamic consummativeness; + String? disdiapason; + dynamic egestive; + dynamic enchylema; + dynamic gasconade; + dynamic holidayer; + bool? homocerc; + dynamic intuitionalism; + dynamic lophiostomate; + dynamic nonbookish; + dynamic nonvolition; + dynamic palatableness; + dynamic pimpery; + dynamic previolation; + dynamic reconveyance; + dynamic registership; + dynamic rhyacolite; + dynamic smithereens; + dynamic superedification; + dynamic trust; + dynamic whitestone; + + MonotheisticallyClass({ + this.blaspheme, + this.catharticalness, + this.celiosalpingectomy, + this.chirotherium, + this.consummativeness, + this.disdiapason, + this.egestive, + this.enchylema, + this.gasconade, + this.holidayer, + this.homocerc, + this.intuitionalism, + this.lophiostomate, + this.nonbookish, + this.nonvolition, + this.palatableness, + this.pimpery, + this.previolation, + this.reconveyance, + this.registership, + this.rhyacolite, + this.smithereens, + this.superedification, + this.trust, + this.whitestone, + }); + + factory MonotheisticallyClass.fromJson(Map json) => MonotheisticallyClass( + blaspheme: json["blaspheme"], + catharticalness: json["catharticalness"]?.toDouble(), + celiosalpingectomy: json["celiosalpingectomy"], + chirotherium: json["Chirotherium"], + consummativeness: json["consummativeness"], + disdiapason: json["disdiapason"], + egestive: json["egestive"], + enchylema: json["enchylema"], + gasconade: json["gasconade"], + holidayer: json["holidayer"], + homocerc: json["homocerc"], + intuitionalism: json["intuitionalism"], + lophiostomate: json["lophiostomate"], + nonbookish: json["nonbookish"], + nonvolition: json["nonvolition"], + palatableness: json["palatableness"], + pimpery: json["pimpery"], + previolation: json["previolation"], + reconveyance: json["reconveyance"], + registership: json["registership"], + rhyacolite: json["rhyacolite"], + smithereens: json["smithereens"], + superedification: json["superedification"], + trust: json["trust"], + whitestone: json["whitestone"], + ); + + Map toJson() => { + "blaspheme": blaspheme, + "catharticalness": catharticalness, + "celiosalpingectomy": celiosalpingectomy, + "Chirotherium": chirotherium, + "consummativeness": consummativeness, + "disdiapason": disdiapason, + "egestive": egestive, + "enchylema": enchylema, + "gasconade": gasconade, + "holidayer": holidayer, + "homocerc": homocerc, + "intuitionalism": intuitionalism, + "lophiostomate": lophiostomate, + "nonbookish": nonbookish, + "nonvolition": nonvolition, + "palatableness": palatableness, + "pimpery": pimpery, + "previolation": previolation, + "reconveyance": reconveyance, + "registership": registership, + "rhyacolite": rhyacolite, + "smithereens": smithereens, + "superedification": superedification, + "trust": trust, + "whitestone": whitestone, + }; +} + +class Noncontributing { + String estevin; + double jolterhead; + int sauternes; + bool sparsely; + dynamic unrequested; + + Noncontributing({ + required this.estevin, + required this.jolterhead, + required this.sauternes, + required this.sparsely, + required this.unrequested, + }); + + factory Noncontributing.fromJson(Map json) => Noncontributing( + estevin: json["estevin"], + jolterhead: json["jolterhead"]?.toDouble(), + sauternes: json["sauternes"], + sparsely: json["sparsely"], + unrequested: json["unrequested"], + ); + + Map toJson() => { + "estevin": estevin, + "jolterhead": jolterhead, + "sauternes": sauternes, + "sparsely": sparsely, + "unrequested": unrequested, + }; +} + +class OccupationalistClass { + dynamic beholdable; + dynamic brotuliform; + dynamic chimakum; + dynamic doodler; + dynamic emulsin; + dynamic fin; + dynamic flourishing; + dynamic flueless; + dynamic furtively; + dynamic gritter; + dynamic interwish; + dynamic monoxylic; + dynamic myristic; + dynamic nightwear; + dynamic peruser; + dynamic theoastrological; + dynamic thumby; + dynamic tingitid; + dynamic trailless; + dynamic unpocketed; + + OccupationalistClass({ + required this.beholdable, + required this.brotuliform, + required this.chimakum, + required this.doodler, + required this.emulsin, + required this.fin, + required this.flourishing, + required this.flueless, + required this.furtively, + required this.gritter, + required this.interwish, + required this.monoxylic, + required this.myristic, + required this.nightwear, + required this.peruser, + required this.theoastrological, + required this.thumby, + required this.tingitid, + required this.trailless, + required this.unpocketed, + }); + + factory OccupationalistClass.fromJson(Map json) => OccupationalistClass( + beholdable: json["beholdable"], + brotuliform: json["brotuliform"], + chimakum: json["Chimakum"], + doodler: json["doodler"], + emulsin: json["emulsin"], + fin: json["Fin"], + flourishing: json["flourishing"], + flueless: json["flueless"], + furtively: json["furtively"], + gritter: json["gritter"], + interwish: json["interwish"], + monoxylic: json["monoxylic"], + myristic: json["myristic"], + nightwear: json["nightwear"], + peruser: json["peruser"], + theoastrological: json["theoastrological"], + thumby: json["thumby"], + tingitid: json["tingitid"], + trailless: json["trailless"], + unpocketed: json["unpocketed"], + ); + + Map toJson() => { + "beholdable": beholdable, + "brotuliform": brotuliform, + "Chimakum": chimakum, + "doodler": doodler, + "emulsin": emulsin, + "Fin": fin, + "flourishing": flourishing, + "flueless": flueless, + "furtively": furtively, + "gritter": gritter, + "interwish": interwish, + "monoxylic": monoxylic, + "myristic": myristic, + "nightwear": nightwear, + "peruser": peruser, + "theoastrological": theoastrological, + "thumby": thumby, + "tingitid": tingitid, + "trailless": trailless, + "unpocketed": unpocketed, + }; +} + +class OutrivalClass { + dynamic adroitly; + dynamic bridehood; + dynamic castoroides; + dynamic czechoslovak; + dynamic diagenesis; + dynamic dihexahedron; + dynamic dopester; + dynamic eumerism; + dynamic flyness; + dynamic fouler; + dynamic laudanosine; + dynamic lingulidae; + dynamic minutary; + dynamic mitra; + dynamic opisthorchiasis; + dynamic pensively; + dynamic pubigerous; + dynamic rebellious; + dynamic recodify; + dynamic unpaced; + + OutrivalClass({ + required this.adroitly, + required this.bridehood, + required this.castoroides, + required this.czechoslovak, + required this.diagenesis, + required this.dihexahedron, + required this.dopester, + required this.eumerism, + required this.flyness, + required this.fouler, + required this.laudanosine, + required this.lingulidae, + required this.minutary, + required this.mitra, + required this.opisthorchiasis, + required this.pensively, + required this.pubigerous, + required this.rebellious, + required this.recodify, + required this.unpaced, + }); + + factory OutrivalClass.fromJson(Map json) => OutrivalClass( + adroitly: json["adroitly"], + bridehood: json["bridehood"], + castoroides: json["Castoroides"], + czechoslovak: json["Czechoslovak"], + diagenesis: json["diagenesis"], + dihexahedron: json["dihexahedron"], + dopester: json["dopester"], + eumerism: json["eumerism"], + flyness: json["flyness"], + fouler: json["fouler"], + laudanosine: json["laudanosine"], + lingulidae: json["Lingulidae"], + minutary: json["minutary"], + mitra: json["mitra"], + opisthorchiasis: json["opisthorchiasis"], + pensively: json["pensively"], + pubigerous: json["pubigerous"], + rebellious: json["rebellious"], + recodify: json["recodify"], + unpaced: json["unpaced"], + ); + + Map toJson() => { + "adroitly": adroitly, + "bridehood": bridehood, + "Castoroides": castoroides, + "Czechoslovak": czechoslovak, + "diagenesis": diagenesis, + "dihexahedron": dihexahedron, + "dopester": dopester, + "eumerism": eumerism, + "flyness": flyness, + "fouler": fouler, + "laudanosine": laudanosine, + "Lingulidae": lingulidae, + "minutary": minutary, + "mitra": mitra, + "opisthorchiasis": opisthorchiasis, + "pensively": pensively, + "pubigerous": pubigerous, + "rebellious": rebellious, + "recodify": recodify, + "unpaced": unpaced, + }; +} + +class PiaculumClass { + int? alada; + int? amphistomous; + int? boysenberry; + double? catharticalness; + int? chirotherium; + int? decardinalize; + int? discouragement; + String? disdiapason; + int? doitrified; + int? hexaspermous; + bool? homocerc; + int? insinking; + int? loathfulness; + int? miasmatical; + int? neurofibril; + dynamic nonbookish; + int? phonendoscope; + int? pilferment; + int? predismissory; + int? preinscription; + int? quotative; + int? sienna; + int? thorax; + int? yachting; + int? zipper; + + PiaculumClass({ + this.alada, + this.amphistomous, + this.boysenberry, + this.catharticalness, + this.chirotherium, + this.decardinalize, + this.discouragement, + this.disdiapason, + this.doitrified, + this.hexaspermous, + this.homocerc, + this.insinking, + this.loathfulness, + this.miasmatical, + this.neurofibril, + this.nonbookish, + this.phonendoscope, + this.pilferment, + this.predismissory, + this.preinscription, + this.quotative, + this.sienna, + this.thorax, + this.yachting, + this.zipper, + }); + + factory PiaculumClass.fromJson(Map json) => PiaculumClass( + alada: json["alada"], + amphistomous: json["amphistomous"], + boysenberry: json["boysenberry"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + decardinalize: json["decardinalize"], + discouragement: json["discouragement"], + disdiapason: json["disdiapason"], + doitrified: json["doitrified"], + hexaspermous: json["hexaspermous"], + homocerc: json["homocerc"], + insinking: json["insinking"], + loathfulness: json["loathfulness"], + miasmatical: json["miasmatical"], + neurofibril: json["neurofibril"], + nonbookish: json["nonbookish"], + phonendoscope: json["phonendoscope"], + pilferment: json["pilferment"], + predismissory: json["predismissory"], + preinscription: json["preinscription"], + quotative: json["quotative"], + sienna: json["sienna"], + thorax: json["thorax"], + yachting: json["yachting"], + zipper: json["Zipper"], + ); + + Map toJson() => { + "alada": alada, + "amphistomous": amphistomous, + "boysenberry": boysenberry, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "decardinalize": decardinalize, + "discouragement": discouragement, + "disdiapason": disdiapason, + "doitrified": doitrified, + "hexaspermous": hexaspermous, + "homocerc": homocerc, + "insinking": insinking, + "loathfulness": loathfulness, + "miasmatical": miasmatical, + "neurofibril": neurofibril, + "nonbookish": nonbookish, + "phonendoscope": phonendoscope, + "pilferment": pilferment, + "predismissory": predismissory, + "preinscription": preinscription, + "quotative": quotative, + "sienna": sienna, + "thorax": thorax, + "yachting": yachting, + "Zipper": zipper, + }; +} + +class Pneumocele { + dynamic carbonarism; + double? catharticalness; + int? chirotherium; + dynamic cineolic; + dynamic cobbly; + dynamic conchyliferous; + dynamic congregation; + String? disdiapason; + dynamic enterotomy; + dynamic entophytal; + dynamic fewtrils; + dynamic herem; + bool? homocerc; + dynamic koniga; + dynamic meticulosity; + dynamic micky; + dynamic mismarriage; + dynamic neurotrophic; + dynamic nonbookish; + dynamic persuasively; + dynamic replaceable; + dynamic silex; + dynamic taillight; + dynamic unjealous; + dynamic visitorial; + + Pneumocele({ + this.carbonarism, + this.catharticalness, + this.chirotherium, + this.cineolic, + this.cobbly, + this.conchyliferous, + this.congregation, + this.disdiapason, + this.enterotomy, + this.entophytal, + this.fewtrils, + this.herem, + this.homocerc, + this.koniga, + this.meticulosity, + this.micky, + this.mismarriage, + this.neurotrophic, + this.nonbookish, + this.persuasively, + this.replaceable, + this.silex, + this.taillight, + this.unjealous, + this.visitorial, + }); + + factory Pneumocele.fromJson(Map json) => Pneumocele( + carbonarism: json["Carbonarism"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + cineolic: json["cineolic"], + cobbly: json["cobbly"], + conchyliferous: json["conchyliferous"], + congregation: json["congregation"], + disdiapason: json["disdiapason"], + enterotomy: json["enterotomy"], + entophytal: json["entophytal"], + fewtrils: json["fewtrils"], + herem: json["herem"], + homocerc: json["homocerc"], + koniga: json["Koniga"], + meticulosity: json["meticulosity"], + micky: json["Micky"], + mismarriage: json["mismarriage"], + neurotrophic: json["neurotrophic"], + nonbookish: json["nonbookish"], + persuasively: json["persuasively"], + replaceable: json["replaceable"], + silex: json["silex"], + taillight: json["taillight"], + unjealous: json["unjealous"], + visitorial: json["visitorial"], + ); + + Map toJson() => { + "Carbonarism": carbonarism, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "cineolic": cineolic, + "cobbly": cobbly, + "conchyliferous": conchyliferous, + "congregation": congregation, + "disdiapason": disdiapason, + "enterotomy": enterotomy, + "entophytal": entophytal, + "fewtrils": fewtrils, + "herem": herem, + "homocerc": homocerc, + "Koniga": koniga, + "meticulosity": meticulosity, + "Micky": micky, + "mismarriage": mismarriage, + "neurotrophic": neurotrophic, + "nonbookish": nonbookish, + "persuasively": persuasively, + "replaceable": replaceable, + "silex": silex, + "taillight": taillight, + "unjealous": unjealous, + "visitorial": visitorial, + }; +} + +class PotwhiskyClass { + dynamic arciform; + dynamic cresolin; + dynamic disheartener; + dynamic disproportionable; + dynamic euchorda; + dynamic ferryway; + dynamic filamentiferous; + dynamic flemish; + dynamic forgainst; + dynamic grainering; + dynamic irrevoluble; + dynamic kindredship; + dynamic pinguitudinous; + dynamic simpletonic; + dynamic singsong; + dynamic submergement; + dynamic supraoesophagal; + dynamic thrashel; + dynamic tyremesis; + dynamic yoruba; + + PotwhiskyClass({ + required this.arciform, + required this.cresolin, + required this.disheartener, + required this.disproportionable, + required this.euchorda, + required this.ferryway, + required this.filamentiferous, + required this.flemish, + required this.forgainst, + required this.grainering, + required this.irrevoluble, + required this.kindredship, + required this.pinguitudinous, + required this.simpletonic, + required this.singsong, + required this.submergement, + required this.supraoesophagal, + required this.thrashel, + required this.tyremesis, + required this.yoruba, + }); + + factory PotwhiskyClass.fromJson(Map json) => PotwhiskyClass( + arciform: json["arciform"], + cresolin: json["cresolin"], + disheartener: json["disheartener"], + disproportionable: json["disproportionable"], + euchorda: json["Euchorda"], + ferryway: json["ferryway"], + filamentiferous: json["filamentiferous"], + flemish: json["flemish"], + forgainst: json["forgainst"], + grainering: json["grainering"], + irrevoluble: json["irrevoluble"], + kindredship: json["kindredship"], + pinguitudinous: json["pinguitudinous"], + simpletonic: json["simpletonic"], + singsong: json["singsong"], + submergement: json["submergement"], + supraoesophagal: json["supraoesophagal"], + thrashel: json["thrashel"], + tyremesis: json["tyremesis"], + yoruba: json["Yoruba"], + ); + + Map toJson() => { + "arciform": arciform, + "cresolin": cresolin, + "disheartener": disheartener, + "disproportionable": disproportionable, + "Euchorda": euchorda, + "ferryway": ferryway, + "filamentiferous": filamentiferous, + "flemish": flemish, + "forgainst": forgainst, + "grainering": grainering, + "irrevoluble": irrevoluble, + "kindredship": kindredship, + "pinguitudinous": pinguitudinous, + "simpletonic": simpletonic, + "singsong": singsong, + "submergement": submergement, + "supraoesophagal": supraoesophagal, + "thrashel": thrashel, + "tyremesis": tyremesis, + "Yoruba": yoruba, + }; +} + +class PrefreshmanClass { + dynamic azorubine; + dynamic choroiditis; + dynamic coagulatory; + dynamic cyclorama; + dynamic dolphus; + dynamic duckhearted; + dynamic ficus; + dynamic gemaric; + dynamic jugation; + dynamic myoliposis; + dynamic nonnomination; + dynamic palay; + dynamic pentactinal; + dynamic phaet; + dynamic piquant; + dynamic registration; + dynamic remancipation; + dynamic scutatiform; + dynamic theodolite; + dynamic underward; + + PrefreshmanClass({ + required this.azorubine, + required this.choroiditis, + required this.coagulatory, + required this.cyclorama, + required this.dolphus, + required this.duckhearted, + required this.ficus, + required this.gemaric, + required this.jugation, + required this.myoliposis, + required this.nonnomination, + required this.palay, + required this.pentactinal, + required this.phaet, + required this.piquant, + required this.registration, + required this.remancipation, + required this.scutatiform, + required this.theodolite, + required this.underward, + }); + + factory PrefreshmanClass.fromJson(Map json) => PrefreshmanClass( + azorubine: json["azorubine"], + choroiditis: json["choroiditis"], + coagulatory: json["coagulatory"], + cyclorama: json["cyclorama"], + dolphus: json["Dolphus"], + duckhearted: json["duckhearted"], + ficus: json["Ficus"], + gemaric: json["Gemaric"], + jugation: json["jugation"], + myoliposis: json["myoliposis"], + nonnomination: json["nonnomination"], + palay: json["palay"], + pentactinal: json["pentactinal"], + phaet: json["Phaet"], + piquant: json["piquant"], + registration: json["registration"], + remancipation: json["remancipation"], + scutatiform: json["scutatiform"], + theodolite: json["theodolite"], + underward: json["underward"], + ); + + Map toJson() => { + "azorubine": azorubine, + "choroiditis": choroiditis, + "coagulatory": coagulatory, + "cyclorama": cyclorama, + "Dolphus": dolphus, + "duckhearted": duckhearted, + "Ficus": ficus, + "Gemaric": gemaric, + "jugation": jugation, + "myoliposis": myoliposis, + "nonnomination": nonnomination, + "palay": palay, + "pentactinal": pentactinal, + "Phaet": phaet, + "piquant": piquant, + "registration": registration, + "remancipation": remancipation, + "scutatiform": scutatiform, + "theodolite": theodolite, + "underward": underward, + }; +} diff --git a/head/dart/test/inputs/json/priority/combinations4.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations4.json/default/TopLevel.dart new file mode 100644 index 0000000..d2580eb --- /dev/null +++ b/head/dart/test/inputs/json/priority/combinations4.json/default/TopLevel.dart @@ -0,0 +1,1761 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + final List protrusive; + final List pulpitism; + final List pyodermia; + final List quebrachine; + final List querier; + final List rebarbative; + final List reimagine; + final Ressaut ressaut; + final List retrocervical; + final List revert; + final List rewrite; + final List saccoderm; + final List santir; + final List saprophilous; + final List saxten; + final List scatty; + final List scoffer; + final List scrampum; + final double semantic; + final List serpentinic; + final List shadowable; + final List sistering; + final List staghunting; + final List stagmometer; + final List stimulability; + final List strangleable; + final List strenuosity; + final List tabaxir; + final List talpiform; + final List thwack; + final List to; + final List tortricine; + final List truantcy; + final List turgesce; + final List unbeginning; + final List underdunged; + final List undesirability; + final List unerasing; + final List unguentarium; + final List unimpeachably; + final List unmortgaged; + final List unobstructed; + final List unreceptivity; + final List unsatisfactoriness; + final List unsecurity; + final List unstressed; + final List untasked; + final List unvarying; + final List vehemently; + final Map warriorship; + final List whitepot; + final List wrothy; + + TopLevel({ + required this.protrusive, + required this.pulpitism, + required this.pyodermia, + required this.quebrachine, + required this.querier, + required this.rebarbative, + required this.reimagine, + required this.ressaut, + required this.retrocervical, + required this.revert, + required this.rewrite, + required this.saccoderm, + required this.santir, + required this.saprophilous, + required this.saxten, + required this.scatty, + required this.scoffer, + required this.scrampum, + required this.semantic, + required this.serpentinic, + required this.shadowable, + required this.sistering, + required this.staghunting, + required this.stagmometer, + required this.stimulability, + required this.strangleable, + required this.strenuosity, + required this.tabaxir, + required this.talpiform, + required this.thwack, + required this.to, + required this.tortricine, + required this.truantcy, + required this.turgesce, + required this.unbeginning, + required this.underdunged, + required this.undesirability, + required this.unerasing, + required this.unguentarium, + required this.unimpeachably, + required this.unmortgaged, + required this.unobstructed, + required this.unreceptivity, + required this.unsatisfactoriness, + required this.unsecurity, + required this.unstressed, + required this.untasked, + required this.unvarying, + required this.vehemently, + required this.warriorship, + required this.whitepot, + required this.wrothy, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + protrusive: List.from(json["protrusive"].map((x) => x)), + pulpitism: List.from(json["pulpitism"].map((x) => x)), + pyodermia: List.from(json["pyodermia"].map((x) => x)), + quebrachine: List.from(json["quebrachine"].map((x) => x)), + querier: List.from(json["querier"].map((x) => x)), + rebarbative: List.from(json["rebarbative"].map((x) => x)), + reimagine: List.from(json["reimagine"].map((x) => Reimagine.fromJson(x))), + ressaut: Ressaut.fromJson(json["ressaut"]), + retrocervical: List.from(json["retrocervical"].map((x) => x)), + revert: List.from(json["revert"].map((x) => x)), + rewrite: List.from(json["rewrite"].map((x) => x)), + saccoderm: List.from(json["saccoderm"].map((x) => x)), + santir: List.from(json["santir"].map((x) => x)), + saprophilous: List.from(json["saprophilous"].map((x) => x)), + saxten: List.from(json["saxten"].map((x) => x)), + scatty: List.from(json["scatty"].map((x) => x == null ? null : Scatty.fromJson(x))), + scoffer: List.from(json["scoffer"].map((x) => x)), + scrampum: List.from(json["scrampum"].map((x) => x)), + semantic: json["semantic"]?.toDouble(), + serpentinic: List.from(json["serpentinic"].map((x) => x)), + shadowable: List.from(json["shadowable"].map((x) => x)), + sistering: List.from(json["sistering"].map((x) => x)), + staghunting: List.from(json["staghunting"].map((x) => Staghunting.fromJson(x))), + stagmometer: List.from(json["stagmometer"].map((x) => x)), + stimulability: List.from(json["stimulability"].map((x) => x)), + strangleable: List.from(json["strangleable"].map((x) => x)), + strenuosity: List.from(json["strenuosity"].map((x) => x)), + tabaxir: List.from(json["tabaxir"].map((x) => x)), + talpiform: List.from(json["talpiform"].map((x) => x)), + thwack: List.from(json["thwack"].map((x) => x)), + to: List.from(json["to"].map((x) => x?.toDouble())), + tortricine: List.from(json["tortricine"].map((x) => x)), + truantcy: List.from(json["truantcy"].map((x) => x)), + turgesce: List.from(json["turgesce"].map((x) => x)), + unbeginning: List.from(json["unbeginning"].map((x) => x)), + underdunged: List.from(json["underdunged"].map((x) => x?.toDouble())), + undesirability: List.from(json["undesirability"].map((x) => x)), + unerasing: List.from(json["unerasing"].map((x) => x)), + unguentarium: List.from(json["unguentarium"].map((x) => x)), + unimpeachably: List.from(json["unimpeachably"].map((x) => x)), + unmortgaged: List.from(json["unmortgaged"].map((x) => x)), + unobstructed: List.from(json["unobstructed"].map((x) => x)), + unreceptivity: List.from(json["unreceptivity"].map((x) => x)), + unsatisfactoriness: List.from(json["unsatisfactoriness"].map((x) => x)), + unsecurity: List.from(json["unsecurity"].map((x) => x)), + unstressed: List.from(json["unstressed"].map((x) => x)), + untasked: List.from(json["untasked"].map((x) => x)), + unvarying: List.from(json["unvarying"].map((x) => x)), + vehemently: List.from(json["vehemently"].map((x) => x)), + warriorship: Map.from(json["warriorship"]).map((k, v) => MapEntry(k, v)), + whitepot: List.from(json["whitepot"].map((x) => x)), + wrothy: List.from(json["wrothy"].map((x) => x)), + ); + + Map toJson() => { + "protrusive": List.from(protrusive.map((x) => x)), + "pulpitism": List.from(pulpitism.map((x) => x)), + "pyodermia": List.from(pyodermia.map((x) => x)), + "quebrachine": List.from(quebrachine.map((x) => x)), + "querier": List.from(querier.map((x) => x)), + "rebarbative": List.from(rebarbative.map((x) => x)), + "reimagine": List.from(reimagine.map((x) => x.toJson())), + "ressaut": ressaut.toJson(), + "retrocervical": List.from(retrocervical.map((x) => x)), + "revert": List.from(revert.map((x) => x)), + "rewrite": List.from(rewrite.map((x) => x)), + "saccoderm": List.from(saccoderm.map((x) => x)), + "santir": List.from(santir.map((x) => x)), + "saprophilous": List.from(saprophilous.map((x) => x)), + "saxten": List.from(saxten.map((x) => x)), + "scatty": List.from(scatty.map((x) => x?.toJson())), + "scoffer": List.from(scoffer.map((x) => x)), + "scrampum": List.from(scrampum.map((x) => x)), + "semantic": semantic, + "serpentinic": List.from(serpentinic.map((x) => x)), + "shadowable": List.from(shadowable.map((x) => x)), + "sistering": List.from(sistering.map((x) => x)), + "staghunting": List.from(staghunting.map((x) => x.toJson())), + "stagmometer": List.from(stagmometer.map((x) => x)), + "stimulability": List.from(stimulability.map((x) => x)), + "strangleable": List.from(strangleable.map((x) => x)), + "strenuosity": List.from(strenuosity.map((x) => x)), + "tabaxir": List.from(tabaxir.map((x) => x)), + "talpiform": List.from(talpiform.map((x) => x)), + "thwack": List.from(thwack.map((x) => x)), + "to": List.from(to.map((x) => x)), + "tortricine": List.from(tortricine.map((x) => x)), + "truantcy": List.from(truantcy.map((x) => x)), + "turgesce": List.from(turgesce.map((x) => x)), + "unbeginning": List.from(unbeginning.map((x) => x)), + "underdunged": List.from(underdunged.map((x) => x)), + "undesirability": List.from(undesirability.map((x) => x)), + "unerasing": List.from(unerasing.map((x) => x)), + "unguentarium": List.from(unguentarium.map((x) => x)), + "unimpeachably": List.from(unimpeachably.map((x) => x)), + "unmortgaged": List.from(unmortgaged.map((x) => x)), + "unobstructed": List.from(unobstructed.map((x) => x)), + "unreceptivity": List.from(unreceptivity.map((x) => x)), + "unsatisfactoriness": List.from(unsatisfactoriness.map((x) => x)), + "unsecurity": List.from(unsecurity.map((x) => x)), + "unstressed": List.from(unstressed.map((x) => x)), + "untasked": List.from(untasked.map((x) => x)), + "unvarying": List.from(unvarying.map((x) => x)), + "vehemently": List.from(vehemently.map((x) => x)), + "warriorship": Map.from(warriorship).map((k, v) => MapEntry(k, v)), + "whitepot": List.from(whitepot.map((x) => x)), + "wrothy": List.from(wrothy.map((x) => x)), + }; +} + +class PulpitismClass { + final dynamic abnet; + final dynamic buckhorn; + final dynamic calciform; + final dynamic chelophore; + final dynamic cogitation; + final dynamic decreeable; + final dynamic despicable; + final dynamic isodiazo; + final dynamic jadedly; + final dynamic leptochlorite; + final dynamic nursling; + final dynamic palamedean; + final dynamic photoheliograph; + final dynamic pipewood; + final dynamic roberd; + final dynamic statable; + final dynamic superassume; + final dynamic syllabe; + final dynamic toughhead; + final dynamic underburn; + + PulpitismClass({ + required this.abnet, + required this.buckhorn, + required this.calciform, + required this.chelophore, + required this.cogitation, + required this.decreeable, + required this.despicable, + required this.isodiazo, + required this.jadedly, + required this.leptochlorite, + required this.nursling, + required this.palamedean, + required this.photoheliograph, + required this.pipewood, + required this.roberd, + required this.statable, + required this.superassume, + required this.syllabe, + required this.toughhead, + required this.underburn, + }); + + factory PulpitismClass.fromJson(Map json) => PulpitismClass( + abnet: json["abnet"], + buckhorn: json["buckhorn"], + calciform: json["calciform"], + chelophore: json["chelophore"], + cogitation: json["cogitation"], + decreeable: json["decreeable"], + despicable: json["despicable"], + isodiazo: json["isodiazo"], + jadedly: json["jadedly"], + leptochlorite: json["leptochlorite"], + nursling: json["nursling"], + palamedean: json["palamedean"], + photoheliograph: json["photoheliograph"], + pipewood: json["pipewood"], + roberd: json["roberd"], + statable: json["statable"], + superassume: json["superassume"], + syllabe: json["syllabe"], + toughhead: json["toughhead"], + underburn: json["underburn"], + ); + + Map toJson() => { + "abnet": abnet, + "buckhorn": buckhorn, + "calciform": calciform, + "chelophore": chelophore, + "cogitation": cogitation, + "decreeable": decreeable, + "despicable": despicable, + "isodiazo": isodiazo, + "jadedly": jadedly, + "leptochlorite": leptochlorite, + "nursling": nursling, + "palamedean": palamedean, + "photoheliograph": photoheliograph, + "pipewood": pipewood, + "roberd": roberd, + "statable": statable, + "superassume": superassume, + "syllabe": syllabe, + "toughhead": toughhead, + "underburn": underburn, + }; +} + +class PyodermiaClass { + final dynamic aphoristically; + final dynamic apophyllous; + final dynamic cognize; + final dynamic dermonosology; + final dynamic gyppo; + final dynamic ither; + final dynamic juglandaceous; + final dynamic litho; + final dynamic macropterous; + final dynamic photographer; + final dynamic romancing; + final dynamic rumness; + final dynamic somniloquist; + final dynamic stressfully; + final dynamic tactically; + final dynamic tracheophony; + final dynamic unappositely; + final dynamic unclothedly; + final dynamic unimplied; + final dynamic unsyncopated; + + PyodermiaClass({ + required this.aphoristically, + required this.apophyllous, + required this.cognize, + required this.dermonosology, + required this.gyppo, + required this.ither, + required this.juglandaceous, + required this.litho, + required this.macropterous, + required this.photographer, + required this.romancing, + required this.rumness, + required this.somniloquist, + required this.stressfully, + required this.tactically, + required this.tracheophony, + required this.unappositely, + required this.unclothedly, + required this.unimplied, + required this.unsyncopated, + }); + + factory PyodermiaClass.fromJson(Map json) => PyodermiaClass( + aphoristically: json["aphoristically"], + apophyllous: json["apophyllous"], + cognize: json["cognize"], + dermonosology: json["dermonosology"], + gyppo: json["Gyppo"], + ither: json["ither"], + juglandaceous: json["juglandaceous"], + litho: json["litho"], + macropterous: json["macropterous"], + photographer: json["photographer"], + romancing: json["romancing"], + rumness: json["rumness"], + somniloquist: json["somniloquist"], + stressfully: json["stressfully"], + tactically: json["tactically"], + tracheophony: json["tracheophony"], + unappositely: json["unappositely"], + unclothedly: json["unclothedly"], + unimplied: json["unimplied"], + unsyncopated: json["unsyncopated"], + ); + + Map toJson() => { + "aphoristically": aphoristically, + "apophyllous": apophyllous, + "cognize": cognize, + "dermonosology": dermonosology, + "Gyppo": gyppo, + "ither": ither, + "juglandaceous": juglandaceous, + "litho": litho, + "macropterous": macropterous, + "photographer": photographer, + "romancing": romancing, + "rumness": rumness, + "somniloquist": somniloquist, + "stressfully": stressfully, + "tactically": tactically, + "tracheophony": tracheophony, + "unappositely": unappositely, + "unclothedly": unclothedly, + "unimplied": unimplied, + "unsyncopated": unsyncopated, + }; +} + +class QuebrachineClass { + final double catharticalness; + final int chirotherium; + final String disdiapason; + final bool homocerc; + final dynamic nonbookish; + + QuebrachineClass({ + required this.catharticalness, + required this.chirotherium, + required this.disdiapason, + required this.homocerc, + required this.nonbookish, + }); + + factory QuebrachineClass.fromJson(Map json) => QuebrachineClass( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + homocerc: json["homocerc"], + nonbookish: json["nonbookish"], + ); + + Map toJson() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "homocerc": homocerc, + "nonbookish": nonbookish, + }; +} + +class Reimagine { + final dynamic adducible; + final dynamic anabolin; + final dynamic brainy; + final double? catharticalness; + final int? chirotherium; + final dynamic chrysamine; + final String? disdiapason; + final dynamic fluxweed; + final dynamic glaucine; + final dynamic grobianism; + final dynamic hermo; + final dynamic hieroglyphist; + final bool? homocerc; + final dynamic icteroid; + final dynamic immortal; + final dynamic impetulant; + final dynamic irrigate; + final dynamic myxedema; + final dynamic nonbookish; + final dynamic onyx; + final dynamic repasser; + final dynamic septomarginal; + final dynamic subdie; + final dynamic tibiometatarsal; + final dynamic waltzlike; + + Reimagine({ + this.adducible, + this.anabolin, + this.brainy, + this.catharticalness, + this.chirotherium, + this.chrysamine, + this.disdiapason, + this.fluxweed, + this.glaucine, + this.grobianism, + this.hermo, + this.hieroglyphist, + this.homocerc, + this.icteroid, + this.immortal, + this.impetulant, + this.irrigate, + this.myxedema, + this.nonbookish, + this.onyx, + this.repasser, + this.septomarginal, + this.subdie, + this.tibiometatarsal, + this.waltzlike, + }); + + factory Reimagine.fromJson(Map json) => Reimagine( + adducible: json["adducible"], + anabolin: json["anabolin"], + brainy: json["brainy"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + chrysamine: json["chrysamine"], + disdiapason: json["disdiapason"], + fluxweed: json["fluxweed"], + glaucine: json["glaucine"], + grobianism: json["grobianism"], + hermo: json["Hermo"], + hieroglyphist: json["hieroglyphist"], + homocerc: json["homocerc"], + icteroid: json["icteroid"], + immortal: json["immortal"], + impetulant: json["impetulant"], + irrigate: json["irrigate"], + myxedema: json["myxedema"], + nonbookish: json["nonbookish"], + onyx: json["onyx"], + repasser: json["repasser"], + septomarginal: json["septomarginal"], + subdie: json["subdie"], + tibiometatarsal: json["tibiometatarsal"], + waltzlike: json["waltzlike"], + ); + + Map toJson() => { + "adducible": adducible, + "anabolin": anabolin, + "brainy": brainy, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "chrysamine": chrysamine, + "disdiapason": disdiapason, + "fluxweed": fluxweed, + "glaucine": glaucine, + "grobianism": grobianism, + "Hermo": hermo, + "hieroglyphist": hieroglyphist, + "homocerc": homocerc, + "icteroid": icteroid, + "immortal": immortal, + "impetulant": impetulant, + "irrigate": irrigate, + "myxedema": myxedema, + "nonbookish": nonbookish, + "onyx": onyx, + "repasser": repasser, + "septomarginal": septomarginal, + "subdie": subdie, + "tibiometatarsal": tibiometatarsal, + "waltzlike": waltzlike, + }; +} + +class Ressaut { + final String apperceptive; + final String cuttoo; + final String douser; + final String drinkproof; + final String forementioned; + final String freesia; + final String genevieve; + final String hyperdiabolical; + final String hypocone; + final String irreverentially; + final String jumart; + final String mimosaceae; + final String mollicrush; + final String nedder; + final String retinasphalt; + final String sough; + final String steading; + final String theopaschitism; + final String undurableness; + final String unmingleable; + + Ressaut({ + required this.apperceptive, + required this.cuttoo, + required this.douser, + required this.drinkproof, + required this.forementioned, + required this.freesia, + required this.genevieve, + required this.hyperdiabolical, + required this.hypocone, + required this.irreverentially, + required this.jumart, + required this.mimosaceae, + required this.mollicrush, + required this.nedder, + required this.retinasphalt, + required this.sough, + required this.steading, + required this.theopaschitism, + required this.undurableness, + required this.unmingleable, + }); + + factory Ressaut.fromJson(Map json) => Ressaut( + apperceptive: json["apperceptive"], + cuttoo: json["cuttoo"], + douser: json["douser"], + drinkproof: json["drinkproof"], + forementioned: json["forementioned"], + freesia: json["Freesia"], + genevieve: json["Genevieve"], + hyperdiabolical: json["hyperdiabolical"], + hypocone: json["hypocone"], + irreverentially: json["irreverentially"], + jumart: json["jumart"], + mimosaceae: json["Mimosaceae"], + mollicrush: json["mollicrush"], + nedder: json["nedder"], + retinasphalt: json["retinasphalt"], + sough: json["sough"], + steading: json["steading"], + theopaschitism: json["Theopaschitism"], + undurableness: json["undurableness"], + unmingleable: json["unmingleable"], + ); + + Map toJson() => { + "apperceptive": apperceptive, + "cuttoo": cuttoo, + "douser": douser, + "drinkproof": drinkproof, + "forementioned": forementioned, + "Freesia": freesia, + "Genevieve": genevieve, + "hyperdiabolical": hyperdiabolical, + "hypocone": hypocone, + "irreverentially": irreverentially, + "jumart": jumart, + "Mimosaceae": mimosaceae, + "mollicrush": mollicrush, + "nedder": nedder, + "retinasphalt": retinasphalt, + "sough": sough, + "steading": steading, + "Theopaschitism": theopaschitism, + "undurableness": undurableness, + "unmingleable": unmingleable, + }; +} + +class RewriteClass { + final dynamic accountancy; + final dynamic cacotrophic; + final dynamic contest; + final dynamic couthily; + final dynamic falculate; + final dynamic foreseize; + final dynamic hyades; + final dynamic lemnad; + final dynamic monotheistically; + final dynamic nonflying; + final dynamic ptenoglossa; + final dynamic repatch; + final dynamic rodman; + final dynamic strung; + final dynamic titmal; + final dynamic twalpennyworth; + final dynamic unblamable; + final dynamic vertical; + final dynamic whiggification; + final dynamic yardman; + + RewriteClass({ + required this.accountancy, + required this.cacotrophic, + required this.contest, + required this.couthily, + required this.falculate, + required this.foreseize, + required this.hyades, + required this.lemnad, + required this.monotheistically, + required this.nonflying, + required this.ptenoglossa, + required this.repatch, + required this.rodman, + required this.strung, + required this.titmal, + required this.twalpennyworth, + required this.unblamable, + required this.vertical, + required this.whiggification, + required this.yardman, + }); + + factory RewriteClass.fromJson(Map json) => RewriteClass( + accountancy: json["accountancy"], + cacotrophic: json["cacotrophic"], + contest: json["contest"], + couthily: json["couthily"], + falculate: json["falculate"], + foreseize: json["foreseize"], + hyades: json["Hyades"], + lemnad: json["lemnad"], + monotheistically: json["monotheistically"], + nonflying: json["nonflying"], + ptenoglossa: json["Ptenoglossa"], + repatch: json["repatch"], + rodman: json["rodman"], + strung: json["strung"], + titmal: json["titmal"], + twalpennyworth: json["twalpennyworth"], + unblamable: json["unblamable"], + vertical: json["vertical"], + whiggification: json["Whiggification"], + yardman: json["yardman"], + ); + + Map toJson() => { + "accountancy": accountancy, + "cacotrophic": cacotrophic, + "contest": contest, + "couthily": couthily, + "falculate": falculate, + "foreseize": foreseize, + "Hyades": hyades, + "lemnad": lemnad, + "monotheistically": monotheistically, + "nonflying": nonflying, + "Ptenoglossa": ptenoglossa, + "repatch": repatch, + "rodman": rodman, + "strung": strung, + "titmal": titmal, + "twalpennyworth": twalpennyworth, + "unblamable": unblamable, + "vertical": vertical, + "Whiggification": whiggification, + "yardman": yardman, + }; +} + +class SantirClass { + final dynamic admiredly; + final dynamic demicaponier; + final dynamic epitympanic; + final dynamic investitor; + final dynamic lupiform; + final dynamic monoflagellate; + final dynamic paleoethnic; + final dynamic prediscountable; + final dynamic rhetoricals; + final dynamic roomth; + final dynamic saccharose; + final dynamic septonasal; + final dynamic serpenticide; + final dynamic setarious; + final dynamic spaework; + final dynamic stylite; + final dynamic suessiones; + final dynamic timelily; + final dynamic unprofaned; + final dynamic vorticular; + + SantirClass({ + required this.admiredly, + required this.demicaponier, + required this.epitympanic, + required this.investitor, + required this.lupiform, + required this.monoflagellate, + required this.paleoethnic, + required this.prediscountable, + required this.rhetoricals, + required this.roomth, + required this.saccharose, + required this.septonasal, + required this.serpenticide, + required this.setarious, + required this.spaework, + required this.stylite, + required this.suessiones, + required this.timelily, + required this.unprofaned, + required this.vorticular, + }); + + factory SantirClass.fromJson(Map json) => SantirClass( + admiredly: json["admiredly"], + demicaponier: json["demicaponier"], + epitympanic: json["epitympanic"], + investitor: json["investitor"], + lupiform: json["lupiform"], + monoflagellate: json["monoflagellate"], + paleoethnic: json["paleoethnic"], + prediscountable: json["prediscountable"], + rhetoricals: json["rhetoricals"], + roomth: json["roomth"], + saccharose: json["saccharose"], + septonasal: json["septonasal"], + serpenticide: json["serpenticide"], + setarious: json["setarious"], + spaework: json["spaework"], + stylite: json["stylite"], + suessiones: json["Suessiones"], + timelily: json["timelily"], + unprofaned: json["unprofaned"], + vorticular: json["vorticular"], + ); + + Map toJson() => { + "admiredly": admiredly, + "demicaponier": demicaponier, + "epitympanic": epitympanic, + "investitor": investitor, + "lupiform": lupiform, + "monoflagellate": monoflagellate, + "paleoethnic": paleoethnic, + "prediscountable": prediscountable, + "rhetoricals": rhetoricals, + "roomth": roomth, + "saccharose": saccharose, + "septonasal": septonasal, + "serpenticide": serpenticide, + "setarious": setarious, + "spaework": spaework, + "stylite": stylite, + "Suessiones": suessiones, + "timelily": timelily, + "unprofaned": unprofaned, + "vorticular": vorticular, + }; +} + +class SaxtenClass { + final dynamic algarrobilla; + final dynamic bowgrace; + final double? catharticalness; + final dynamic centaurid; + final int? chirotherium; + final String? disdiapason; + final dynamic flix; + final dynamic germanely; + final bool? homocerc; + final dynamic inhume; + final dynamic lepidote; + final dynamic megalochirous; + final dynamic ninepenny; + final dynamic nonbookish; + final dynamic nondeist; + final dynamic nymphaeaceous; + final dynamic parietofrontal; + final dynamic sancyite; + final dynamic subjectivist; + final dynamic tibiad; + final dynamic transonic; + final dynamic tripetalous; + final dynamic trunchman; + final dynamic urger; + final dynamic withdrawnness; + + SaxtenClass({ + this.algarrobilla, + this.bowgrace, + this.catharticalness, + this.centaurid, + this.chirotherium, + this.disdiapason, + this.flix, + this.germanely, + this.homocerc, + this.inhume, + this.lepidote, + this.megalochirous, + this.ninepenny, + this.nonbookish, + this.nondeist, + this.nymphaeaceous, + this.parietofrontal, + this.sancyite, + this.subjectivist, + this.tibiad, + this.transonic, + this.tripetalous, + this.trunchman, + this.urger, + this.withdrawnness, + }); + + factory SaxtenClass.fromJson(Map json) => SaxtenClass( + algarrobilla: json["algarrobilla"], + bowgrace: json["bowgrace"], + catharticalness: json["catharticalness"]?.toDouble(), + centaurid: json["Centaurid"], + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + flix: json["flix"], + germanely: json["germanely"], + homocerc: json["homocerc"], + inhume: json["inhume"], + lepidote: json["lepidote"], + megalochirous: json["megalochirous"], + ninepenny: json["ninepenny"], + nonbookish: json["nonbookish"], + nondeist: json["nondeist"], + nymphaeaceous: json["nymphaeaceous"], + parietofrontal: json["parietofrontal"], + sancyite: json["sancyite"], + subjectivist: json["subjectivist"], + tibiad: json["tibiad"], + transonic: json["transonic"], + tripetalous: json["tripetalous"], + trunchman: json["trunchman"], + urger: json["urger"], + withdrawnness: json["withdrawnness"], + ); + + Map toJson() => { + "algarrobilla": algarrobilla, + "bowgrace": bowgrace, + "catharticalness": catharticalness, + "Centaurid": centaurid, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "flix": flix, + "germanely": germanely, + "homocerc": homocerc, + "inhume": inhume, + "lepidote": lepidote, + "megalochirous": megalochirous, + "ninepenny": ninepenny, + "nonbookish": nonbookish, + "nondeist": nondeist, + "nymphaeaceous": nymphaeaceous, + "parietofrontal": parietofrontal, + "sancyite": sancyite, + "subjectivist": subjectivist, + "tibiad": tibiad, + "transonic": transonic, + "tripetalous": tripetalous, + "trunchman": trunchman, + "urger": urger, + "withdrawnness": withdrawnness, + }; +} + +class Scatty { + final dynamic aeriferous; + final dynamic antical; + final dynamic antighostism; + final dynamic arcanum; + final dynamic autotrophy; + final dynamic baronial; + final dynamic caffeine; + final dynamic gorgoniacean; + final dynamic heroical; + final dynamic hydropical; + final dynamic mechanology; + final dynamic musicopoetic; + final dynamic officiality; + final dynamic oftentimes; + final dynamic ophthalmotonometer; + final dynamic reflectively; + final dynamic springer; + final dynamic tabasco; + final dynamic teleianthous; + final dynamic uncombated; + + Scatty({ + required this.aeriferous, + required this.antical, + required this.antighostism, + required this.arcanum, + required this.autotrophy, + required this.baronial, + required this.caffeine, + required this.gorgoniacean, + required this.heroical, + required this.hydropical, + required this.mechanology, + required this.musicopoetic, + required this.officiality, + required this.oftentimes, + required this.ophthalmotonometer, + required this.reflectively, + required this.springer, + required this.tabasco, + required this.teleianthous, + required this.uncombated, + }); + + factory Scatty.fromJson(Map json) => Scatty( + aeriferous: json["aeriferous"], + antical: json["antical"], + antighostism: json["antighostism"], + arcanum: json["arcanum"], + autotrophy: json["autotrophy"], + baronial: json["baronial"], + caffeine: json["caffeine"], + gorgoniacean: json["gorgoniacean"], + heroical: json["heroical"], + hydropical: json["hydropical"], + mechanology: json["mechanology"], + musicopoetic: json["musicopoetic"], + officiality: json["officiality"], + oftentimes: json["oftentimes"], + ophthalmotonometer: json["ophthalmotonometer"], + reflectively: json["reflectively"], + springer: json["springer"], + tabasco: json["Tabasco"], + teleianthous: json["teleianthous"], + uncombated: json["uncombated"], + ); + + Map toJson() => { + "aeriferous": aeriferous, + "antical": antical, + "antighostism": antighostism, + "arcanum": arcanum, + "autotrophy": autotrophy, + "baronial": baronial, + "caffeine": caffeine, + "gorgoniacean": gorgoniacean, + "heroical": heroical, + "hydropical": hydropical, + "mechanology": mechanology, + "musicopoetic": musicopoetic, + "officiality": officiality, + "oftentimes": oftentimes, + "ophthalmotonometer": ophthalmotonometer, + "reflectively": reflectively, + "springer": springer, + "Tabasco": tabasco, + "teleianthous": teleianthous, + "uncombated": uncombated, + }; +} + +class SisteringClass { + final dynamic amphicarpic; + final dynamic chianti; + final dynamic frigorific; + final dynamic haplomi; + final dynamic hyperkinesis; + final dynamic laudable; + final dynamic madwoman; + final dynamic maimedly; + final dynamic micropterygidae; + final dynamic microrhabdus; + final dynamic nondense; + final dynamic phlebemphraxis; + final dynamic redsear; + final dynamic schismatical; + final dynamic tartryl; + final dynamic unabhorred; + final dynamic undeliberateness; + final dynamic unmixable; + final dynamic untruckling; + final dynamic vineal; + + SisteringClass({ + required this.amphicarpic, + required this.chianti, + required this.frigorific, + required this.haplomi, + required this.hyperkinesis, + required this.laudable, + required this.madwoman, + required this.maimedly, + required this.micropterygidae, + required this.microrhabdus, + required this.nondense, + required this.phlebemphraxis, + required this.redsear, + required this.schismatical, + required this.tartryl, + required this.unabhorred, + required this.undeliberateness, + required this.unmixable, + required this.untruckling, + required this.vineal, + }); + + factory SisteringClass.fromJson(Map json) => SisteringClass( + amphicarpic: json["amphicarpic"], + chianti: json["Chianti"], + frigorific: json["frigorific"], + haplomi: json["Haplomi"], + hyperkinesis: json["hyperkinesis"], + laudable: json["laudable"], + madwoman: json["madwoman"], + maimedly: json["maimedly"], + micropterygidae: json["Micropterygidae"], + microrhabdus: json["microrhabdus"], + nondense: json["nondense"], + phlebemphraxis: json["phlebemphraxis"], + redsear: json["redsear"], + schismatical: json["schismatical"], + tartryl: json["tartryl"], + unabhorred: json["unabhorred"], + undeliberateness: json["undeliberateness"], + unmixable: json["unmixable"], + untruckling: json["untruckling"], + vineal: json["vineal"], + ); + + Map toJson() => { + "amphicarpic": amphicarpic, + "Chianti": chianti, + "frigorific": frigorific, + "Haplomi": haplomi, + "hyperkinesis": hyperkinesis, + "laudable": laudable, + "madwoman": madwoman, + "maimedly": maimedly, + "Micropterygidae": micropterygidae, + "microrhabdus": microrhabdus, + "nondense": nondense, + "phlebemphraxis": phlebemphraxis, + "redsear": redsear, + "schismatical": schismatical, + "tartryl": tartryl, + "unabhorred": unabhorred, + "undeliberateness": undeliberateness, + "unmixable": unmixable, + "untruckling": untruckling, + "vineal": vineal, + }; +} + +class Staghunting { + final int? calorimetric; + final int? canid; + final double? catharticalness; + final int? chirotherium; + final String? disdiapason; + final int? ditriglyphic; + final int? floriferousness; + final int? gamelike; + final int? grig; + final bool? homocerc; + final int? interloan; + final int? lithotomy; + final int? loric; + final int? membranocoriaceous; + final int? membranogenic; + final dynamic nonbookish; + final int? overtrump; + final int? scotino; + final int? seasonable; + final int? sephen; + final int? stigmarioid; + final int? tired; + final int? trifid; + final int? undefeatedly; + final int? ungirlish; + + Staghunting({ + this.calorimetric, + this.canid, + this.catharticalness, + this.chirotherium, + this.disdiapason, + this.ditriglyphic, + this.floriferousness, + this.gamelike, + this.grig, + this.homocerc, + this.interloan, + this.lithotomy, + this.loric, + this.membranocoriaceous, + this.membranogenic, + this.nonbookish, + this.overtrump, + this.scotino, + this.seasonable, + this.sephen, + this.stigmarioid, + this.tired, + this.trifid, + this.undefeatedly, + this.ungirlish, + }); + + factory Staghunting.fromJson(Map json) => Staghunting( + calorimetric: json["calorimetric"], + canid: json["canid"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + ditriglyphic: json["ditriglyphic"], + floriferousness: json["floriferousness"], + gamelike: json["gamelike"], + grig: json["grig"], + homocerc: json["homocerc"], + interloan: json["interloan"], + lithotomy: json["lithotomy"], + loric: json["loric"], + membranocoriaceous: json["membranocoriaceous"], + membranogenic: json["membranogenic"], + nonbookish: json["nonbookish"], + overtrump: json["overtrump"], + scotino: json["scotino"], + seasonable: json["seasonable"], + sephen: json["sephen"], + stigmarioid: json["stigmarioid"], + tired: json["tired"], + trifid: json["trifid"], + undefeatedly: json["undefeatedly"], + ungirlish: json["ungirlish"], + ); + + Map toJson() => { + "calorimetric": calorimetric, + "canid": canid, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "ditriglyphic": ditriglyphic, + "floriferousness": floriferousness, + "gamelike": gamelike, + "grig": grig, + "homocerc": homocerc, + "interloan": interloan, + "lithotomy": lithotomy, + "loric": loric, + "membranocoriaceous": membranocoriaceous, + "membranogenic": membranogenic, + "nonbookish": nonbookish, + "overtrump": overtrump, + "scotino": scotino, + "seasonable": seasonable, + "sephen": sephen, + "stigmarioid": stigmarioid, + "tired": tired, + "trifid": trifid, + "undefeatedly": undefeatedly, + "ungirlish": ungirlish, + }; +} + +class StrenuosityClass { + final int? bliss; + final int? buccate; + final int? bulletproof; + final double? catharticalness; + final int? chirotherium; + final int? crumblingness; + final String? disdiapason; + final int? engagedly; + final int? fightable; + final int? hoariness; + final bool? homocerc; + final int? hypopodium; + final int? luxurist; + final int? mechanician; + final dynamic nonbookish; + final int? onopordon; + final int? podgily; + final int? reformableness; + final int? scatterbrains; + final int? seminuria; + final int? sodomite; + final int? tramp; + final int? undueness; + final int? worthily; + final int? yankeeist; + + StrenuosityClass({ + this.bliss, + this.buccate, + this.bulletproof, + this.catharticalness, + this.chirotherium, + this.crumblingness, + this.disdiapason, + this.engagedly, + this.fightable, + this.hoariness, + this.homocerc, + this.hypopodium, + this.luxurist, + this.mechanician, + this.nonbookish, + this.onopordon, + this.podgily, + this.reformableness, + this.scatterbrains, + this.seminuria, + this.sodomite, + this.tramp, + this.undueness, + this.worthily, + this.yankeeist, + }); + + factory StrenuosityClass.fromJson(Map json) => StrenuosityClass( + bliss: json["bliss"], + buccate: json["buccate"], + bulletproof: json["bulletproof"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + crumblingness: json["crumblingness"], + disdiapason: json["disdiapason"], + engagedly: json["engagedly"], + fightable: json["fightable"], + hoariness: json["hoariness"], + homocerc: json["homocerc"], + hypopodium: json["hypopodium"], + luxurist: json["luxurist"], + mechanician: json["mechanician"], + nonbookish: json["nonbookish"], + onopordon: json["Onopordon"], + podgily: json["podgily"], + reformableness: json["reformableness"], + scatterbrains: json["scatterbrains"], + seminuria: json["seminuria"], + sodomite: json["Sodomite"], + tramp: json["tramp"], + undueness: json["undueness"], + worthily: json["worthily"], + yankeeist: json["Yankeeist"], + ); + + Map toJson() => { + "bliss": bliss, + "buccate": buccate, + "bulletproof": bulletproof, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "crumblingness": crumblingness, + "disdiapason": disdiapason, + "engagedly": engagedly, + "fightable": fightable, + "hoariness": hoariness, + "homocerc": homocerc, + "hypopodium": hypopodium, + "luxurist": luxurist, + "mechanician": mechanician, + "nonbookish": nonbookish, + "Onopordon": onopordon, + "podgily": podgily, + "reformableness": reformableness, + "scatterbrains": scatterbrains, + "seminuria": seminuria, + "Sodomite": sodomite, + "tramp": tramp, + "undueness": undueness, + "worthily": worthily, + "Yankeeist": yankeeist, + }; +} + +class TruantcyClass { + final dynamic alfiona; + final dynamic ascaridiasis; + final dynamic bungey; + final double? catharticalness; + final dynamic ceroxyle; + final int? chirotherium; + final dynamic chorology; + final String? disdiapason; + final dynamic enmarble; + final dynamic epeira; + final dynamic eurylaimi; + final dynamic germination; + final dynamic hallelujah; + final bool? homocerc; + final dynamic lev; + final dynamic mouthing; + final dynamic nonbookish; + final dynamic philliloo; + final dynamic planetal; + final dynamic poney; + final dynamic punctualist; + final dynamic returnlessly; + final dynamic skelder; + final dynamic windwaywardly; + final dynamic yuman; + + TruantcyClass({ + this.alfiona, + this.ascaridiasis, + this.bungey, + this.catharticalness, + this.ceroxyle, + this.chirotherium, + this.chorology, + this.disdiapason, + this.enmarble, + this.epeira, + this.eurylaimi, + this.germination, + this.hallelujah, + this.homocerc, + this.lev, + this.mouthing, + this.nonbookish, + this.philliloo, + this.planetal, + this.poney, + this.punctualist, + this.returnlessly, + this.skelder, + this.windwaywardly, + this.yuman, + }); + + factory TruantcyClass.fromJson(Map json) => TruantcyClass( + alfiona: json["alfiona"], + ascaridiasis: json["ascaridiasis"], + bungey: json["bungey"], + catharticalness: json["catharticalness"]?.toDouble(), + ceroxyle: json["ceroxyle"], + chirotherium: json["Chirotherium"], + chorology: json["chorology"], + disdiapason: json["disdiapason"], + enmarble: json["enmarble"], + epeira: json["Epeira"], + eurylaimi: json["Eurylaimi"], + germination: json["germination"], + hallelujah: json["hallelujah"], + homocerc: json["homocerc"], + lev: json["lev"], + mouthing: json["mouthing"], + nonbookish: json["nonbookish"], + philliloo: json["philliloo"], + planetal: json["planetal"], + poney: json["poney"], + punctualist: json["punctualist"], + returnlessly: json["returnlessly"], + skelder: json["skelder"], + windwaywardly: json["windwaywardly"], + yuman: json["Yuman"], + ); + + Map toJson() => { + "alfiona": alfiona, + "ascaridiasis": ascaridiasis, + "bungey": bungey, + "catharticalness": catharticalness, + "ceroxyle": ceroxyle, + "Chirotherium": chirotherium, + "chorology": chorology, + "disdiapason": disdiapason, + "enmarble": enmarble, + "Epeira": epeira, + "Eurylaimi": eurylaimi, + "germination": germination, + "hallelujah": hallelujah, + "homocerc": homocerc, + "lev": lev, + "mouthing": mouthing, + "nonbookish": nonbookish, + "philliloo": philliloo, + "planetal": planetal, + "poney": poney, + "punctualist": punctualist, + "returnlessly": returnlessly, + "skelder": skelder, + "windwaywardly": windwaywardly, + "Yuman": yuman, + }; +} + +class UnimpeachablyClass { + final int? acerin; + final int? bobadil; + final double? catharticalness; + final int? chirotherium; + final int? chlorophylligenous; + final int? conversational; + final int? demiowl; + final String? disdiapason; + final int? ectorhinal; + final int? gamblesomeness; + final bool? homocerc; + final int? irrorate; + final int? kindergartening; + final int? lateritic; + final int? mespil; + final int? misconfiguration; + final dynamic nonbookish; + final int? planometry; + final int? quiina; + final int? robert; + final int? rot; + final int? subcinctorium; + final int? tussocker; + final int? ultraproud; + final int? unsuggestedness; + + UnimpeachablyClass({ + this.acerin, + this.bobadil, + this.catharticalness, + this.chirotherium, + this.chlorophylligenous, + this.conversational, + this.demiowl, + this.disdiapason, + this.ectorhinal, + this.gamblesomeness, + this.homocerc, + this.irrorate, + this.kindergartening, + this.lateritic, + this.mespil, + this.misconfiguration, + this.nonbookish, + this.planometry, + this.quiina, + this.robert, + this.rot, + this.subcinctorium, + this.tussocker, + this.ultraproud, + this.unsuggestedness, + }); + + factory UnimpeachablyClass.fromJson(Map json) => UnimpeachablyClass( + acerin: json["acerin"], + bobadil: json["Bobadil"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + chlorophylligenous: json["chlorophylligenous"], + conversational: json["conversational"], + demiowl: json["demiowl"], + disdiapason: json["disdiapason"], + ectorhinal: json["ectorhinal"], + gamblesomeness: json["gamblesomeness"], + homocerc: json["homocerc"], + irrorate: json["irrorate"], + kindergartening: json["kindergartening"], + lateritic: json["lateritic"], + mespil: json["mespil"], + misconfiguration: json["misconfiguration"], + nonbookish: json["nonbookish"], + planometry: json["planometry"], + quiina: json["Quiina"], + robert: json["Robert"], + rot: json["rot"], + subcinctorium: json["subcinctorium"], + tussocker: json["tussocker"], + ultraproud: json["ultraproud"], + unsuggestedness: json["unsuggestedness"], + ); + + Map toJson() => { + "acerin": acerin, + "Bobadil": bobadil, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "chlorophylligenous": chlorophylligenous, + "conversational": conversational, + "demiowl": demiowl, + "disdiapason": disdiapason, + "ectorhinal": ectorhinal, + "gamblesomeness": gamblesomeness, + "homocerc": homocerc, + "irrorate": irrorate, + "kindergartening": kindergartening, + "lateritic": lateritic, + "mespil": mespil, + "misconfiguration": misconfiguration, + "nonbookish": nonbookish, + "planometry": planometry, + "Quiina": quiina, + "Robert": robert, + "rot": rot, + "subcinctorium": subcinctorium, + "tussocker": tussocker, + "ultraproud": ultraproud, + "unsuggestedness": unsuggestedness, + }; +} + +class UnstressedClass { + final dynamic alain; + final dynamic amphirhina; + final dynamic antimachinery; + final dynamic coldish; + final dynamic crantara; + final dynamic distinguishing; + final dynamic elytroposis; + final dynamic gentianwort; + final dynamic heliosis; + final dynamic instrumental; + final dynamic introinflection; + final dynamic kala; + final dynamic lincolnian; + final dynamic metad; + final dynamic sarcophilus; + final dynamic swingingly; + final dynamic unconformity; + final dynamic undecreed; + final dynamic venerable; + final dynamic vowellessness; + + UnstressedClass({ + required this.alain, + required this.amphirhina, + required this.antimachinery, + required this.coldish, + required this.crantara, + required this.distinguishing, + required this.elytroposis, + required this.gentianwort, + required this.heliosis, + required this.instrumental, + required this.introinflection, + required this.kala, + required this.lincolnian, + required this.metad, + required this.sarcophilus, + required this.swingingly, + required this.unconformity, + required this.undecreed, + required this.venerable, + required this.vowellessness, + }); + + factory UnstressedClass.fromJson(Map json) => UnstressedClass( + alain: json["Alain"], + amphirhina: json["Amphirhina"], + antimachinery: json["antimachinery"], + coldish: json["coldish"], + crantara: json["crantara"], + distinguishing: json["distinguishing"], + elytroposis: json["elytroposis"], + gentianwort: json["gentianwort"], + heliosis: json["heliosis"], + instrumental: json["instrumental"], + introinflection: json["introinflection"], + kala: json["kala"], + lincolnian: json["Lincolnian"], + metad: json["metad"], + sarcophilus: json["Sarcophilus"], + swingingly: json["swingingly"], + unconformity: json["unconformity"], + undecreed: json["undecreed"], + venerable: json["venerable"], + vowellessness: json["vowellessness"], + ); + + Map toJson() => { + "Alain": alain, + "Amphirhina": amphirhina, + "antimachinery": antimachinery, + "coldish": coldish, + "crantara": crantara, + "distinguishing": distinguishing, + "elytroposis": elytroposis, + "gentianwort": gentianwort, + "heliosis": heliosis, + "instrumental": instrumental, + "introinflection": introinflection, + "kala": kala, + "Lincolnian": lincolnian, + "metad": metad, + "Sarcophilus": sarcophilus, + "swingingly": swingingly, + "unconformity": unconformity, + "undecreed": undecreed, + "venerable": venerable, + "vowellessness": vowellessness, + }; +} + +class WrothyClass { + final dynamic aeschynanthus; + final dynamic aquiferous; + final dynamic cheapener; + final dynamic enumeration; + final dynamic ephesine; + final dynamic escadrille; + final dynamic estrous; + final dynamic interestedly; + final dynamic katakinetomer; + final dynamic mortification; + final dynamic morula; + final dynamic orthosymmetrical; + final dynamic overbark; + final dynamic politist; + final dynamic qualified; + final dynamic sphenomalar; + final dynamic throatful; + final dynamic transhumance; + final dynamic triandrian; + final dynamic unbooked; + + WrothyClass({ + required this.aeschynanthus, + required this.aquiferous, + required this.cheapener, + required this.enumeration, + required this.ephesine, + required this.escadrille, + required this.estrous, + required this.interestedly, + required this.katakinetomer, + required this.mortification, + required this.morula, + required this.orthosymmetrical, + required this.overbark, + required this.politist, + required this.qualified, + required this.sphenomalar, + required this.throatful, + required this.transhumance, + required this.triandrian, + required this.unbooked, + }); + + factory WrothyClass.fromJson(Map json) => WrothyClass( + aeschynanthus: json["Aeschynanthus"], + aquiferous: json["aquiferous"], + cheapener: json["cheapener"], + enumeration: json["enumeration"], + ephesine: json["Ephesine"], + escadrille: json["escadrille"], + estrous: json["estrous"], + interestedly: json["interestedly"], + katakinetomer: json["katakinetomer"], + mortification: json["mortification"], + morula: json["morula"], + orthosymmetrical: json["orthosymmetrical"], + overbark: json["overbark"], + politist: json["politist"], + qualified: json["qualified"], + sphenomalar: json["sphenomalar"], + throatful: json["throatful"], + transhumance: json["transhumance"], + triandrian: json["triandrian"], + unbooked: json["unbooked"], + ); + + Map toJson() => { + "Aeschynanthus": aeschynanthus, + "aquiferous": aquiferous, + "cheapener": cheapener, + "enumeration": enumeration, + "Ephesine": ephesine, + "escadrille": escadrille, + "estrous": estrous, + "interestedly": interestedly, + "katakinetomer": katakinetomer, + "mortification": mortification, + "morula": morula, + "orthosymmetrical": orthosymmetrical, + "overbark": overbark, + "politist": politist, + "qualified": qualified, + "sphenomalar": sphenomalar, + "throatful": throatful, + "transhumance": transhumance, + "triandrian": triandrian, + "unbooked": unbooked, + }; +} diff --git a/head/dart/test/inputs/json/priority/combinations4.json/final-props-false--58a791807e0c/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations4.json/final-props-false--58a791807e0c/TopLevel.dart new file mode 100644 index 0000000..dbdb05d --- /dev/null +++ b/head/dart/test/inputs/json/priority/combinations4.json/final-props-false--58a791807e0c/TopLevel.dart @@ -0,0 +1,1761 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + List protrusive; + List pulpitism; + List pyodermia; + List quebrachine; + List querier; + List rebarbative; + List reimagine; + Ressaut ressaut; + List retrocervical; + List revert; + List rewrite; + List saccoderm; + List santir; + List saprophilous; + List saxten; + List scatty; + List scoffer; + List scrampum; + double semantic; + List serpentinic; + List shadowable; + List sistering; + List staghunting; + List stagmometer; + List stimulability; + List strangleable; + List strenuosity; + List tabaxir; + List talpiform; + List thwack; + List to; + List tortricine; + List truantcy; + List turgesce; + List unbeginning; + List underdunged; + List undesirability; + List unerasing; + List unguentarium; + List unimpeachably; + List unmortgaged; + List unobstructed; + List unreceptivity; + List unsatisfactoriness; + List unsecurity; + List unstressed; + List untasked; + List unvarying; + List vehemently; + Map warriorship; + List whitepot; + List wrothy; + + TopLevel({ + required this.protrusive, + required this.pulpitism, + required this.pyodermia, + required this.quebrachine, + required this.querier, + required this.rebarbative, + required this.reimagine, + required this.ressaut, + required this.retrocervical, + required this.revert, + required this.rewrite, + required this.saccoderm, + required this.santir, + required this.saprophilous, + required this.saxten, + required this.scatty, + required this.scoffer, + required this.scrampum, + required this.semantic, + required this.serpentinic, + required this.shadowable, + required this.sistering, + required this.staghunting, + required this.stagmometer, + required this.stimulability, + required this.strangleable, + required this.strenuosity, + required this.tabaxir, + required this.talpiform, + required this.thwack, + required this.to, + required this.tortricine, + required this.truantcy, + required this.turgesce, + required this.unbeginning, + required this.underdunged, + required this.undesirability, + required this.unerasing, + required this.unguentarium, + required this.unimpeachably, + required this.unmortgaged, + required this.unobstructed, + required this.unreceptivity, + required this.unsatisfactoriness, + required this.unsecurity, + required this.unstressed, + required this.untasked, + required this.unvarying, + required this.vehemently, + required this.warriorship, + required this.whitepot, + required this.wrothy, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + protrusive: List.from(json["protrusive"].map((x) => x)), + pulpitism: List.from(json["pulpitism"].map((x) => x)), + pyodermia: List.from(json["pyodermia"].map((x) => x)), + quebrachine: List.from(json["quebrachine"].map((x) => x)), + querier: List.from(json["querier"].map((x) => x)), + rebarbative: List.from(json["rebarbative"].map((x) => x)), + reimagine: List.from(json["reimagine"].map((x) => Reimagine.fromJson(x))), + ressaut: Ressaut.fromJson(json["ressaut"]), + retrocervical: List.from(json["retrocervical"].map((x) => x)), + revert: List.from(json["revert"].map((x) => x)), + rewrite: List.from(json["rewrite"].map((x) => x)), + saccoderm: List.from(json["saccoderm"].map((x) => x)), + santir: List.from(json["santir"].map((x) => x)), + saprophilous: List.from(json["saprophilous"].map((x) => x)), + saxten: List.from(json["saxten"].map((x) => x)), + scatty: List.from(json["scatty"].map((x) => x == null ? null : Scatty.fromJson(x))), + scoffer: List.from(json["scoffer"].map((x) => x)), + scrampum: List.from(json["scrampum"].map((x) => x)), + semantic: json["semantic"]?.toDouble(), + serpentinic: List.from(json["serpentinic"].map((x) => x)), + shadowable: List.from(json["shadowable"].map((x) => x)), + sistering: List.from(json["sistering"].map((x) => x)), + staghunting: List.from(json["staghunting"].map((x) => Staghunting.fromJson(x))), + stagmometer: List.from(json["stagmometer"].map((x) => x)), + stimulability: List.from(json["stimulability"].map((x) => x)), + strangleable: List.from(json["strangleable"].map((x) => x)), + strenuosity: List.from(json["strenuosity"].map((x) => x)), + tabaxir: List.from(json["tabaxir"].map((x) => x)), + talpiform: List.from(json["talpiform"].map((x) => x)), + thwack: List.from(json["thwack"].map((x) => x)), + to: List.from(json["to"].map((x) => x?.toDouble())), + tortricine: List.from(json["tortricine"].map((x) => x)), + truantcy: List.from(json["truantcy"].map((x) => x)), + turgesce: List.from(json["turgesce"].map((x) => x)), + unbeginning: List.from(json["unbeginning"].map((x) => x)), + underdunged: List.from(json["underdunged"].map((x) => x?.toDouble())), + undesirability: List.from(json["undesirability"].map((x) => x)), + unerasing: List.from(json["unerasing"].map((x) => x)), + unguentarium: List.from(json["unguentarium"].map((x) => x)), + unimpeachably: List.from(json["unimpeachably"].map((x) => x)), + unmortgaged: List.from(json["unmortgaged"].map((x) => x)), + unobstructed: List.from(json["unobstructed"].map((x) => x)), + unreceptivity: List.from(json["unreceptivity"].map((x) => x)), + unsatisfactoriness: List.from(json["unsatisfactoriness"].map((x) => x)), + unsecurity: List.from(json["unsecurity"].map((x) => x)), + unstressed: List.from(json["unstressed"].map((x) => x)), + untasked: List.from(json["untasked"].map((x) => x)), + unvarying: List.from(json["unvarying"].map((x) => x)), + vehemently: List.from(json["vehemently"].map((x) => x)), + warriorship: Map.from(json["warriorship"]).map((k, v) => MapEntry(k, v)), + whitepot: List.from(json["whitepot"].map((x) => x)), + wrothy: List.from(json["wrothy"].map((x) => x)), + ); + + Map toJson() => { + "protrusive": List.from(protrusive.map((x) => x)), + "pulpitism": List.from(pulpitism.map((x) => x)), + "pyodermia": List.from(pyodermia.map((x) => x)), + "quebrachine": List.from(quebrachine.map((x) => x)), + "querier": List.from(querier.map((x) => x)), + "rebarbative": List.from(rebarbative.map((x) => x)), + "reimagine": List.from(reimagine.map((x) => x.toJson())), + "ressaut": ressaut.toJson(), + "retrocervical": List.from(retrocervical.map((x) => x)), + "revert": List.from(revert.map((x) => x)), + "rewrite": List.from(rewrite.map((x) => x)), + "saccoderm": List.from(saccoderm.map((x) => x)), + "santir": List.from(santir.map((x) => x)), + "saprophilous": List.from(saprophilous.map((x) => x)), + "saxten": List.from(saxten.map((x) => x)), + "scatty": List.from(scatty.map((x) => x?.toJson())), + "scoffer": List.from(scoffer.map((x) => x)), + "scrampum": List.from(scrampum.map((x) => x)), + "semantic": semantic, + "serpentinic": List.from(serpentinic.map((x) => x)), + "shadowable": List.from(shadowable.map((x) => x)), + "sistering": List.from(sistering.map((x) => x)), + "staghunting": List.from(staghunting.map((x) => x.toJson())), + "stagmometer": List.from(stagmometer.map((x) => x)), + "stimulability": List.from(stimulability.map((x) => x)), + "strangleable": List.from(strangleable.map((x) => x)), + "strenuosity": List.from(strenuosity.map((x) => x)), + "tabaxir": List.from(tabaxir.map((x) => x)), + "talpiform": List.from(talpiform.map((x) => x)), + "thwack": List.from(thwack.map((x) => x)), + "to": List.from(to.map((x) => x)), + "tortricine": List.from(tortricine.map((x) => x)), + "truantcy": List.from(truantcy.map((x) => x)), + "turgesce": List.from(turgesce.map((x) => x)), + "unbeginning": List.from(unbeginning.map((x) => x)), + "underdunged": List.from(underdunged.map((x) => x)), + "undesirability": List.from(undesirability.map((x) => x)), + "unerasing": List.from(unerasing.map((x) => x)), + "unguentarium": List.from(unguentarium.map((x) => x)), + "unimpeachably": List.from(unimpeachably.map((x) => x)), + "unmortgaged": List.from(unmortgaged.map((x) => x)), + "unobstructed": List.from(unobstructed.map((x) => x)), + "unreceptivity": List.from(unreceptivity.map((x) => x)), + "unsatisfactoriness": List.from(unsatisfactoriness.map((x) => x)), + "unsecurity": List.from(unsecurity.map((x) => x)), + "unstressed": List.from(unstressed.map((x) => x)), + "untasked": List.from(untasked.map((x) => x)), + "unvarying": List.from(unvarying.map((x) => x)), + "vehemently": List.from(vehemently.map((x) => x)), + "warriorship": Map.from(warriorship).map((k, v) => MapEntry(k, v)), + "whitepot": List.from(whitepot.map((x) => x)), + "wrothy": List.from(wrothy.map((x) => x)), + }; +} + +class PulpitismClass { + dynamic abnet; + dynamic buckhorn; + dynamic calciform; + dynamic chelophore; + dynamic cogitation; + dynamic decreeable; + dynamic despicable; + dynamic isodiazo; + dynamic jadedly; + dynamic leptochlorite; + dynamic nursling; + dynamic palamedean; + dynamic photoheliograph; + dynamic pipewood; + dynamic roberd; + dynamic statable; + dynamic superassume; + dynamic syllabe; + dynamic toughhead; + dynamic underburn; + + PulpitismClass({ + required this.abnet, + required this.buckhorn, + required this.calciform, + required this.chelophore, + required this.cogitation, + required this.decreeable, + required this.despicable, + required this.isodiazo, + required this.jadedly, + required this.leptochlorite, + required this.nursling, + required this.palamedean, + required this.photoheliograph, + required this.pipewood, + required this.roberd, + required this.statable, + required this.superassume, + required this.syllabe, + required this.toughhead, + required this.underburn, + }); + + factory PulpitismClass.fromJson(Map json) => PulpitismClass( + abnet: json["abnet"], + buckhorn: json["buckhorn"], + calciform: json["calciform"], + chelophore: json["chelophore"], + cogitation: json["cogitation"], + decreeable: json["decreeable"], + despicable: json["despicable"], + isodiazo: json["isodiazo"], + jadedly: json["jadedly"], + leptochlorite: json["leptochlorite"], + nursling: json["nursling"], + palamedean: json["palamedean"], + photoheliograph: json["photoheliograph"], + pipewood: json["pipewood"], + roberd: json["roberd"], + statable: json["statable"], + superassume: json["superassume"], + syllabe: json["syllabe"], + toughhead: json["toughhead"], + underburn: json["underburn"], + ); + + Map toJson() => { + "abnet": abnet, + "buckhorn": buckhorn, + "calciform": calciform, + "chelophore": chelophore, + "cogitation": cogitation, + "decreeable": decreeable, + "despicable": despicable, + "isodiazo": isodiazo, + "jadedly": jadedly, + "leptochlorite": leptochlorite, + "nursling": nursling, + "palamedean": palamedean, + "photoheliograph": photoheliograph, + "pipewood": pipewood, + "roberd": roberd, + "statable": statable, + "superassume": superassume, + "syllabe": syllabe, + "toughhead": toughhead, + "underburn": underburn, + }; +} + +class PyodermiaClass { + dynamic aphoristically; + dynamic apophyllous; + dynamic cognize; + dynamic dermonosology; + dynamic gyppo; + dynamic ither; + dynamic juglandaceous; + dynamic litho; + dynamic macropterous; + dynamic photographer; + dynamic romancing; + dynamic rumness; + dynamic somniloquist; + dynamic stressfully; + dynamic tactically; + dynamic tracheophony; + dynamic unappositely; + dynamic unclothedly; + dynamic unimplied; + dynamic unsyncopated; + + PyodermiaClass({ + required this.aphoristically, + required this.apophyllous, + required this.cognize, + required this.dermonosology, + required this.gyppo, + required this.ither, + required this.juglandaceous, + required this.litho, + required this.macropterous, + required this.photographer, + required this.romancing, + required this.rumness, + required this.somniloquist, + required this.stressfully, + required this.tactically, + required this.tracheophony, + required this.unappositely, + required this.unclothedly, + required this.unimplied, + required this.unsyncopated, + }); + + factory PyodermiaClass.fromJson(Map json) => PyodermiaClass( + aphoristically: json["aphoristically"], + apophyllous: json["apophyllous"], + cognize: json["cognize"], + dermonosology: json["dermonosology"], + gyppo: json["Gyppo"], + ither: json["ither"], + juglandaceous: json["juglandaceous"], + litho: json["litho"], + macropterous: json["macropterous"], + photographer: json["photographer"], + romancing: json["romancing"], + rumness: json["rumness"], + somniloquist: json["somniloquist"], + stressfully: json["stressfully"], + tactically: json["tactically"], + tracheophony: json["tracheophony"], + unappositely: json["unappositely"], + unclothedly: json["unclothedly"], + unimplied: json["unimplied"], + unsyncopated: json["unsyncopated"], + ); + + Map toJson() => { + "aphoristically": aphoristically, + "apophyllous": apophyllous, + "cognize": cognize, + "dermonosology": dermonosology, + "Gyppo": gyppo, + "ither": ither, + "juglandaceous": juglandaceous, + "litho": litho, + "macropterous": macropterous, + "photographer": photographer, + "romancing": romancing, + "rumness": rumness, + "somniloquist": somniloquist, + "stressfully": stressfully, + "tactically": tactically, + "tracheophony": tracheophony, + "unappositely": unappositely, + "unclothedly": unclothedly, + "unimplied": unimplied, + "unsyncopated": unsyncopated, + }; +} + +class QuebrachineClass { + double catharticalness; + int chirotherium; + String disdiapason; + bool homocerc; + dynamic nonbookish; + + QuebrachineClass({ + required this.catharticalness, + required this.chirotherium, + required this.disdiapason, + required this.homocerc, + required this.nonbookish, + }); + + factory QuebrachineClass.fromJson(Map json) => QuebrachineClass( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + homocerc: json["homocerc"], + nonbookish: json["nonbookish"], + ); + + Map toJson() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "homocerc": homocerc, + "nonbookish": nonbookish, + }; +} + +class Reimagine { + dynamic adducible; + dynamic anabolin; + dynamic brainy; + double? catharticalness; + int? chirotherium; + dynamic chrysamine; + String? disdiapason; + dynamic fluxweed; + dynamic glaucine; + dynamic grobianism; + dynamic hermo; + dynamic hieroglyphist; + bool? homocerc; + dynamic icteroid; + dynamic immortal; + dynamic impetulant; + dynamic irrigate; + dynamic myxedema; + dynamic nonbookish; + dynamic onyx; + dynamic repasser; + dynamic septomarginal; + dynamic subdie; + dynamic tibiometatarsal; + dynamic waltzlike; + + Reimagine({ + this.adducible, + this.anabolin, + this.brainy, + this.catharticalness, + this.chirotherium, + this.chrysamine, + this.disdiapason, + this.fluxweed, + this.glaucine, + this.grobianism, + this.hermo, + this.hieroglyphist, + this.homocerc, + this.icteroid, + this.immortal, + this.impetulant, + this.irrigate, + this.myxedema, + this.nonbookish, + this.onyx, + this.repasser, + this.septomarginal, + this.subdie, + this.tibiometatarsal, + this.waltzlike, + }); + + factory Reimagine.fromJson(Map json) => Reimagine( + adducible: json["adducible"], + anabolin: json["anabolin"], + brainy: json["brainy"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + chrysamine: json["chrysamine"], + disdiapason: json["disdiapason"], + fluxweed: json["fluxweed"], + glaucine: json["glaucine"], + grobianism: json["grobianism"], + hermo: json["Hermo"], + hieroglyphist: json["hieroglyphist"], + homocerc: json["homocerc"], + icteroid: json["icteroid"], + immortal: json["immortal"], + impetulant: json["impetulant"], + irrigate: json["irrigate"], + myxedema: json["myxedema"], + nonbookish: json["nonbookish"], + onyx: json["onyx"], + repasser: json["repasser"], + septomarginal: json["septomarginal"], + subdie: json["subdie"], + tibiometatarsal: json["tibiometatarsal"], + waltzlike: json["waltzlike"], + ); + + Map toJson() => { + "adducible": adducible, + "anabolin": anabolin, + "brainy": brainy, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "chrysamine": chrysamine, + "disdiapason": disdiapason, + "fluxweed": fluxweed, + "glaucine": glaucine, + "grobianism": grobianism, + "Hermo": hermo, + "hieroglyphist": hieroglyphist, + "homocerc": homocerc, + "icteroid": icteroid, + "immortal": immortal, + "impetulant": impetulant, + "irrigate": irrigate, + "myxedema": myxedema, + "nonbookish": nonbookish, + "onyx": onyx, + "repasser": repasser, + "septomarginal": septomarginal, + "subdie": subdie, + "tibiometatarsal": tibiometatarsal, + "waltzlike": waltzlike, + }; +} + +class Ressaut { + String apperceptive; + String cuttoo; + String douser; + String drinkproof; + String forementioned; + String freesia; + String genevieve; + String hyperdiabolical; + String hypocone; + String irreverentially; + String jumart; + String mimosaceae; + String mollicrush; + String nedder; + String retinasphalt; + String sough; + String steading; + String theopaschitism; + String undurableness; + String unmingleable; + + Ressaut({ + required this.apperceptive, + required this.cuttoo, + required this.douser, + required this.drinkproof, + required this.forementioned, + required this.freesia, + required this.genevieve, + required this.hyperdiabolical, + required this.hypocone, + required this.irreverentially, + required this.jumart, + required this.mimosaceae, + required this.mollicrush, + required this.nedder, + required this.retinasphalt, + required this.sough, + required this.steading, + required this.theopaschitism, + required this.undurableness, + required this.unmingleable, + }); + + factory Ressaut.fromJson(Map json) => Ressaut( + apperceptive: json["apperceptive"], + cuttoo: json["cuttoo"], + douser: json["douser"], + drinkproof: json["drinkproof"], + forementioned: json["forementioned"], + freesia: json["Freesia"], + genevieve: json["Genevieve"], + hyperdiabolical: json["hyperdiabolical"], + hypocone: json["hypocone"], + irreverentially: json["irreverentially"], + jumart: json["jumart"], + mimosaceae: json["Mimosaceae"], + mollicrush: json["mollicrush"], + nedder: json["nedder"], + retinasphalt: json["retinasphalt"], + sough: json["sough"], + steading: json["steading"], + theopaschitism: json["Theopaschitism"], + undurableness: json["undurableness"], + unmingleable: json["unmingleable"], + ); + + Map toJson() => { + "apperceptive": apperceptive, + "cuttoo": cuttoo, + "douser": douser, + "drinkproof": drinkproof, + "forementioned": forementioned, + "Freesia": freesia, + "Genevieve": genevieve, + "hyperdiabolical": hyperdiabolical, + "hypocone": hypocone, + "irreverentially": irreverentially, + "jumart": jumart, + "Mimosaceae": mimosaceae, + "mollicrush": mollicrush, + "nedder": nedder, + "retinasphalt": retinasphalt, + "sough": sough, + "steading": steading, + "Theopaschitism": theopaschitism, + "undurableness": undurableness, + "unmingleable": unmingleable, + }; +} + +class RewriteClass { + dynamic accountancy; + dynamic cacotrophic; + dynamic contest; + dynamic couthily; + dynamic falculate; + dynamic foreseize; + dynamic hyades; + dynamic lemnad; + dynamic monotheistically; + dynamic nonflying; + dynamic ptenoglossa; + dynamic repatch; + dynamic rodman; + dynamic strung; + dynamic titmal; + dynamic twalpennyworth; + dynamic unblamable; + dynamic vertical; + dynamic whiggification; + dynamic yardman; + + RewriteClass({ + required this.accountancy, + required this.cacotrophic, + required this.contest, + required this.couthily, + required this.falculate, + required this.foreseize, + required this.hyades, + required this.lemnad, + required this.monotheistically, + required this.nonflying, + required this.ptenoglossa, + required this.repatch, + required this.rodman, + required this.strung, + required this.titmal, + required this.twalpennyworth, + required this.unblamable, + required this.vertical, + required this.whiggification, + required this.yardman, + }); + + factory RewriteClass.fromJson(Map json) => RewriteClass( + accountancy: json["accountancy"], + cacotrophic: json["cacotrophic"], + contest: json["contest"], + couthily: json["couthily"], + falculate: json["falculate"], + foreseize: json["foreseize"], + hyades: json["Hyades"], + lemnad: json["lemnad"], + monotheistically: json["monotheistically"], + nonflying: json["nonflying"], + ptenoglossa: json["Ptenoglossa"], + repatch: json["repatch"], + rodman: json["rodman"], + strung: json["strung"], + titmal: json["titmal"], + twalpennyworth: json["twalpennyworth"], + unblamable: json["unblamable"], + vertical: json["vertical"], + whiggification: json["Whiggification"], + yardman: json["yardman"], + ); + + Map toJson() => { + "accountancy": accountancy, + "cacotrophic": cacotrophic, + "contest": contest, + "couthily": couthily, + "falculate": falculate, + "foreseize": foreseize, + "Hyades": hyades, + "lemnad": lemnad, + "monotheistically": monotheistically, + "nonflying": nonflying, + "Ptenoglossa": ptenoglossa, + "repatch": repatch, + "rodman": rodman, + "strung": strung, + "titmal": titmal, + "twalpennyworth": twalpennyworth, + "unblamable": unblamable, + "vertical": vertical, + "Whiggification": whiggification, + "yardman": yardman, + }; +} + +class SantirClass { + dynamic admiredly; + dynamic demicaponier; + dynamic epitympanic; + dynamic investitor; + dynamic lupiform; + dynamic monoflagellate; + dynamic paleoethnic; + dynamic prediscountable; + dynamic rhetoricals; + dynamic roomth; + dynamic saccharose; + dynamic septonasal; + dynamic serpenticide; + dynamic setarious; + dynamic spaework; + dynamic stylite; + dynamic suessiones; + dynamic timelily; + dynamic unprofaned; + dynamic vorticular; + + SantirClass({ + required this.admiredly, + required this.demicaponier, + required this.epitympanic, + required this.investitor, + required this.lupiform, + required this.monoflagellate, + required this.paleoethnic, + required this.prediscountable, + required this.rhetoricals, + required this.roomth, + required this.saccharose, + required this.septonasal, + required this.serpenticide, + required this.setarious, + required this.spaework, + required this.stylite, + required this.suessiones, + required this.timelily, + required this.unprofaned, + required this.vorticular, + }); + + factory SantirClass.fromJson(Map json) => SantirClass( + admiredly: json["admiredly"], + demicaponier: json["demicaponier"], + epitympanic: json["epitympanic"], + investitor: json["investitor"], + lupiform: json["lupiform"], + monoflagellate: json["monoflagellate"], + paleoethnic: json["paleoethnic"], + prediscountable: json["prediscountable"], + rhetoricals: json["rhetoricals"], + roomth: json["roomth"], + saccharose: json["saccharose"], + septonasal: json["septonasal"], + serpenticide: json["serpenticide"], + setarious: json["setarious"], + spaework: json["spaework"], + stylite: json["stylite"], + suessiones: json["Suessiones"], + timelily: json["timelily"], + unprofaned: json["unprofaned"], + vorticular: json["vorticular"], + ); + + Map toJson() => { + "admiredly": admiredly, + "demicaponier": demicaponier, + "epitympanic": epitympanic, + "investitor": investitor, + "lupiform": lupiform, + "monoflagellate": monoflagellate, + "paleoethnic": paleoethnic, + "prediscountable": prediscountable, + "rhetoricals": rhetoricals, + "roomth": roomth, + "saccharose": saccharose, + "septonasal": septonasal, + "serpenticide": serpenticide, + "setarious": setarious, + "spaework": spaework, + "stylite": stylite, + "Suessiones": suessiones, + "timelily": timelily, + "unprofaned": unprofaned, + "vorticular": vorticular, + }; +} + +class SaxtenClass { + dynamic algarrobilla; + dynamic bowgrace; + double? catharticalness; + dynamic centaurid; + int? chirotherium; + String? disdiapason; + dynamic flix; + dynamic germanely; + bool? homocerc; + dynamic inhume; + dynamic lepidote; + dynamic megalochirous; + dynamic ninepenny; + dynamic nonbookish; + dynamic nondeist; + dynamic nymphaeaceous; + dynamic parietofrontal; + dynamic sancyite; + dynamic subjectivist; + dynamic tibiad; + dynamic transonic; + dynamic tripetalous; + dynamic trunchman; + dynamic urger; + dynamic withdrawnness; + + SaxtenClass({ + this.algarrobilla, + this.bowgrace, + this.catharticalness, + this.centaurid, + this.chirotherium, + this.disdiapason, + this.flix, + this.germanely, + this.homocerc, + this.inhume, + this.lepidote, + this.megalochirous, + this.ninepenny, + this.nonbookish, + this.nondeist, + this.nymphaeaceous, + this.parietofrontal, + this.sancyite, + this.subjectivist, + this.tibiad, + this.transonic, + this.tripetalous, + this.trunchman, + this.urger, + this.withdrawnness, + }); + + factory SaxtenClass.fromJson(Map json) => SaxtenClass( + algarrobilla: json["algarrobilla"], + bowgrace: json["bowgrace"], + catharticalness: json["catharticalness"]?.toDouble(), + centaurid: json["Centaurid"], + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + flix: json["flix"], + germanely: json["germanely"], + homocerc: json["homocerc"], + inhume: json["inhume"], + lepidote: json["lepidote"], + megalochirous: json["megalochirous"], + ninepenny: json["ninepenny"], + nonbookish: json["nonbookish"], + nondeist: json["nondeist"], + nymphaeaceous: json["nymphaeaceous"], + parietofrontal: json["parietofrontal"], + sancyite: json["sancyite"], + subjectivist: json["subjectivist"], + tibiad: json["tibiad"], + transonic: json["transonic"], + tripetalous: json["tripetalous"], + trunchman: json["trunchman"], + urger: json["urger"], + withdrawnness: json["withdrawnness"], + ); + + Map toJson() => { + "algarrobilla": algarrobilla, + "bowgrace": bowgrace, + "catharticalness": catharticalness, + "Centaurid": centaurid, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "flix": flix, + "germanely": germanely, + "homocerc": homocerc, + "inhume": inhume, + "lepidote": lepidote, + "megalochirous": megalochirous, + "ninepenny": ninepenny, + "nonbookish": nonbookish, + "nondeist": nondeist, + "nymphaeaceous": nymphaeaceous, + "parietofrontal": parietofrontal, + "sancyite": sancyite, + "subjectivist": subjectivist, + "tibiad": tibiad, + "transonic": transonic, + "tripetalous": tripetalous, + "trunchman": trunchman, + "urger": urger, + "withdrawnness": withdrawnness, + }; +} + +class Scatty { + dynamic aeriferous; + dynamic antical; + dynamic antighostism; + dynamic arcanum; + dynamic autotrophy; + dynamic baronial; + dynamic caffeine; + dynamic gorgoniacean; + dynamic heroical; + dynamic hydropical; + dynamic mechanology; + dynamic musicopoetic; + dynamic officiality; + dynamic oftentimes; + dynamic ophthalmotonometer; + dynamic reflectively; + dynamic springer; + dynamic tabasco; + dynamic teleianthous; + dynamic uncombated; + + Scatty({ + required this.aeriferous, + required this.antical, + required this.antighostism, + required this.arcanum, + required this.autotrophy, + required this.baronial, + required this.caffeine, + required this.gorgoniacean, + required this.heroical, + required this.hydropical, + required this.mechanology, + required this.musicopoetic, + required this.officiality, + required this.oftentimes, + required this.ophthalmotonometer, + required this.reflectively, + required this.springer, + required this.tabasco, + required this.teleianthous, + required this.uncombated, + }); + + factory Scatty.fromJson(Map json) => Scatty( + aeriferous: json["aeriferous"], + antical: json["antical"], + antighostism: json["antighostism"], + arcanum: json["arcanum"], + autotrophy: json["autotrophy"], + baronial: json["baronial"], + caffeine: json["caffeine"], + gorgoniacean: json["gorgoniacean"], + heroical: json["heroical"], + hydropical: json["hydropical"], + mechanology: json["mechanology"], + musicopoetic: json["musicopoetic"], + officiality: json["officiality"], + oftentimes: json["oftentimes"], + ophthalmotonometer: json["ophthalmotonometer"], + reflectively: json["reflectively"], + springer: json["springer"], + tabasco: json["Tabasco"], + teleianthous: json["teleianthous"], + uncombated: json["uncombated"], + ); + + Map toJson() => { + "aeriferous": aeriferous, + "antical": antical, + "antighostism": antighostism, + "arcanum": arcanum, + "autotrophy": autotrophy, + "baronial": baronial, + "caffeine": caffeine, + "gorgoniacean": gorgoniacean, + "heroical": heroical, + "hydropical": hydropical, + "mechanology": mechanology, + "musicopoetic": musicopoetic, + "officiality": officiality, + "oftentimes": oftentimes, + "ophthalmotonometer": ophthalmotonometer, + "reflectively": reflectively, + "springer": springer, + "Tabasco": tabasco, + "teleianthous": teleianthous, + "uncombated": uncombated, + }; +} + +class SisteringClass { + dynamic amphicarpic; + dynamic chianti; + dynamic frigorific; + dynamic haplomi; + dynamic hyperkinesis; + dynamic laudable; + dynamic madwoman; + dynamic maimedly; + dynamic micropterygidae; + dynamic microrhabdus; + dynamic nondense; + dynamic phlebemphraxis; + dynamic redsear; + dynamic schismatical; + dynamic tartryl; + dynamic unabhorred; + dynamic undeliberateness; + dynamic unmixable; + dynamic untruckling; + dynamic vineal; + + SisteringClass({ + required this.amphicarpic, + required this.chianti, + required this.frigorific, + required this.haplomi, + required this.hyperkinesis, + required this.laudable, + required this.madwoman, + required this.maimedly, + required this.micropterygidae, + required this.microrhabdus, + required this.nondense, + required this.phlebemphraxis, + required this.redsear, + required this.schismatical, + required this.tartryl, + required this.unabhorred, + required this.undeliberateness, + required this.unmixable, + required this.untruckling, + required this.vineal, + }); + + factory SisteringClass.fromJson(Map json) => SisteringClass( + amphicarpic: json["amphicarpic"], + chianti: json["Chianti"], + frigorific: json["frigorific"], + haplomi: json["Haplomi"], + hyperkinesis: json["hyperkinesis"], + laudable: json["laudable"], + madwoman: json["madwoman"], + maimedly: json["maimedly"], + micropterygidae: json["Micropterygidae"], + microrhabdus: json["microrhabdus"], + nondense: json["nondense"], + phlebemphraxis: json["phlebemphraxis"], + redsear: json["redsear"], + schismatical: json["schismatical"], + tartryl: json["tartryl"], + unabhorred: json["unabhorred"], + undeliberateness: json["undeliberateness"], + unmixable: json["unmixable"], + untruckling: json["untruckling"], + vineal: json["vineal"], + ); + + Map toJson() => { + "amphicarpic": amphicarpic, + "Chianti": chianti, + "frigorific": frigorific, + "Haplomi": haplomi, + "hyperkinesis": hyperkinesis, + "laudable": laudable, + "madwoman": madwoman, + "maimedly": maimedly, + "Micropterygidae": micropterygidae, + "microrhabdus": microrhabdus, + "nondense": nondense, + "phlebemphraxis": phlebemphraxis, + "redsear": redsear, + "schismatical": schismatical, + "tartryl": tartryl, + "unabhorred": unabhorred, + "undeliberateness": undeliberateness, + "unmixable": unmixable, + "untruckling": untruckling, + "vineal": vineal, + }; +} + +class Staghunting { + int? calorimetric; + int? canid; + double? catharticalness; + int? chirotherium; + String? disdiapason; + int? ditriglyphic; + int? floriferousness; + int? gamelike; + int? grig; + bool? homocerc; + int? interloan; + int? lithotomy; + int? loric; + int? membranocoriaceous; + int? membranogenic; + dynamic nonbookish; + int? overtrump; + int? scotino; + int? seasonable; + int? sephen; + int? stigmarioid; + int? tired; + int? trifid; + int? undefeatedly; + int? ungirlish; + + Staghunting({ + this.calorimetric, + this.canid, + this.catharticalness, + this.chirotherium, + this.disdiapason, + this.ditriglyphic, + this.floriferousness, + this.gamelike, + this.grig, + this.homocerc, + this.interloan, + this.lithotomy, + this.loric, + this.membranocoriaceous, + this.membranogenic, + this.nonbookish, + this.overtrump, + this.scotino, + this.seasonable, + this.sephen, + this.stigmarioid, + this.tired, + this.trifid, + this.undefeatedly, + this.ungirlish, + }); + + factory Staghunting.fromJson(Map json) => Staghunting( + calorimetric: json["calorimetric"], + canid: json["canid"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + ditriglyphic: json["ditriglyphic"], + floriferousness: json["floriferousness"], + gamelike: json["gamelike"], + grig: json["grig"], + homocerc: json["homocerc"], + interloan: json["interloan"], + lithotomy: json["lithotomy"], + loric: json["loric"], + membranocoriaceous: json["membranocoriaceous"], + membranogenic: json["membranogenic"], + nonbookish: json["nonbookish"], + overtrump: json["overtrump"], + scotino: json["scotino"], + seasonable: json["seasonable"], + sephen: json["sephen"], + stigmarioid: json["stigmarioid"], + tired: json["tired"], + trifid: json["trifid"], + undefeatedly: json["undefeatedly"], + ungirlish: json["ungirlish"], + ); + + Map toJson() => { + "calorimetric": calorimetric, + "canid": canid, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "ditriglyphic": ditriglyphic, + "floriferousness": floriferousness, + "gamelike": gamelike, + "grig": grig, + "homocerc": homocerc, + "interloan": interloan, + "lithotomy": lithotomy, + "loric": loric, + "membranocoriaceous": membranocoriaceous, + "membranogenic": membranogenic, + "nonbookish": nonbookish, + "overtrump": overtrump, + "scotino": scotino, + "seasonable": seasonable, + "sephen": sephen, + "stigmarioid": stigmarioid, + "tired": tired, + "trifid": trifid, + "undefeatedly": undefeatedly, + "ungirlish": ungirlish, + }; +} + +class StrenuosityClass { + int? bliss; + int? buccate; + int? bulletproof; + double? catharticalness; + int? chirotherium; + int? crumblingness; + String? disdiapason; + int? engagedly; + int? fightable; + int? hoariness; + bool? homocerc; + int? hypopodium; + int? luxurist; + int? mechanician; + dynamic nonbookish; + int? onopordon; + int? podgily; + int? reformableness; + int? scatterbrains; + int? seminuria; + int? sodomite; + int? tramp; + int? undueness; + int? worthily; + int? yankeeist; + + StrenuosityClass({ + this.bliss, + this.buccate, + this.bulletproof, + this.catharticalness, + this.chirotherium, + this.crumblingness, + this.disdiapason, + this.engagedly, + this.fightable, + this.hoariness, + this.homocerc, + this.hypopodium, + this.luxurist, + this.mechanician, + this.nonbookish, + this.onopordon, + this.podgily, + this.reformableness, + this.scatterbrains, + this.seminuria, + this.sodomite, + this.tramp, + this.undueness, + this.worthily, + this.yankeeist, + }); + + factory StrenuosityClass.fromJson(Map json) => StrenuosityClass( + bliss: json["bliss"], + buccate: json["buccate"], + bulletproof: json["bulletproof"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + crumblingness: json["crumblingness"], + disdiapason: json["disdiapason"], + engagedly: json["engagedly"], + fightable: json["fightable"], + hoariness: json["hoariness"], + homocerc: json["homocerc"], + hypopodium: json["hypopodium"], + luxurist: json["luxurist"], + mechanician: json["mechanician"], + nonbookish: json["nonbookish"], + onopordon: json["Onopordon"], + podgily: json["podgily"], + reformableness: json["reformableness"], + scatterbrains: json["scatterbrains"], + seminuria: json["seminuria"], + sodomite: json["Sodomite"], + tramp: json["tramp"], + undueness: json["undueness"], + worthily: json["worthily"], + yankeeist: json["Yankeeist"], + ); + + Map toJson() => { + "bliss": bliss, + "buccate": buccate, + "bulletproof": bulletproof, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "crumblingness": crumblingness, + "disdiapason": disdiapason, + "engagedly": engagedly, + "fightable": fightable, + "hoariness": hoariness, + "homocerc": homocerc, + "hypopodium": hypopodium, + "luxurist": luxurist, + "mechanician": mechanician, + "nonbookish": nonbookish, + "Onopordon": onopordon, + "podgily": podgily, + "reformableness": reformableness, + "scatterbrains": scatterbrains, + "seminuria": seminuria, + "Sodomite": sodomite, + "tramp": tramp, + "undueness": undueness, + "worthily": worthily, + "Yankeeist": yankeeist, + }; +} + +class TruantcyClass { + dynamic alfiona; + dynamic ascaridiasis; + dynamic bungey; + double? catharticalness; + dynamic ceroxyle; + int? chirotherium; + dynamic chorology; + String? disdiapason; + dynamic enmarble; + dynamic epeira; + dynamic eurylaimi; + dynamic germination; + dynamic hallelujah; + bool? homocerc; + dynamic lev; + dynamic mouthing; + dynamic nonbookish; + dynamic philliloo; + dynamic planetal; + dynamic poney; + dynamic punctualist; + dynamic returnlessly; + dynamic skelder; + dynamic windwaywardly; + dynamic yuman; + + TruantcyClass({ + this.alfiona, + this.ascaridiasis, + this.bungey, + this.catharticalness, + this.ceroxyle, + this.chirotherium, + this.chorology, + this.disdiapason, + this.enmarble, + this.epeira, + this.eurylaimi, + this.germination, + this.hallelujah, + this.homocerc, + this.lev, + this.mouthing, + this.nonbookish, + this.philliloo, + this.planetal, + this.poney, + this.punctualist, + this.returnlessly, + this.skelder, + this.windwaywardly, + this.yuman, + }); + + factory TruantcyClass.fromJson(Map json) => TruantcyClass( + alfiona: json["alfiona"], + ascaridiasis: json["ascaridiasis"], + bungey: json["bungey"], + catharticalness: json["catharticalness"]?.toDouble(), + ceroxyle: json["ceroxyle"], + chirotherium: json["Chirotherium"], + chorology: json["chorology"], + disdiapason: json["disdiapason"], + enmarble: json["enmarble"], + epeira: json["Epeira"], + eurylaimi: json["Eurylaimi"], + germination: json["germination"], + hallelujah: json["hallelujah"], + homocerc: json["homocerc"], + lev: json["lev"], + mouthing: json["mouthing"], + nonbookish: json["nonbookish"], + philliloo: json["philliloo"], + planetal: json["planetal"], + poney: json["poney"], + punctualist: json["punctualist"], + returnlessly: json["returnlessly"], + skelder: json["skelder"], + windwaywardly: json["windwaywardly"], + yuman: json["Yuman"], + ); + + Map toJson() => { + "alfiona": alfiona, + "ascaridiasis": ascaridiasis, + "bungey": bungey, + "catharticalness": catharticalness, + "ceroxyle": ceroxyle, + "Chirotherium": chirotherium, + "chorology": chorology, + "disdiapason": disdiapason, + "enmarble": enmarble, + "Epeira": epeira, + "Eurylaimi": eurylaimi, + "germination": germination, + "hallelujah": hallelujah, + "homocerc": homocerc, + "lev": lev, + "mouthing": mouthing, + "nonbookish": nonbookish, + "philliloo": philliloo, + "planetal": planetal, + "poney": poney, + "punctualist": punctualist, + "returnlessly": returnlessly, + "skelder": skelder, + "windwaywardly": windwaywardly, + "Yuman": yuman, + }; +} + +class UnimpeachablyClass { + int? acerin; + int? bobadil; + double? catharticalness; + int? chirotherium; + int? chlorophylligenous; + int? conversational; + int? demiowl; + String? disdiapason; + int? ectorhinal; + int? gamblesomeness; + bool? homocerc; + int? irrorate; + int? kindergartening; + int? lateritic; + int? mespil; + int? misconfiguration; + dynamic nonbookish; + int? planometry; + int? quiina; + int? robert; + int? rot; + int? subcinctorium; + int? tussocker; + int? ultraproud; + int? unsuggestedness; + + UnimpeachablyClass({ + this.acerin, + this.bobadil, + this.catharticalness, + this.chirotherium, + this.chlorophylligenous, + this.conversational, + this.demiowl, + this.disdiapason, + this.ectorhinal, + this.gamblesomeness, + this.homocerc, + this.irrorate, + this.kindergartening, + this.lateritic, + this.mespil, + this.misconfiguration, + this.nonbookish, + this.planometry, + this.quiina, + this.robert, + this.rot, + this.subcinctorium, + this.tussocker, + this.ultraproud, + this.unsuggestedness, + }); + + factory UnimpeachablyClass.fromJson(Map json) => UnimpeachablyClass( + acerin: json["acerin"], + bobadil: json["Bobadil"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + chlorophylligenous: json["chlorophylligenous"], + conversational: json["conversational"], + demiowl: json["demiowl"], + disdiapason: json["disdiapason"], + ectorhinal: json["ectorhinal"], + gamblesomeness: json["gamblesomeness"], + homocerc: json["homocerc"], + irrorate: json["irrorate"], + kindergartening: json["kindergartening"], + lateritic: json["lateritic"], + mespil: json["mespil"], + misconfiguration: json["misconfiguration"], + nonbookish: json["nonbookish"], + planometry: json["planometry"], + quiina: json["Quiina"], + robert: json["Robert"], + rot: json["rot"], + subcinctorium: json["subcinctorium"], + tussocker: json["tussocker"], + ultraproud: json["ultraproud"], + unsuggestedness: json["unsuggestedness"], + ); + + Map toJson() => { + "acerin": acerin, + "Bobadil": bobadil, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "chlorophylligenous": chlorophylligenous, + "conversational": conversational, + "demiowl": demiowl, + "disdiapason": disdiapason, + "ectorhinal": ectorhinal, + "gamblesomeness": gamblesomeness, + "homocerc": homocerc, + "irrorate": irrorate, + "kindergartening": kindergartening, + "lateritic": lateritic, + "mespil": mespil, + "misconfiguration": misconfiguration, + "nonbookish": nonbookish, + "planometry": planometry, + "Quiina": quiina, + "Robert": robert, + "rot": rot, + "subcinctorium": subcinctorium, + "tussocker": tussocker, + "ultraproud": ultraproud, + "unsuggestedness": unsuggestedness, + }; +} + +class UnstressedClass { + dynamic alain; + dynamic amphirhina; + dynamic antimachinery; + dynamic coldish; + dynamic crantara; + dynamic distinguishing; + dynamic elytroposis; + dynamic gentianwort; + dynamic heliosis; + dynamic instrumental; + dynamic introinflection; + dynamic kala; + dynamic lincolnian; + dynamic metad; + dynamic sarcophilus; + dynamic swingingly; + dynamic unconformity; + dynamic undecreed; + dynamic venerable; + dynamic vowellessness; + + UnstressedClass({ + required this.alain, + required this.amphirhina, + required this.antimachinery, + required this.coldish, + required this.crantara, + required this.distinguishing, + required this.elytroposis, + required this.gentianwort, + required this.heliosis, + required this.instrumental, + required this.introinflection, + required this.kala, + required this.lincolnian, + required this.metad, + required this.sarcophilus, + required this.swingingly, + required this.unconformity, + required this.undecreed, + required this.venerable, + required this.vowellessness, + }); + + factory UnstressedClass.fromJson(Map json) => UnstressedClass( + alain: json["Alain"], + amphirhina: json["Amphirhina"], + antimachinery: json["antimachinery"], + coldish: json["coldish"], + crantara: json["crantara"], + distinguishing: json["distinguishing"], + elytroposis: json["elytroposis"], + gentianwort: json["gentianwort"], + heliosis: json["heliosis"], + instrumental: json["instrumental"], + introinflection: json["introinflection"], + kala: json["kala"], + lincolnian: json["Lincolnian"], + metad: json["metad"], + sarcophilus: json["Sarcophilus"], + swingingly: json["swingingly"], + unconformity: json["unconformity"], + undecreed: json["undecreed"], + venerable: json["venerable"], + vowellessness: json["vowellessness"], + ); + + Map toJson() => { + "Alain": alain, + "Amphirhina": amphirhina, + "antimachinery": antimachinery, + "coldish": coldish, + "crantara": crantara, + "distinguishing": distinguishing, + "elytroposis": elytroposis, + "gentianwort": gentianwort, + "heliosis": heliosis, + "instrumental": instrumental, + "introinflection": introinflection, + "kala": kala, + "Lincolnian": lincolnian, + "metad": metad, + "Sarcophilus": sarcophilus, + "swingingly": swingingly, + "unconformity": unconformity, + "undecreed": undecreed, + "venerable": venerable, + "vowellessness": vowellessness, + }; +} + +class WrothyClass { + dynamic aeschynanthus; + dynamic aquiferous; + dynamic cheapener; + dynamic enumeration; + dynamic ephesine; + dynamic escadrille; + dynamic estrous; + dynamic interestedly; + dynamic katakinetomer; + dynamic mortification; + dynamic morula; + dynamic orthosymmetrical; + dynamic overbark; + dynamic politist; + dynamic qualified; + dynamic sphenomalar; + dynamic throatful; + dynamic transhumance; + dynamic triandrian; + dynamic unbooked; + + WrothyClass({ + required this.aeschynanthus, + required this.aquiferous, + required this.cheapener, + required this.enumeration, + required this.ephesine, + required this.escadrille, + required this.estrous, + required this.interestedly, + required this.katakinetomer, + required this.mortification, + required this.morula, + required this.orthosymmetrical, + required this.overbark, + required this.politist, + required this.qualified, + required this.sphenomalar, + required this.throatful, + required this.transhumance, + required this.triandrian, + required this.unbooked, + }); + + factory WrothyClass.fromJson(Map json) => WrothyClass( + aeschynanthus: json["Aeschynanthus"], + aquiferous: json["aquiferous"], + cheapener: json["cheapener"], + enumeration: json["enumeration"], + ephesine: json["Ephesine"], + escadrille: json["escadrille"], + estrous: json["estrous"], + interestedly: json["interestedly"], + katakinetomer: json["katakinetomer"], + mortification: json["mortification"], + morula: json["morula"], + orthosymmetrical: json["orthosymmetrical"], + overbark: json["overbark"], + politist: json["politist"], + qualified: json["qualified"], + sphenomalar: json["sphenomalar"], + throatful: json["throatful"], + transhumance: json["transhumance"], + triandrian: json["triandrian"], + unbooked: json["unbooked"], + ); + + Map toJson() => { + "Aeschynanthus": aeschynanthus, + "aquiferous": aquiferous, + "cheapener": cheapener, + "enumeration": enumeration, + "Ephesine": ephesine, + "escadrille": escadrille, + "estrous": estrous, + "interestedly": interestedly, + "katakinetomer": katakinetomer, + "mortification": mortification, + "morula": morula, + "orthosymmetrical": orthosymmetrical, + "overbark": overbark, + "politist": politist, + "qualified": qualified, + "sphenomalar": sphenomalar, + "throatful": throatful, + "transhumance": transhumance, + "triandrian": triandrian, + "unbooked": unbooked, + }; +} diff --git a/head/dart/test/inputs/json/priority/direct-recursive.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/direct-recursive.json/default/TopLevel.dart new file mode 100644 index 0000000..027d880 --- /dev/null +++ b/head/dart/test/inputs/json/priority/direct-recursive.json/default/TopLevel.dart @@ -0,0 +1,41 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + final TopLevel? also; + final bool bar; + final int foo; + final double moo; + final String quux; + + TopLevel({ + this.also, + required this.bar, + required this.foo, + required this.moo, + required this.quux, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + also: json["also"] == null ? null : TopLevel.fromJson(json["also"]), + bar: json["bar"], + foo: json["foo"], + moo: json["moo"]?.toDouble(), + quux: json["quux"], + ); + + Map toJson() => { + "also": also?.toJson(), + "bar": bar, + "foo": foo, + "moo": moo, + "quux": quux, + }; +} diff --git a/head/dart/test/inputs/json/priority/list.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/list.json/default/TopLevel.dart new file mode 100644 index 0000000..12bef77 --- /dev/null +++ b/head/dart/test/inputs/json/priority/list.json/default/TopLevel.dart @@ -0,0 +1,29 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + final int data; + final TopLevel? next; + + TopLevel({ + required this.data, + required this.next, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + data: json["data"], + next: json["next"] == null ? null : TopLevel.fromJson(json["next"]), + ); + + Map toJson() => { + "data": data, + "next": next?.toJson(), + }; +} diff --git a/head/dart/test/inputs/json/priority/nbl-stats.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/nbl-stats.json/default/TopLevel.dart new file mode 100644 index 0000000..abf6fd4 --- /dev/null +++ b/head/dart/test/inputs/json/priority/nbl-stats.json/default/TopLevel.dart @@ -0,0 +1,1225 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + final int attendance; + final String clock; + final int disableMatch; + final int inOt; + final List> leaddata; + final String officialsReferee1; + final String officialsReferee2; + final String officialsReferee3; + final List othermatches; + final List pbp; + final int period; + final int periodLengthOvertime; + final int periodLengthRegular; + final PerType periodType; + final int periodsMax; + final Map> scorers; + final List timeline; + final Map tm; + final int totalTimeAdded; + final Totallds totallds; + + TopLevel({ + required this.attendance, + required this.clock, + required this.disableMatch, + required this.inOt, + required this.leaddata, + required this.officialsReferee1, + required this.officialsReferee2, + required this.officialsReferee3, + required this.othermatches, + required this.pbp, + required this.period, + required this.periodLengthOvertime, + required this.periodLengthRegular, + required this.periodType, + required this.periodsMax, + required this.scorers, + required this.timeline, + required this.tm, + required this.totalTimeAdded, + required this.totallds, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + attendance: json["attendance"], + clock: json["clock"], + disableMatch: json["disableMatch"], + inOt: json["inOT"], + leaddata: List>.from(json["leaddata"].map((x) => List.from(x.map((x) => x)))), + officialsReferee1: json["officials_referee1"], + officialsReferee2: json["officials_referee2"], + officialsReferee3: json["officials_referee3"], + othermatches: List.from(json["othermatches"].map((x) => Othermatch.fromJson(x))), + pbp: List.from(json["pbp"].map((x) => Pbp.fromJson(x))), + period: json["period"], + periodLengthOvertime: json["periodLengthOVERTIME"], + periodLengthRegular: json["periodLengthREGULAR"], + periodType: perTypeValues.map[json["periodType"]]!, + periodsMax: json["periodsMax"], + scorers: Map.from(json["scorers"]).map((k, v) => MapEntry>(k, List.from(v.map((x) => Scorer.fromJson(x))))), + timeline: List.from(json["timeline"].map((x) => x)), + tm: Map.from(json["tm"]).map((k, v) => MapEntry(k, Tm.fromJson(v))), + totalTimeAdded: json["totalTimeAdded"], + totallds: Totallds.fromJson(json["totallds"]), + ); + + Map toJson() => { + "attendance": attendance, + "clock": clock, + "disableMatch": disableMatch, + "inOT": inOt, + "leaddata": List.from(leaddata.map((x) => List.from(x.map((x) => x)))), + "officials_referee1": officialsReferee1, + "officials_referee2": officialsReferee2, + "officials_referee3": officialsReferee3, + "othermatches": List.from(othermatches.map((x) => x.toJson())), + "pbp": List.from(pbp.map((x) => x.toJson())), + "period": period, + "periodLengthOVERTIME": periodLengthOvertime, + "periodLengthREGULAR": periodLengthRegular, + "periodType": perTypeValues.reverse[periodType], + "periodsMax": periodsMax, + "scorers": Map.from(scorers).map((k, v) => MapEntry(k, List.from(v.map((x) => x.toJson())))), + "timeline": List.from(timeline.map((x) => x)), + "tm": Map.from(tm).map((k, v) => MapEntry(k, v.toJson())), + "totalTimeAdded": totalTimeAdded, + "totallds": totallds.toJson(), + }; +} + +enum LeaddatumEnum { + EMPTY, + P1, + P2, + P3, + P4 +} + +final leaddatumEnumValues = EnumValues({ + "": LeaddatumEnum.EMPTY, + "P1": LeaddatumEnum.P1, + "P2": LeaddatumEnum.P2, + "P3": LeaddatumEnum.P3, + "P4": LeaddatumEnum.P4 +}); + +class Othermatch { + final String clock; + final String competitionName; + final String id; + final int period; + final PerType periodType; + final Team team1; + final String team1Name; + final int team1Score; + final Team team2; + final String team2Name; + final int team2Score; + + Othermatch({ + required this.clock, + required this.competitionName, + required this.id, + required this.period, + required this.periodType, + required this.team1, + required this.team1Name, + required this.team1Score, + required this.team2, + required this.team2Name, + required this.team2Score, + }); + + factory Othermatch.fromJson(Map json) => Othermatch( + clock: json["clock"], + competitionName: json["competitionName"], + id: json["id"], + period: json["period"], + periodType: perTypeValues.map[json["periodType"]]!, + team1: Team.fromJson(json["team1"]), + team1Name: json["team1Name"], + team1Score: json["team1Score"], + team2: Team.fromJson(json["team2"]), + team2Name: json["team2Name"], + team2Score: json["team2Score"], + ); + + Map toJson() => { + "clock": clock, + "competitionName": competitionName, + "id": id, + "period": period, + "periodType": perTypeValues.reverse[periodType], + "team1": team1.toJson(), + "team1Name": team1Name, + "team1Score": team1Score, + "team2": team2.toJson(), + "team2Name": team2Name, + "team2Score": team2Score, + }; +} + +enum PerType { + REGULAR +} + +final perTypeValues = EnumValues({ + "REGULAR": PerType.REGULAR +}); + +class Team { + final String teamCode; + final String teamCodeInternational; + final String teamName; + final String teamNameInternational; + + Team({ + required this.teamCode, + required this.teamCodeInternational, + required this.teamName, + required this.teamNameInternational, + }); + + factory Team.fromJson(Map json) => Team( + teamCode: json["teamCode"], + teamCodeInternational: json["teamCodeInternational"], + teamName: json["teamName"], + teamNameInternational: json["teamNameInternational"], + ); + + Map toJson() => { + "teamCode": teamCode, + "teamCodeInternational": teamCodeInternational, + "teamName": teamName, + "teamNameInternational": teamNameInternational, + }; +} + +class Pbp { + final ActionType actionType; + final String? familyName; + final FamilyNameInitial? familyNameInitial; + final String? firstName; + final FirstNameInitial? firstNameInitial; + final String gt; + final String? internationalFamilyName; + final FamilyNameInitial? internationalFamilyNameInitial; + final String? internationalFirstName; + final FirstNameInitial? internationalFirstNameInitial; + final int lead; + final int period; + final PerType periodType; + final String player; + final int pno; + final String qualifier; + final int s1; + final int s2; + final ScoreboardName? scoreboardName; + final int scoring; + final String shirtNumber; + final String subType; + final int success; + final int tno; + + Pbp({ + required this.actionType, + this.familyName, + this.familyNameInitial, + this.firstName, + this.firstNameInitial, + required this.gt, + this.internationalFamilyName, + this.internationalFamilyNameInitial, + this.internationalFirstName, + this.internationalFirstNameInitial, + required this.lead, + required this.period, + required this.periodType, + required this.player, + required this.pno, + required this.qualifier, + required this.s1, + required this.s2, + this.scoreboardName, + required this.scoring, + required this.shirtNumber, + required this.subType, + required this.success, + required this.tno, + }); + + factory Pbp.fromJson(Map json) => Pbp( + actionType: actionTypeValues.map[json["actionType"]]!, + familyName: json["familyName"], + familyNameInitial: familyNameInitialValues.map[json["familyNameInitial"]], + firstName: json["firstName"], + firstNameInitial: firstNameInitialValues.map[json["firstNameInitial"]], + gt: json["gt"], + internationalFamilyName: json["internationalFamilyName"], + internationalFamilyNameInitial: familyNameInitialValues.map[json["internationalFamilyNameInitial"]], + internationalFirstName: json["internationalFirstName"], + internationalFirstNameInitial: firstNameInitialValues.map[json["internationalFirstNameInitial"]], + lead: json["lead"], + period: json["period"], + periodType: perTypeValues.map[json["periodType"]]!, + player: json["player"], + pno: json["pno"], + qualifier: json["qualifier"], + s1: json["s1"], + s2: json["s2"], + scoreboardName: scoreboardNameValues.map[json["scoreboardName"]], + scoring: json["scoring"], + shirtNumber: json["shirtNumber"], + subType: json["subType"], + success: json["success"], + tno: json["tno"], + ); + + Map toJson() => { + "actionType": actionTypeValues.reverse[actionType], + "familyName": familyName, + "familyNameInitial": familyNameInitialValues.reverse[familyNameInitial], + "firstName": firstName, + "firstNameInitial": firstNameInitialValues.reverse[firstNameInitial], + "gt": gt, + "internationalFamilyName": internationalFamilyName, + "internationalFamilyNameInitial": familyNameInitialValues.reverse[internationalFamilyNameInitial], + "internationalFirstName": internationalFirstName, + "internationalFirstNameInitial": firstNameInitialValues.reverse[internationalFirstNameInitial], + "lead": lead, + "period": period, + "periodType": perTypeValues.reverse[periodType], + "player": player, + "pno": pno, + "qualifier": qualifier, + "s1": s1, + "s2": s2, + "scoreboardName": scoreboardNameValues.reverse[scoreboardName], + "scoring": scoring, + "shirtNumber": shirtNumber, + "subType": subType, + "success": success, + "tno": tno, + }; +} + +enum ActionType { + GAME, + PERIOD, + THE_3_PT, + THE_2_PT, + REBOUND, + TIMEOUT, + FOULON, + FOUL, + ASSIST, + SUBSTITUTION, + FREETHROW, + STEAL, + TURNOVER, + BLOCK, + JUMPBALL +} + +final actionTypeValues = EnumValues({ + "game": ActionType.GAME, + "period": ActionType.PERIOD, + "3pt": ActionType.THE_3_PT, + "2pt": ActionType.THE_2_PT, + "rebound": ActionType.REBOUND, + "timeout": ActionType.TIMEOUT, + "foulon": ActionType.FOULON, + "foul": ActionType.FOUL, + "assist": ActionType.ASSIST, + "substitution": ActionType.SUBSTITUTION, + "freethrow": ActionType.FREETHROW, + "steal": ActionType.STEAL, + "turnover": ActionType.TURNOVER, + "block": ActionType.BLOCK, + "jumpball": ActionType.JUMPBALL +}); + +enum FamilyNameInitial { + R, + M, + S, + C, + O, + W, + A, + P, + V, + I, + J, + FAMILY_NAME_INITIAL_S, + H, + B +} + +final familyNameInitialValues = EnumValues({ + "R": FamilyNameInitial.R, + "M": FamilyNameInitial.M, + "s": FamilyNameInitial.S, + "C": FamilyNameInitial.C, + "O": FamilyNameInitial.O, + "W": FamilyNameInitial.W, + "A": FamilyNameInitial.A, + "P": FamilyNameInitial.P, + "V": FamilyNameInitial.V, + "I": FamilyNameInitial.I, + "J": FamilyNameInitial.J, + "S": FamilyNameInitial.FAMILY_NAME_INITIAL_S, + "H": FamilyNameInitial.H, + "B": FamilyNameInitial.B +}); + +enum FirstNameInitial { + D, + J, + T, + C, + O, + H, + L, + A, + K, + R, + B, + N +} + +final firstNameInitialValues = EnumValues({ + "D": FirstNameInitial.D, + "J": FirstNameInitial.J, + "T": FirstNameInitial.T, + "C": FirstNameInitial.C, + "O": FirstNameInitial.O, + "H": FirstNameInitial.H, + "L": FirstNameInitial.L, + "A": FirstNameInitial.A, + "K": FirstNameInitial.K, + "R": FirstNameInitial.R, + "B": FirstNameInitial.B, + "N": FirstNameInitial.N +}); + +enum ScoreboardName { + EMPTY, + T_S, + R_IHATA, + D_JONES, + B_VALENTINE +} + +final scoreboardNameValues = EnumValues({ + "": ScoreboardName.EMPTY, + "T. s": ScoreboardName.T_S, + "R. Ihata": ScoreboardName.R_IHATA, + "D. Jones": ScoreboardName.D_JONES, + "B. Valentine": ScoreboardName.B_VALENTINE +}); + +class Scorer { + final String? familyName; + final FamilyNameInitial? familyNameInitial; + final String? firstName; + final FirstNameInitial? firstNameInitial; + final String? gt; + final String? internationalFamilyName; + final FamilyNameInitial? internationalFamilyNameInitial; + final String? internationalFirstName; + final FirstNameInitial? internationalFirstNameInitial; + final String? name; + final int? per; + final PerType? perType; + final String? player; + final int pno; + final ScoreboardName? scoreboardName; + final String shirtNumber; + final String? summary; + final List